"""Interpretacje: wynik obliczeń szukany w bazach."""
from __future__ import annotations

from fastapi import Depends, Form, Request
from fastapi.responses import HTMLResponse, Response
import httpx

from app.features import Feature
from app.podstawa import (features, 
    app,
    templates,
    logic,
    security,
    DEFAULT_LOCATION_LABEL,
    default_form,
    rozszerzenia,
    _build_utc,
    _dozwolona_akcja,
    _report_records,
    _logic_error,
)

# ---------------- Interpretacje (wynik obliczeń szukany w bazie) ----------------
@app.get("/interpret", response_class=HTMLResponse)
def interpret_form(request: Request):
    return templates.TemplateResponse(
        request, "interpret.html",
        {"result": None, "form": default_form(), "location_label": DEFAULT_LOCATION_LABEL,
         **rozszerzenia.kontekst_szablonu(request)},
    )


@app.post("/interpret", response_class=HTMLResponse)
def interpret_run(
    request: Request,
    person: str = Form(""),          # imie i nazwisko — do naglowka raportu (PRE-21/24)
    date: str = Form(...),
    time: str = Form(...),
    tz_offset: float = Form(0.0),
    lat: float = Form(0.0),
    lon: float = Form(0.0),
    group: bool = Form(False),
    action: str = Form("report"),
    # Pola wnoszone przez moduły opcjonalne. FastAPI czyta pola z sygnatury, a ta
    # nie może ich wymieniać — w obrazie bez modułu byłyby nazwą nieistniejącej
    # funkcji wpisaną w kod. Zależność przenosi deklarację do modułu.
    dodatki: dict = Depends(rozszerzenia.pola_formularza()),
):
    form = {"person": person, "date": date, "time": time, "tz_offset": tz_offset,
            "lat": lat, "lon": lon, "group": group, **dodatki}
    action = _dozwolona_akcja(request, action, "report")
    ctx: dict = {"form": form, "result": None, "error": None, "moment": None,
                 **rozszerzenia.kontekst_szablonu(request)}
    try:
        iso_utc, label = _build_utc(date, time, tz_offset)
        ctx["moment"] = label
        # Akcja może należeć do modułu opcjonalnego. `None` znaczy „nie jego",
        # więc ekran robi to, co robi normalnie. Moduł może oddać słownik do
        # kontekstu albo gotową odpowiedź — na przykład plik do pobrania.
        wynik = rozszerzenia.obsluz(action, profil="natal", iso_utc=iso_utc,
                                    lat=lat, lon=lon, dodatki=dodatki,
                                    request=request, group=group)
        if isinstance(wynik, Response):
            return wynik
        if wynik is not None:
            ctx["wynik_dodatku"] = wynik
        else:
            ctx["result"] = logic.report(when_utc_iso=iso_utc, lat=lat, lon=lon, group=group)
            security.audit_records(request, _report_records(ctx["result"]))
    except httpx.HTTPError as e:
        ctx["error"] = _logic_error(e)
    except ValueError as e:
        ctx["error"] = f"Niepoprawne dane wejściowe: {e}"
    return templates.TemplateResponse(request, "interpret.html", ctx)

features.zarejestruj(
    ekran=Feature("interpret", "Interpretacje", "Interpretacja natalna z baz.",
                  "Ekrany", "/interpret", kolejnosc=20),
    trasy={("GET", "/interpret"): "interpret", ("POST", "/interpret"): "interpret"},
    zasoby={"s-interpret.css": "interpret"},
)