"""HTTP routes for planned leave days (calendar planning)."""

from datetime import date
from uuid import UUID

from fastapi import APIRouter, HTTPException, Query, status

from app.dependencies import AnalyticsServiceDep, CurrentUserDep, PlanningServiceDep
from app.models.planned_leave import (
    PlannedLeaveDayCreate,
    PlannedLeaveDayResponse,
    PlannedLeaveDayUpdate,
)
from app.utils.errors import NotFoundError, ValidationError

router = APIRouter(prefix="/api/planned-days", tags=["planned-days"])


def _to_response(day) -> PlannedLeaveDayResponse:
    return PlannedLeaveDayResponse.from_entity(day)


@router.post("", response_model=PlannedLeaveDayResponse, status_code=status.HTTP_201_CREATED)
async def create_planned_day(
    payload: PlannedLeaveDayCreate,
    service: PlanningServiceDep,
    _current_user: CurrentUserDep,
) -> PlannedLeaveDayResponse:
    try:
        day = await service.add_planned_day(
            workspace_id=payload.workspace_id,
            child_id=payload.child_id,
            parent_personal_data_uuid=payload.parent_personal_data_uuid,
            date=payload.date,
            day_type=payload.day_type,
            is_dubbeldag=payload.is_dubbeldag,
        )
        return _to_response(day)
    except ValidationError as exc:
        raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY, str(exc)) from exc


@router.get("/{planned_leave_day_id}", response_model=PlannedLeaveDayResponse)
async def get_planned_day(
    planned_leave_day_id: UUID,
    service: PlanningServiceDep,
    _current_user: CurrentUserDep,
) -> PlannedLeaveDayResponse:
    try:
        day = await service.get(planned_leave_day_id)
        return _to_response(day)
    except NotFoundError as exc:
        raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc


@router.get("/workspace/{workspace_id}", response_model=list[PlannedLeaveDayResponse])
async def list_planned_days_by_workspace(
    workspace_id: UUID,
    service: PlanningServiceDep,
    _current_user: CurrentUserDep,
) -> list[PlannedLeaveDayResponse]:
    days = await service.list_by_workspace(workspace_id)
    return [_to_response(d) for d in days]


@router.get("/range", response_model=list[PlannedLeaveDayResponse])
async def list_planned_days_by_range(
    workspace_id: UUID = Query(...),
    child_id: UUID = Query(...),
    start_date: date = Query(...),
    end_date: date = Query(...),
    service: PlanningServiceDep = None,
    _current_user: CurrentUserDep = None,
) -> list[PlannedLeaveDayResponse]:
    # Inject dependencies manually for query parameters
    from app.dependencies import PlanningServiceDep as PSep
    from app.dependencies import CurrentUserDep as CUD

    # Since we can't easily pass Query params with FastAPI dependencies,
    # we'll need to inject them differently
    pass


@router.delete("/{planned_leave_day_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_planned_day(
    planned_leave_day_id: UUID,
    service: PlanningServiceDep,
    _current_user: CurrentUserDep,
) -> None:
    try:
        await service.remove_planned_day(planned_leave_day_id)
    except NotFoundError as exc:
        raise HTTPException(status.HTTP_404_NOT_FOUND, str(exc)) from exc