"""Public, cacheable standard reference data for dashboard and platform form controls."""
from __future__ import annotations

from fastapi import APIRouter, HTTPException, Query

from src.domain.reference_data.catalog import (
    CATALOG_VERSION,
    countries,
    currencies,
    languages,
    subdivisions,
    timezones,
)
from src.domain.reference_data.schemas import (
    CountryResponse,
    CurrencyResponse,
    LanguageResponse,
    ReferenceDataMetaResponse,
    SubdivisionResponse,
    TimezoneResponse,
)

router = APIRouter(prefix="/api/reference-data", tags=["reference-data"])


@router.get("/meta", response_model=ReferenceDataMetaResponse)
async def get_reference_data_meta() -> ReferenceDataMetaResponse:
    return ReferenceDataMetaResponse(
        catalog_version=CATALOG_VERSION,
        country_count=len(countries()),
        currency_count=len(currencies()),
        language_count=len(languages()),
        timezone_count=len(timezones()),
    )


@router.get("/countries", response_model=list[CountryResponse])
async def list_countries(
    query: str | None = Query(default=None, min_length=1, max_length=100),
    include: list[str] | None = Query(default=None),
) -> list[dict[str, object]]:
    """List ISO countries. ``include`` limits results to selected alpha-2 codes."""
    selected = {item.strip().upper() for item in include or [] if item.strip()}
    needle = (query or "").strip().casefold()
    return [
        row for row in countries()
        if (not selected or row["code"] in selected)
        and (
            not needle
            or needle in str(row["name"]).casefold()
            or needle in str(row["code"]).casefold()
        )
    ]


@router.get("/countries/{country_code}/subdivisions", response_model=list[SubdivisionResponse])
async def list_subdivisions(country_code: str) -> list[dict[str, str]]:
    try:
        return subdivisions(country_code)
    except ValueError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


@router.get("/currencies", response_model=list[CurrencyResponse])
async def list_currencies(
    query: str | None = Query(default=None, min_length=1, max_length=100),
) -> list[dict[str, object]]:
    """List ISO 4217 currencies."""
    needle = (query or "").strip().casefold()
    return [
        row for row in currencies()
        if not needle
        or needle in str(row["name"]).casefold()
        or needle in str(row["code"]).casefold()
    ]


@router.get("/languages", response_model=list[LanguageResponse])
async def list_languages(
    query: str | None = Query(default=None, min_length=1, max_length=100),
) -> list[dict[str, object]]:
    """List ISO 639-1 languages."""
    needle = (query or "").strip().casefold()
    return [
        row for row in languages()
        if not needle
        or needle in str(row["name"]).casefold()
        or needle in str(row["code"]).casefold()
    ]


@router.get("/timezones", response_model=list[TimezoneResponse])
async def list_timezones() -> list[dict[str, object]]:
    """List IANA timezones with their current UTC offset."""
    return list(timezones())