from __future__ import annotations

from dataclasses import dataclass
from typing import Any, Dict, List, Optional

from apps.aroflo_connector_app.core.client import AroFloClient


@dataclass
class UserFilters:
    """
    Filtros simples para la zona Users.

    Ojo: aquí NO usamos lastupdateutc, porque esa columna
    no está disponible en la zona Users.
    """

    userid: Optional[str] = None
    email: Optional[str] = None  # por si en el futuro quieres filtrar
    name_contains: Optional[str] = None  # idem


class UsersService:
    """
    Servicio para leer usuarios desde la zona 'users' de AroFlo.

    Importante:
    - No usamos lastupdateutc en WHERE ni en ORDER.
    - Si no se pasan filtros, NO enviamos WHERE: dejamos que
      AroFlo aplique su filtro por defecto.
    """

    def __init__(self, client: AroFloClient) -> None:
        self.client = client

    def _build_filters_dict(self, filters: Optional[UserFilters]) -> Dict[str, Any]:
        """
        Convierte UserFilters en un dict plano que se enviará
        como querystring (filters=...) al cliente.
        """
        if not filters:
            return {}

        data: Dict[str, Any] = {}

        if filters.userid:
            data["userid"] = filters.userid

        # Estos solo los dejo listos por si AroFlo soporta campos
        # directos tipo 'email' o similar en la zona users.
        if filters.email:
            data["email"] = filters.email

        # Si AroFlo soporta algo como 'namecontains', se podría mapear aquí.
        # Lo dejo como comentario para el futuro:
        # if filters.name_contains:
        #     data["namecontains"] = filters.name_contains

        return data

    def list_users(
        self,
        *,
        filters: Optional[UserFilters] = None,
        page: int = 1,
        include_raw: bool = False,
    ) -> Dict[str, Any]:
        """
        Devuelve usuarios desde la zona 'users'.

        - NO construye WHERE.
        - NO manda ORDER.
        - Solo pasa filtros directos como query params.
        """
        filters_dict = self._build_filters_dict(filters)

        # Aquí no mandamos where ni order, justo para evitar el problema
        # con lastupdateutc. Solo zone + page + filters.
        response = self.client.request(
            zone="users",
            filters=filters_dict,
            page=page,
            method="GET",
        )

        if include_raw:
            return response

        zone = response.get("zoneresponse", {})
        users: List[Dict[str, Any]] = zone.get("users", [])

        return {
            "users": users,
            "pagenumber": int(zone.get("pagenumber", "1")),
            "currentpageresults": int(zone.get("currentpageresults", "0")),
            "maxpageresults": int(zone.get("maxpageresults", "0")),
        }