"""SQLite-Index der Firmware-Library.

Die DB-Datei wandert standardmäßig nach `<firmware_root>/firmware.db`,
damit sie zur Library gehört und beim Mounten automatisch da ist.
"""
from __future__ import annotations

import sqlite3
from contextlib import contextmanager
from pathlib import Path
from typing import Iterator

SCHEMA = """
CREATE TABLE IF NOT EXISTS firmware (
    id           INTEGER PRIMARY KEY AUTOINCREMENT,
    rel_path     TEXT NOT NULL UNIQUE,   -- relativ zum firmware-Root
    size         INTEGER NOT NULL,
    mtime        REAL NOT NULL,
    sha256       TEXT,                   -- erst nach erstem Hash gefüllt
    format       TEXT,                   -- 'huawei-update.app', 'mtk-scatter', 'unknown', ...
    vendor       TEXT,
    model        TEXT,                   -- z.B. 'WAS-LX1'
    soc          TEXT,                   -- z.B. 'kirin-658'
    version      TEXT,                   -- z.B. '8.0.0.367'
    region       TEXT,                   -- z.B. 'C432'
    extra_json   TEXT,                   -- alles weitere als JSON
    added_at     REAL DEFAULT (strftime('%s','now')),
    last_seen_at REAL DEFAULT (strftime('%s','now'))
);
CREATE INDEX IF NOT EXISTS idx_fw_model  ON firmware(model);
CREATE INDEX IF NOT EXISTS idx_fw_format ON firmware(format);
"""


def connect(db_path: Path) -> sqlite3.Connection:
    db_path.parent.mkdir(parents=True, exist_ok=True)
    conn = sqlite3.connect(db_path)
    conn.row_factory = sqlite3.Row
    conn.executescript(SCHEMA)
    return conn


@contextmanager
def open_db(db_path: Path) -> Iterator[sqlite3.Connection]:
    """Connection-Lifecycle für FastAPI-Handler: öffnet, gibt zurück, schließt."""
    conn = connect(db_path)
    try:
        yield conn
    finally:
        conn.close()


@contextmanager
def transaction(conn: sqlite3.Connection) -> Iterator[sqlite3.Connection]:
    try:
        yield conn
        conn.commit()
    except Exception:
        conn.rollback()
        raise


def upsert(conn: sqlite3.Connection, rec: dict) -> int:
    """Einfügen oder bei Konflikt auf rel_path aktualisieren."""
    cols = ["rel_path", "size", "mtime", "sha256", "format",
            "vendor", "model", "soc", "version", "region", "extra_json"]
    placeholders = ",".join(f":{c}" for c in cols)
    update = ",".join(f"{c}=excluded.{c}" for c in cols if c != "rel_path")
    sql = (f"INSERT INTO firmware ({','.join(cols)}) VALUES ({placeholders}) "
           f"ON CONFLICT(rel_path) DO UPDATE SET {update}, "
           f"last_seen_at=strftime('%s','now')")
    cur = conn.execute(sql, {c: rec.get(c) for c in cols})
    return cur.lastrowid or 0


def list_all(conn: sqlite3.Connection) -> list[sqlite3.Row]:
    return list(conn.execute(
        "SELECT * FROM firmware ORDER BY vendor, model, version"
    ))


def get_by_id(conn: sqlite3.Connection, fw_id: int) -> sqlite3.Row | None:
    cur = conn.execute("SELECT * FROM firmware WHERE id = ?", (fw_id,))
    return cur.fetchone()


def delete_missing(conn: sqlite3.Connection, present_rel_paths: set[str]) -> int:
    """Einträge entfernen, die beim letzten Scan nicht mehr da waren."""
    cur = conn.execute("SELECT id, rel_path FROM firmware")
    to_delete = [row["id"] for row in cur if row["rel_path"] not in present_rel_paths]
    if to_delete:
        conn.executemany("DELETE FROM firmware WHERE id = ?",
                         [(i,) for i in to_delete])
    return len(to_delete)