from fastapi import APIRouter, Depends, HTTPException, Query, status

from app.api.deps import require_session
from app.services.tenant_store import (
    SessionIdentity,
    TimeclockOverviewQuery,
    TimeclockScheduleQuery,
    TimeclockScheduleWritePayload,
    get_tenant_store,
)


router = APIRouter()


def _raise_timeclock_error(exc: ValueError) -> None:
    detail = str(exc)
    status_code = status.HTTP_403_FORBIDDEN if "non puo accedere" in detail.lower() else status.HTTP_400_BAD_REQUEST
    raise HTTPException(status_code=status_code, detail=detail) from exc


@router.get("/status")
def get_timeclock_status(session: SessionIdentity = Depends(require_session)) -> dict[str, object]:
    try:
        return get_tenant_store().get_timeclock_status(session)
    except ValueError as exc:
        _raise_timeclock_error(exc)


@router.post("/start")
def start_timeclock_shift(session: SessionIdentity = Depends(require_session)) -> dict[str, object]:
    try:
        return get_tenant_store().start_timeclock_shift(session)
    except ValueError as exc:
        _raise_timeclock_error(exc)


@router.post("/stop")
def stop_timeclock_shift(session: SessionIdentity = Depends(require_session)) -> dict[str, object]:
    try:
        return get_tenant_store().stop_timeclock_shift(session)
    except ValueError as exc:
        _raise_timeclock_error(exc)


@router.get("/overview")
def get_timeclock_overview(
    user_id: str | None = Query(default=None),
    start_date: str | None = Query(default=None),
    end_date: str | None = Query(default=None),
    limit: int = Query(default=200, ge=1, le=1000),
    session: SessionIdentity = Depends(require_session),
) -> dict[str, object]:
    try:
        query = TimeclockOverviewQuery(user_id=user_id, start_date=start_date, end_date=end_date, limit=limit)
        return get_tenant_store().get_timeclock_overview(session, query)
    except ValueError as exc:
        _raise_timeclock_error(exc)


@router.get("/schedule")
def list_timeclock_schedules(
    start_date: str = Query(min_length=10, max_length=10),
    end_date: str = Query(min_length=10, max_length=10),
    user_id: str | None = Query(default=None),
    session: SessionIdentity = Depends(require_session),
) -> dict[str, object]:
    try:
        query = TimeclockScheduleQuery(user_id=user_id, start_date=start_date, end_date=end_date)
        return get_tenant_store().list_timeclock_schedules(session, query)
    except ValueError as exc:
        _raise_timeclock_error(exc)


@router.post("/schedule")
def create_timeclock_schedule(
    payload: TimeclockScheduleWritePayload,
    session: SessionIdentity = Depends(require_session),
) -> dict[str, object]:
    try:
        return get_tenant_store().create_timeclock_schedule(session, payload)
    except ValueError as exc:
        _raise_timeclock_error(exc)


@router.put("/schedule/{schedule_id}")
def update_timeclock_schedule(
    schedule_id: str,
    payload: TimeclockScheduleWritePayload,
    session: SessionIdentity = Depends(require_session),
) -> dict[str, object]:
    try:
        return get_tenant_store().update_timeclock_schedule(session, schedule_id, payload)
    except KeyError as exc:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=exc.args[0] if exc.args else str(exc)) from exc
    except ValueError as exc:
        _raise_timeclock_error(exc)


@router.delete("/schedule/{schedule_id}")
def delete_timeclock_schedule(
    schedule_id: str,
    session: SessionIdentity = Depends(require_session),
) -> dict[str, object]:
    try:
        return get_tenant_store().delete_timeclock_schedule(session, schedule_id)
    except KeyError as exc:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=exc.args[0] if exc.args else str(exc)) from exc
    except ValueError as exc:
        _raise_timeclock_error(exc)