"""API routes for Vorlagen."""

from fastapi import APIRouter, Depends, HTTPException, Query

import json

from tracker.api.models import (
    BeratungOut,
    GremiumOut,
    KiZusammenfassung,
    PaginatedVorlagen,
    ParteiOut,
    ReferenzOut,
    VorlageDetail,
    VorlageKurz,
)
from tracker.core.graph import get_references_for_vorlage
from tracker.db.session import get_connection

router = APIRouter(prefix="/vorlagen", tags=["Vorlagen"])


def _db():
    conn = get_connection()
    try:
        yield conn
    finally:
        conn.close()


@router.get("", response_model=PaginatedVorlagen)
def list_vorlagen(
    page: int = Query(1, ge=1),
    page_size: int = Query(50, ge=1, le=200),
    typ: str | None = None,
    suche: str | None = None,
    conn=Depends(_db),
):
    """List Vorlagen with optional filters."""
    where_clauses = []
    params: list = []

    if typ:
        where_clauses.append("v.typ = ?")
        params.append(typ)

    if suche:
        where_clauses.append("(v.betreff LIKE ? OR v.aktenzeichen LIKE ?)")
        params.extend([f"%{suche}%", f"%{suche}%"])

    where_sql = ("WHERE " + " AND ".join(where_clauses)) if where_clauses else ""

    total = conn.execute(
        f"SELECT COUNT(*) as cnt FROM vorlagen v {where_sql}", params
    ).fetchone()["cnt"]

    offset = (page - 1) * page_size
    rows = conn.execute(
        f"""SELECT v.id, v.aktenzeichen, v.typ, v.betreff, v.datum_eingang,
                   v.ist_verwaltungsvorlage
            FROM vorlagen v {where_sql}
            ORDER BY v.datum_eingang DESC NULLS LAST, v.id DESC
            LIMIT ? OFFSET ?""",
        params + [page_size, offset],
    ).fetchall()

    items = [
        VorlageKurz(
            id=r["id"],
            aktenzeichen=r["aktenzeichen"],
            typ=r["typ"],
            betreff=r["betreff"],
            datum_eingang=r["datum_eingang"],
            ist_verwaltungsvorlage=bool(r["ist_verwaltungsvorlage"]),
        )
        for r in rows
    ]

    return PaginatedVorlagen(items=items, total=total, page=page, page_size=page_size)


@router.get("/{vorlage_id}", response_model=VorlageDetail)
def get_vorlage(vorlage_id: int, conn=Depends(_db)):
    """Get a single Vorlage with all details."""
    row = conn.execute(
        """SELECT id, aktenzeichen, aktenzeichen_basis, aktenzeichen_suffix,
                  typ, betreff, volltext_clean, datum_eingang, pdf_url, web_url,
                  ist_verwaltungsvorlage, thema_kurz
           FROM vorlagen WHERE id = ?""",
        (vorlage_id,),
    ).fetchone()

    if not row:
        raise HTTPException(status_code=404, detail="Vorlage nicht gefunden")

    # Antragsteller
    antragsteller = conn.execute(
        """SELECT p.id, p.kuerzel, p.name, p.farbe
           FROM antragsteller a
           JOIN parteien p ON a.partei_id = p.id
           WHERE a.vorlage_id = ?""",
        (vorlage_id,),
    ).fetchall()

    # Beratungen
    beratungen_rows = conn.execute(
        """SELECT b.id, b.sitzung_datum, b.rolle, b.ergebnis, b.ergebnis_text,
                  g.id as g_id, g.name as g_name, g.kuerzel as g_kuerzel, g.typ as g_typ
           FROM beratungen b
           LEFT JOIN gremien g ON b.gremium_id = g.id
           WHERE b.vorlage_id = ?
           ORDER BY b.sitzung_datum DESC NULLS LAST""",
        (vorlage_id,),
    ).fetchall()

    beratungen = [
        BeratungOut(
            id=b["id"],
            gremium=GremiumOut(id=b["g_id"], name=b["g_name"], kuerzel=b["g_kuerzel"], typ=b["g_typ"])
            if b["g_id"]
            else None,
            sitzung_datum=b["sitzung_datum"],
            rolle=b["rolle"],
            ergebnis=b["ergebnis"],
            ergebnis_text=b["ergebnis_text"],
        )
        for b in beratungen_rows
    ]

    # Referenzen
    refs = get_references_for_vorlage(conn, vorlage_id)

    # Kette-Zugehörigkeit
    kette_row = conn.execute(
        "SELECT kette_id FROM ketten_glieder WHERE vorlage_id = ? LIMIT 1",
        (vorlage_id,),
    ).fetchone()

    # KI-Zusammenfassung
    ki_row = conn.execute(
        "SELECT anmerkungen FROM ki_bewertungen WHERE vorlage_id = ? AND typ = 'zusammenfassung' LIMIT 1",
        (vorlage_id,),
    ).fetchone()
    ki_zusammenfassung = None
    if ki_row and ki_row["anmerkungen"]:
        try:
            ki_data = json.loads(ki_row["anmerkungen"])
            ki_zusammenfassung = KiZusammenfassung(**ki_data)
        except (json.JSONDecodeError, TypeError):
            pass

    return VorlageDetail(
        id=row["id"],
        aktenzeichen=row["aktenzeichen"],
        aktenzeichen_basis=row["aktenzeichen_basis"],
        aktenzeichen_suffix=row["aktenzeichen_suffix"],
        typ=row["typ"],
        betreff=row["betreff"],
        volltext_clean=row["volltext_clean"],
        datum_eingang=row["datum_eingang"],
        pdf_url=row["pdf_url"],
        web_url=row["web_url"],
        ist_verwaltungsvorlage=bool(row["ist_verwaltungsvorlage"]),
        thema_kurz=row["thema_kurz"],
        antragsteller=[ParteiOut(**dict(a)) for a in antragsteller],
        beratungen=beratungen,
        referenzen_ausgehend=[ReferenzOut(**r) for r in refs["ausgehend"]],
        referenzen_eingehend=[ReferenzOut(**r) for r in refs["eingehend"]],
        kette_id=kette_row["kette_id"] if kette_row else None,
        ki_zusammenfassung=ki_zusammenfassung,
    )
