"""Bereits geschaute Filme und ihre Bewertungen.

Der Host trägt ein, was am Abend lief. Bewerten darf jeder, eine Stimme
je Sitzung — dieselbe Cookie-Sitzung wie bei den Vorschlägen. Der Name ist
freiwillig, ohne ihn zählt die Stimme trotzdem.

Titel und Poster werden mitgespeichert, damit ein Eintrag lesbar bleibt,
auch wenn der Film später aus dem Katalog fällt.
"""

from datetime import datetime, timezone

from . import users
from .db import connect
from .users import WEM, besitzer, gehoert_mir

SCHEMA = """
CREATE TABLE IF NOT EXISTS watched (
    id          INTEGER PRIMARY KEY AUTOINCREMENT,
    movie_id    INTEGER NOT NULL UNIQUE,
    title       TEXT NOT NULL,
    year        INTEGER,
    poster_path TEXT,
    watched_at  TEXT NOT NULL,
    hidden      INTEGER NOT NULL DEFAULT 0
);
"""

RATINGS = """
CREATE TABLE IF NOT EXISTS ratings (
    id         INTEGER PRIMARY KEY AUTOINCREMENT,
    watched_id INTEGER NOT NULL,
    session_id TEXT NOT NULL,
    user_id    INTEGER,
    stars      INTEGER NOT NULL,
    name       TEXT,
    created_at TEXT NOT NULL
);
"""

MAX_STERNE = 5


def init():
    with connect() as conn:
        conn.executescript(SCHEMA + RATINGS)
        # Eine Stimme je Person und Film
        users.je_person(conn, "ratings", RATINGS, "watched_id")
        # Die Tabelle stand vor der Spalte schon in bestehenden Datenbanken
        spalten = {r["name"] for r in conn.execute("PRAGMA table_info(watched)")}
        if "hidden" not in spalten:
            conn.execute(
                "ALTER TABLE watched ADD COLUMN hidden INTEGER NOT NULL DEFAULT 0"
            )


def _jetzt():
    return datetime.now(timezone.utc).isoformat(timespec="seconds")


def alle(session_id):
    """Zuletzt geschaut zuerst, mit Schnitt und der eigenen Stimme."""
    with connect() as conn:
        filme = conn.execute(
            "SELECT * FROM watched ORDER BY watched_at DESC, id DESC"
        ).fetchall()
        stimmen = conn.execute(
            "SELECT id, watched_id, session_id, user_id, stars, name FROM ratings "
            "ORDER BY created_at ASC"
        ).fetchall()

    ich = besitzer(session_id)
    je_film = {}
    for s in stimmen:
        je_film.setdefault(s["watched_id"], []).append(s)

    out = []
    for film in filme:
        eigene = je_film.get(film["id"], [])
        werte = [s["stars"] for s in eigene]
        out.append(
            {
                **dict(film),
                "ratings": [
                    {"id": s["id"], "stars": s["stars"], "name": s["name"]}
                    for s in eigene
                ],
                "average": round(sum(werte) / len(werte), 1) if werte else None,
                "count": len(werte),
                "mine": next(
                    (
                        s["stars"]
                        for s in eigene
                        if gehoert_mir(s, session_id, ich)
                    ),
                    None,
                ),
            }
        )
    return out


def markieren(movie):
    """Film als geschaut eintragen. Ein zweiter Klick ändert nichts."""
    with connect() as conn:
        conn.execute(
            "INSERT OR IGNORE INTO watched "
            "(movie_id, title, year, poster_path, watched_at) "
            "VALUES (?, ?, ?, ?, ?)",
            (
                movie["id"],
                movie["title"],
                movie.get("year"),
                movie.get("poster_path"),
                _jetzt(),
            ),
        )
        row = conn.execute(
            "SELECT * FROM watched WHERE movie_id = ?", (movie["id"],)
        ).fetchone()
    return dict(row)


def entfernen(watched_id):
    with connect() as conn:
        conn.execute("DELETE FROM ratings WHERE watched_id = ?", (watched_id,))
        return conn.execute(
            "DELETE FROM watched WHERE id = ?", (watched_id,)
        ).rowcount


def datum_setzen(watched_id, tag):
    """tag im Format JJJJ-MM-TT. Mittags in UTC, damit die Anzeige in
    keiner Zeitzone auf den Nachbartag rutscht."""
    with connect() as conn:
        return conn.execute(
            "UPDATE watched SET watched_at = ? WHERE id = ?",
            (f"{tag}T12:00:00+00:00", watched_id),
        ).rowcount


def sichtbarkeit(watched_id, versteckt):
    """Versteckte Filme sieht nur der Host."""
    with connect() as conn:
        return conn.execute(
            "UPDATE watched SET hidden = ? WHERE id = ?",
            (1 if versteckt else 0, watched_id),
        ).rowcount


def bewerten(watched_id, session_id, stars, name=None):
    """Gibt None zurück, wenn der Film gar nicht in der Liste steht."""
    with connect() as conn:
        da = conn.execute(
            "SELECT 1 FROM watched WHERE id = ?", (watched_id,)
        ).fetchone()
        if not da:
            return None
        # Eine Stimme je Person — die eigene alte fliegt vorher raus
        ich = besitzer(session_id)
        conn.execute(
            f"DELETE FROM ratings WHERE watched_id = ? AND {WEM}",
            (watched_id, ich, ich, session_id),
        )
        conn.execute(
            "INSERT INTO ratings "
            "(watched_id, session_id, user_id, stars, name, created_at) "
            "VALUES (?, ?, ?, ?, ?, ?)",
            (
                watched_id,
                session_id,
                ich,
                stars,
                (name or "").strip()[:40] or None,
                _jetzt(),
            ),
        )
    return {"watched_id": watched_id, "stars": stars}


def stimme_loeschen(rating_id):
    """Der Host räumt eine einzelne Wertung weg."""
    with connect() as conn:
        return conn.execute(
            "DELETE FROM ratings WHERE id = ?", (rating_id,)
        ).rowcount


def ids():
    """movie_ids der geschauten Filme, für die Detailansicht."""
    with connect() as conn:
        return [r["movie_id"] for r in conn.execute("SELECT movie_id FROM watched")]