"""API routes for Abstimmungen und Stimmverhalten-Analysen."""

from fastapi import APIRouter, Depends, Query

from tracker.db.session import get_connection

router = APIRouter(prefix="/abstimmungen", tags=["Abstimmungen"])


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


@router.get("/stats")
def get_abstimmungen_stats(conn=Depends(_db)):
    """Übersicht: Anzahl Abstimmungen, Ergebnisverteilung."""
    total = conn.execute("SELECT COUNT(*) FROM abstimmungen").fetchone()[0]
    
    by_ergebnis = conn.execute("""
        SELECT ergebnis, COUNT(*) as anzahl 
        FROM abstimmungen 
        WHERE ergebnis IS NOT NULL
        GROUP BY ergebnis 
        ORDER BY anzahl DESC
    """).fetchall()
    
    return {
        "total": total,
        "nach_ergebnis": [{"ergebnis": r[0], "anzahl": r[1]} for r in by_ergebnis]
    }


@router.get("/fraktionen")
def get_fraktionen_uebersicht(conn=Depends(_db)):
    """Stimmverhalten aller Fraktionen aggregiert."""
    rows = conn.execute("""
        SELECT fraktion,
               SUM(CASE WHEN stimme='ja' THEN 1 ELSE 0 END) as ja,
               SUM(CASE WHEN stimme='nein' THEN 1 ELSE 0 END) as nein,
               SUM(CASE WHEN stimme='enthaltung' THEN 1 ELSE 0 END) as enthaltung,
               COUNT(*) as gesamt
        FROM abstimmungen_fraktionen
        GROUP BY fraktion
        ORDER BY gesamt DESC
    """).fetchall()
    
    return [
        {
            "fraktion": r[0],
            "ja": r[1],
            "nein": r[2],
            "enthaltung": r[3],
            "gesamt": r[4],
            "ja_quote": round(r[1] / r[4] * 100, 1) if r[4] > 0 else 0
        }
        for r in rows
    ]


@router.get("/koalitionsmatrix")
def get_koalitionsmatrix(conn=Depends(_db)):
    """Matrix: Wie oft stimmen Fraktionen gleich ab?"""
    # Alle Abstimmungen mit mindestens 2 Fraktionen
    abstimmungen = conn.execute("""
        SELECT abstimmung_id, fraktion, stimme
        FROM abstimmungen_fraktionen
        WHERE stimme IN ('ja', 'nein')
    """).fetchall()
    
    # Gruppieren nach Abstimmung
    from collections import defaultdict
    by_abstimmung = defaultdict(dict)
    for aid, fraktion, stimme in abstimmungen:
        by_abstimmung[aid][fraktion] = stimme
    
    # Paarweise Übereinstimmung zählen
    fraktionen = list(set(r[1] for r in abstimmungen))
    matrix = {f1: {f2: {"gleich": 0, "gesamt": 0} for f2 in fraktionen} for f1 in fraktionen}
    
    for aid, stimmen in by_abstimmung.items():
        for f1 in stimmen:
            for f2 in stimmen:
                if f1 != f2:
                    matrix[f1][f2]["gesamt"] += 1
                    if stimmen[f1] == stimmen[f2]:
                        matrix[f1][f2]["gleich"] += 1
    
    # Als Liste für Frontend
    result = []
    for f1 in sorted(fraktionen):
        row = {"fraktion": f1, "uebereinstimmung": {}}
        for f2 in sorted(fraktionen):
            if f1 != f2 and matrix[f1][f2]["gesamt"] > 0:
                quote = round(matrix[f1][f2]["gleich"] / matrix[f1][f2]["gesamt"] * 100, 1)
                row["uebereinstimmung"][f2] = {
                    "quote": quote,
                    "gleich": matrix[f1][f2]["gleich"],
                    "gesamt": matrix[f1][f2]["gesamt"]
                }
        result.append(row)
    
    return result


@router.get("/ablehnungen")
def get_ablehnungsverhalten(conn=Depends(_db)):
    """Wer lehnt wessen Anträge ab?"""
    # Anträge mit Antragsteller-Fraktion und Abstimmungsverhalten
    rows = conn.execute("""
        SELECT 
            kb.anmerkungen,
            af.fraktion,
            af.stimme,
            a.ergebnis
        FROM abstimmungen a
        JOIN abstimmungen_fraktionen af ON a.id = af.abstimmung_id
        LEFT JOIN ki_bewertungen kb ON a.vorlage_id = kb.vorlage_id AND kb.typ = 'zusammenfassung'
        WHERE af.stimme IN ('ja', 'nein', 'enthaltung')
    """).fetchall()
    
    import json
    from collections import defaultdict
    
    # antragsteller -> abstimmende_fraktion -> stimme -> count
    matrix = defaultdict(lambda: defaultdict(lambda: {"ja": 0, "nein": 0, "enthaltung": 0}))
    
    for anmerkungen, fraktion, stimme, ergebnis in rows:
        if not anmerkungen:
            continue
        try:
            data = json.loads(anmerkungen)
            antragsteller = data.get("partei")
            if isinstance(antragsteller, list):
                antragsteller = antragsteller[0] if antragsteller else None
            if antragsteller and antragsteller != fraktion:
                matrix[antragsteller][fraktion][stimme] += 1
        except:
            continue
    
    # Als Liste
    result = []
    for antragsteller, abstimmungen in sorted(matrix.items()):
        result.append({
            "antragsteller": antragsteller,
            "abstimmungen": {
                f: counts for f, counts in sorted(abstimmungen.items())
            }
        })
    
    return result


@router.get("/vorlage/{vorlage_id}")
def get_abstimmungen_fuer_vorlage(vorlage_id: int, conn=Depends(_db)):
    """Alle Abstimmungen zu einer Vorlage."""
    abstimmungen = conn.execute("""
        SELECT a.id, a.sitzung_datum, a.ergebnis, a.volltext, g.name as gremium
        FROM abstimmungen a
        LEFT JOIN gremien g ON a.gremium_id = g.id
        WHERE a.vorlage_id = ?
        ORDER BY a.sitzung_datum
    """, (vorlage_id,)).fetchall()
    
    result = []
    for a in abstimmungen:
        fraktionen = conn.execute("""
            SELECT fraktion, stimme, anzahl, bemerkung
            FROM abstimmungen_fraktionen
            WHERE abstimmung_id = ?
        """, (a[0],)).fetchall()
        
        result.append({
            "id": a[0],
            "sitzung_datum": a[1],
            "ergebnis": a[2],
            "volltext": a[3],
            "gremium": a[4],
            "fraktionen": [
                {"fraktion": f[0], "stimme": f[1], "anzahl": f[2], "bemerkung": f[3]}
                for f in fraktionen
            ]
        })
    
    return result
