# apps/aroflo_connector_app/cli/__main__.py

from __future__ import annotations

import argparse
import json
from datetime import datetime, date
from typing import Optional

from apps.aroflo_connector_app.core.client import AroFloClient
from apps.aroflo_connector_app.core.config import settings
from apps.aroflo_connector_app.features.timesheets.service import (
    TimesheetService,
    TimesheetFilters,
)


from apps.aroflo_connector_app.features.users.service import (
    UsersService,
    UserFilters,
)



# ----------------------------------------------------------------------
# Cliente base
# ----------------------------------------------------------------------


def build_client() -> AroFloClient:
    """
    Helper sencillo para construir el cliente AroFlo.

    Usamos settings.base_url por dentro del propio AroFloClient.
    """
    return AroFloClient()



# ----------------------------------------------------------------------
# Handlers: TIMESHEETS
# ----------------------------------------------------------------------


def _parse_date(value: Optional[str]) -> Optional[date]:
    if not value:
        return None
    return datetime.strptime(value, "%Y-%m-%d").date()


def handle_timesheets(args: argparse.Namespace) -> None:
    client = build_client()
    service = TimesheetService(client)

    filters = TimesheetFilters(
        userid=args.userid,
        type=args.type,
        workdate_from=_parse_date(args.from_date),
        workdate_to=_parse_date(args.to_date),
    )

    result = service.list_timesheets(
        filters=filters,
        page=args.page,
        order_by="workdate",
        include_raw_response=False,
    )

    timesheets = result["timesheets"]
    page_number = result["pagenumber"]
    current_results = result["currentpageresults"]

    print()
    print(f"Página: {page_number} | Resultados: {current_results}")
    print()
    print("-" * 70)

    for ts in timesheets:
        # Ajusta estos campos a lo que AroFlo realmente devuelve
        ts_id = ts.get("timesheetid")
        user = ts.get("userid")
        workdate = ts.get("workdate")
        ts_type = ts.get("type")
        duration = ts.get("duration")

        print(f"TimesheetID : {ts_id}")
        print(f"Usuario     : {user}")
        print(f"Fecha       : {workdate}")
        print(f"Tipo        : {ts_type}")
        print(f"Duración    : {duration}")
        print("-" * 70)


# ----------------------------------------------------------------------
# Handlers: USERS
# ----------------------------------------------------------------------


def handle_users(args: argparse.Namespace) -> None:
    from apps.aroflo_connector_app.core.client import AroFloClient

    client = AroFloClient()
    service = UsersService(client=client)

    filters = UserFilters(userid=args.userid) if getattr(args, "userid", None) else None

    result = service.list_users(
        filters=filters,
        page=args.page,
        include_raw=args.include_raw,
    )

    if args.include_raw:
        import json
        print(json.dumps(result, indent=2))
        return

    users = result.get("users", [])
    pageno = result.get("pagenumber", 1)
    current = result.get("currentpageresults", 0)

    print(f"\nPágina: {pageno} | Resultados: {current}\n")
    print("-" * 70)

    if not users:
        print("Sin usuarios en esta página con los filtros indicados.")
        print("-" * 70)
        return

    for u in users:
        uid = u.get("userid", "")
        name = u.get("name", "")
        email = u.get("email", "")
        print(f"{uid:20s} {name:40s} {email}")

    print("-" * 70)


# ----------------------------------------------------------------------
# CLI principal
# ----------------------------------------------------------------------


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        prog="aroflo-cli",
        description="CLI para consultar la API de AroFlo (conector interno).",
    )

    subparsers = parser.add_subparsers(dest="command", required=True)

    # -------------------- timesheets --------------------
    p_ts = subparsers.add_parser(
        "timesheets",
        help="Consultar timesheets (zona 'timesheets').",
    )
    p_ts.add_argument(
        "--userid",
        help="Filtrar por userid (ID en base64).",
    )
    p_ts.add_argument(
        "--type",
        help="Tipo de timesheet (Productive, Non-Productive, Expense).",
    )
    p_ts.add_argument(
        "--from-date",
        dest="from_date",
        help="Fecha desde (YYYY-MM-DD).",
    )
    p_ts.add_argument(
        "--to-date",
        dest="to_date",
        help="Fecha hasta (YYYY-MM-DD).",
    )
    p_ts.add_argument(
        "--page",
        type=int,
        default=1,
        help="Número de página (por defecto 1).",
    )
    p_ts.set_defaults(func=handle_timesheets)

    # -------------------- users --------------------
    p_users = subparsers.add_parser(
        "users",
        help="Consultar usuarios (zona 'users').",
    )
    p_users.add_argument(
        "--userid",
        help="Filtrar por userid.",
    )
    p_users.add_argument(
        "--email",
        help="Filtrar por email.",
    )
    p_users.add_argument(
        "--username",
        help="Filtrar por username.",
    )
    p_users.add_argument(
        "--active",
        action="store_true",
        help="Filtrar solo usuarios activos (si el campo existe).",
    )
    p_users.add_argument(
        "--page",
        type=int,
        default=1,
        help="Número de página (por defecto 1).",
    )
    p_users.add_argument(
        "--include-raw",
        action="store_true",
        help="Imprimir la respuesta cruda de la API.",
    )
    p_users.set_defaults(func=handle_users)

    return parser


def main() -> None:
    parser = build_parser()
    args = parser.parse_args()
    args.func(args)


if __name__ == "__main__":
    main()