"""Local SQLite persistence for provisional server snapshots."""

from __future__ import annotations

import sqlite3
from datetime import datetime, timezone
from pathlib import Path
from typing import Iterable, Mapping

from .config import get_storage_path, use_postgres_rcon_storage
from .sqlite_utils import connect_sqlite_readonly, connect_sqlite_writer


DEFAULT_GAME_SOURCE = {
    "slug": "current-hll",
    "display_name": "Current Hell Let Loose",
    "provider_kind": "development",
}
SUMMARY_SNAPSHOT_LIMIT = 6


def resolve_storage_path(*, db_path: Path | None = None) -> Path:
    """Resolve the SQLite path used by live snapshot persistence."""
    return db_path or get_storage_path()


def initialize_storage(*, db_path: Path | None = None) -> Path:
    """Create the local database file and minimal schema when missing."""
    resolved_path = resolve_storage_path(db_path=db_path)
    resolved_path.parent.mkdir(parents=True, exist_ok=True)

    with _connect(resolved_path) as connection:
        connection.executescript(
            """
            CREATE TABLE IF NOT EXISTS game_sources (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                slug TEXT NOT NULL UNIQUE,
                display_name TEXT NOT NULL,
                provider_kind TEXT NOT NULL,
                is_active INTEGER NOT NULL DEFAULT 1,
                created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
                updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
            );

            CREATE TABLE IF NOT EXISTS servers (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                game_source_id INTEGER NOT NULL,
                external_server_id TEXT,
                server_name TEXT NOT NULL,
                region TEXT,
                first_seen_at TEXT NOT NULL,
                last_seen_at TEXT NOT NULL,
                created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
                updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
                UNIQUE (game_source_id, external_server_id),
                FOREIGN KEY (game_source_id) REFERENCES game_sources(id)
            );

            CREATE TABLE IF NOT EXISTS server_snapshots (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                server_id INTEGER NOT NULL,
                captured_at TEXT NOT NULL,
                status TEXT NOT NULL,
                players INTEGER,
                max_players INTEGER,
                current_map TEXT,
                source_name TEXT NOT NULL,
                snapshot_origin TEXT,
                source_ref TEXT,
                raw_payload_ref TEXT,
                created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
                FOREIGN KEY (server_id) REFERENCES servers(id)
            );

            CREATE INDEX IF NOT EXISTS idx_server_snapshots_server_time
            ON server_snapshots(server_id, captured_at);
            """
        )
        _ensure_server_snapshot_columns(connection)

    return resolved_path


def persist_snapshot_batch(
    snapshots: Iterable[Mapping[str, object]],
    *,
    source_name: str,
    captured_at: str,
    game_source: Mapping[str, str] | None = None,
    db_path: Path | None = None,
) -> dict[str, object]:
    """Persist a batch of normalized snapshots into local SQLite storage."""
    source_definition = dict(DEFAULT_GAME_SOURCE)
    if game_source is not None:
        source_definition.update(game_source)
    if use_postgres_rcon_storage(explicit_sqlite_path=db_path):
        from .postgres_display_storage import persist_server_snapshots

        return persist_server_snapshots(
            snapshots,
            source_name=source_name,
            captured_at=captured_at,
            game_source=source_definition,
        )
    resolved_path = initialize_storage(db_path=db_path)

    persisted = 0
    with _connect(resolved_path) as connection:
        game_source_id = _upsert_game_source(connection, source_definition)
        for snapshot in snapshots:
            server_id = _upsert_server(
                connection,
                game_source_id=game_source_id,
                snapshot=snapshot,
                captured_at=captured_at,
            )
            connection.execute(
                """
                INSERT INTO server_snapshots (
                    server_id,
                    captured_at,
                    status,
                    players,
                    max_players,
                    current_map,
                    source_name,
                    snapshot_origin,
                    source_ref,
                    raw_payload_ref
                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                """,
                (
                    server_id,
                    captured_at,
                    snapshot.get("status"),
                    snapshot.get("players"),
                    snapshot.get("max_players"),
                    snapshot.get("current_map"),
                    snapshot.get("source_name") or source_name,
                    snapshot.get("snapshot_origin"),
                    snapshot.get("source_ref"),
                    None,
                ),
            )
            persisted += 1

    return {
        "db_path": str(resolved_path),
        "captured_at": captured_at,
        "persisted_snapshots": persisted,
        "game_source_slug": source_definition["slug"],
    }


def list_latest_snapshots(*, db_path: Path | None = None) -> list[dict[str, object]]:
    """Return the latest persisted snapshot for each known server."""
    if use_postgres_rcon_storage(explicit_sqlite_path=db_path):
        from .postgres_display_storage import list_latest_server_snapshots

        return list_latest_server_snapshots()
    resolved_path = resolve_storage_path(db_path=db_path)
    if not resolved_path.exists():
        return []
    with _connect_readonly(resolved_path) as connection:
        rows = connection.execute(
            """
            SELECT
                servers.id AS server_id,
                servers.external_server_id,
                servers.server_name,
                servers.region,
                game_sources.slug AS context,
                server_snapshots.source_name,
                server_snapshots.snapshot_origin,
                server_snapshots.source_ref,
                server_snapshots.captured_at,
                server_snapshots.status,
                server_snapshots.players,
                server_snapshots.max_players,
                server_snapshots.current_map
            FROM servers
            INNER JOIN game_sources
                ON game_sources.id = servers.game_source_id
            INNER JOIN server_snapshots
                ON server_snapshots.server_id = servers.id
            INNER JOIN (
                SELECT server_id, MAX(captured_at) AS latest_captured_at
                FROM server_snapshots
                GROUP BY server_id
            ) AS latest
                ON latest.server_id = server_snapshots.server_id
                AND latest.latest_captured_at = server_snapshots.captured_at
            ORDER BY servers.server_name ASC
            """
        ).fetchall()
        items = [_serialize_snapshot_row(row) for row in rows]
        return _attach_history_summaries(connection, items)


def list_snapshot_history(
    *,
    db_path: Path | None = None,
    limit: int = 20,
) -> list[dict[str, object]]:
    """Return recent persisted snapshots across all servers."""
    if use_postgres_rcon_storage(explicit_sqlite_path=db_path):
        from .postgres_display_storage import list_server_snapshot_history

        return list_server_snapshot_history(limit=limit)
    resolved_path = resolve_storage_path(db_path=db_path)
    if not resolved_path.exists():
        return []
    with _connect_readonly(resolved_path) as connection:
        rows = connection.execute(
            """
            SELECT
                servers.id AS server_id,
                servers.external_server_id,
                servers.server_name,
                servers.region,
                game_sources.slug AS context,
                server_snapshots.source_name,
                server_snapshots.snapshot_origin,
                server_snapshots.source_ref,
                server_snapshots.captured_at,
                server_snapshots.status,
                server_snapshots.players,
                server_snapshots.max_players,
                server_snapshots.current_map
            FROM server_snapshots
            INNER JOIN servers
                ON servers.id = server_snapshots.server_id
            INNER JOIN game_sources
                ON game_sources.id = servers.game_source_id
            ORDER BY server_snapshots.captured_at DESC, servers.server_name ASC
            LIMIT ?
            """,
            (limit,),
        ).fetchall()
    return [_serialize_snapshot_row(row) for row in rows]


def list_server_history(
    server_id: str,
    *,
    db_path: Path | None = None,
    limit: int = 20,
) -> list[dict[str, object]]:
    """Return recent history for one server by numeric id or external id."""
    if use_postgres_rcon_storage(explicit_sqlite_path=db_path):
        from .postgres_display_storage import list_server_snapshot_history

        return list_server_snapshot_history(server_id=server_id, limit=limit)
    resolved_path = resolve_storage_path(db_path=db_path)
    if not resolved_path.exists():
        return []
    server_filter, server_value = _build_server_filter(server_id)
    with _connect_readonly(resolved_path) as connection:
        rows = connection.execute(
            f"""
            SELECT
                servers.id AS server_id,
                servers.external_server_id,
                servers.server_name,
                servers.region,
                game_sources.slug AS context,
                server_snapshots.source_name,
                server_snapshots.snapshot_origin,
                server_snapshots.source_ref,
                server_snapshots.captured_at,
                server_snapshots.status,
                server_snapshots.players,
                server_snapshots.max_players,
                server_snapshots.current_map
            FROM server_snapshots
            INNER JOIN servers
                ON servers.id = server_snapshots.server_id
            INNER JOIN game_sources
                ON game_sources.id = servers.game_source_id
            WHERE {server_filter} = ?
            ORDER BY server_snapshots.captured_at DESC
            LIMIT ?
            """,
            (server_value, limit),
        ).fetchall()
    return [_serialize_snapshot_row(row) for row in rows]


def _connect(db_path: Path) -> sqlite3.Connection:
    return connect_sqlite_writer(db_path)


def _connect_readonly(db_path: Path) -> sqlite3.Connection:
    return connect_sqlite_readonly(db_path)


def _upsert_game_source(
    connection: sqlite3.Connection,
    game_source: Mapping[str, str],
) -> int:
    connection.execute(
        """
        INSERT INTO game_sources (slug, display_name, provider_kind, is_active)
        VALUES (?, ?, ?, 1)
        ON CONFLICT(slug) DO UPDATE SET
            display_name = excluded.display_name,
            provider_kind = excluded.provider_kind,
            is_active = 1,
            updated_at = CURRENT_TIMESTAMP
        """,
        (
            game_source["slug"],
            game_source["display_name"],
            game_source["provider_kind"],
        ),
    )
    row = connection.execute(
        "SELECT id FROM game_sources WHERE slug = ?",
        (game_source["slug"],),
    ).fetchone()
    if row is None:
        raise RuntimeError("Failed to resolve game source during snapshot persistence.")

    return int(row["id"])


def _upsert_server(
    connection: sqlite3.Connection,
    *,
    game_source_id: int,
    snapshot: Mapping[str, object],
    captured_at: str,
) -> int:
    external_server_id = snapshot.get("external_server_id")
    if not isinstance(external_server_id, str) or not external_server_id.strip():
        external_server_id = _build_fallback_external_id(snapshot)

    server_name = str(snapshot.get("server_name") or "Unknown server")
    region = snapshot.get("region")

    connection.execute(
        """
        INSERT INTO servers (
            game_source_id,
            external_server_id,
            server_name,
            region,
            first_seen_at,
            last_seen_at
        ) VALUES (?, ?, ?, ?, ?, ?)
        ON CONFLICT(game_source_id, external_server_id) DO UPDATE SET
            server_name = excluded.server_name,
            region = excluded.region,
            last_seen_at = excluded.last_seen_at,
            updated_at = CURRENT_TIMESTAMP
        """,
        (
            game_source_id,
            external_server_id,
            server_name,
            region,
            captured_at,
            captured_at,
        ),
    )
    row = connection.execute(
        """
        SELECT id
        FROM servers
        WHERE game_source_id = ? AND external_server_id = ?
        """,
        (game_source_id, external_server_id),
    ).fetchone()
    if row is None:
        raise RuntimeError("Failed to resolve server during snapshot persistence.")

    return int(row["id"])


def _build_fallback_external_id(snapshot: Mapping[str, object]) -> str:
    server_name = str(snapshot.get("server_name") or "unknown-server")
    normalized = "".join(
        character.lower() if character.isalnum() else "-"
        for character in server_name
    )
    compact = "-".join(part for part in normalized.split("-") if part)
    return compact or "unknown-server"


def _ensure_server_snapshot_columns(connection: sqlite3.Connection) -> None:
    columns = {
        str(row["name"])
        for row in connection.execute("PRAGMA table_info(server_snapshots)").fetchall()
    }

    if "snapshot_origin" not in columns:
        connection.execute("ALTER TABLE server_snapshots ADD COLUMN snapshot_origin TEXT")
    if "source_ref" not in columns:
        connection.execute("ALTER TABLE server_snapshots ADD COLUMN source_ref TEXT")

    connection.execute(
        """
        UPDATE server_snapshots
        SET snapshot_origin = CASE
            WHEN source_name = 'controlled-placeholder' THEN 'controlled-fallback'
            WHEN source_name LIKE '%a2s%' THEN 'real-a2s'
            ELSE 'unknown'
        END
        WHERE snapshot_origin IS NULL OR snapshot_origin = ''
        """
    )
    connection.execute(
        """
        UPDATE server_snapshots
        SET source_ref = source_name
        WHERE source_ref IS NULL OR source_ref = ''
        """
    )
    _backfill_registered_a2s_source_refs(connection)


def _backfill_registered_a2s_source_refs(connection: sqlite3.Connection) -> None:
    from .server_targets import load_a2s_targets

    for target in load_a2s_targets():
        if not target.external_server_id:
            continue

        connection.execute(
            """
            UPDATE server_snapshots
            SET source_ref = ?
            WHERE snapshot_origin = 'real-a2s'
              AND source_ref = source_name
              AND server_id IN (
                  SELECT id
                  FROM servers
                  WHERE external_server_id = ?
              )
            """,
            (
                f"a2s://{target.host}:{target.query_port}",
                target.external_server_id,
            ),
        )


def _serialize_snapshot_row(row: sqlite3.Row) -> dict[str, object]:
    return {
        "server_id": row["server_id"],
        "external_server_id": row["external_server_id"],
        "server_name": row["server_name"],
        "region": row["region"],
        "context": row["context"],
        "source_name": row["source_name"],
        "snapshot_origin": row["snapshot_origin"],
        "source_ref": row["source_ref"],
        "captured_at": row["captured_at"],
        "status": row["status"],
        "players": row["players"],
        "max_players": row["max_players"],
        "current_map": row["current_map"],
    }


def _attach_history_summaries(
    connection: sqlite3.Connection,
    items: list[dict[str, object]],
) -> list[dict[str, object]]:
    enriched_items: list[dict[str, object]] = []
    for item in items:
        enriched = dict(item)
        enriched["history_summary"] = _build_history_summary(
            connection,
            int(item["server_id"]),
        )
        enriched_items.append(enriched)

    return enriched_items


def _build_history_summary(
    connection: sqlite3.Connection,
    server_id: int,
) -> dict[str, object]:
    rows = connection.execute(
        """
        SELECT
            captured_at,
            status,
            players
        FROM server_snapshots
        WHERE server_id = ?
        ORDER BY captured_at DESC
        LIMIT ?
        """,
        (server_id, SUMMARY_SNAPSHOT_LIMIT),
    ).fetchall()
    return _summarize_history_rows(rows)


def _summarize_history_rows(rows: list[sqlite3.Row]) -> dict[str, object]:
    capture_count = len(rows)
    player_values = [
        int(row["players"])
        for row in rows
        if row["players"] is not None
    ]
    online_rows = [row for row in rows if row["status"] == "online"]
    latest_captured_at = str(rows[0]["captured_at"]) if rows else None
    last_seen_online_at = str(online_rows[0]["captured_at"]) if online_rows else None

    return {
        "window_size": SUMMARY_SNAPSHOT_LIMIT,
        "recent_capture_count": capture_count,
        "recent_online_count": len(online_rows),
        "recent_average_players": _round_average(player_values),
        "recent_peak_players": max(player_values, default=None),
        "last_seen_online_at": last_seen_online_at,
        "minutes_since_last_capture": _minutes_since_timestamp(latest_captured_at),
    }


def _round_average(values: list[int]) -> float | None:
    if not values:
        return None

    return round(sum(values) / len(values), 1)


def _minutes_since_timestamp(timestamp: str | None) -> int | None:
    if not timestamp:
        return None

    normalized = timestamp.replace("Z", "+00:00")
    captured_at = datetime.fromisoformat(normalized)
    if captured_at.tzinfo is None:
        captured_at = captured_at.replace(tzinfo=timezone.utc)

    delta = datetime.now(timezone.utc) - captured_at.astimezone(timezone.utc)
    return max(0, int(delta.total_seconds() // 60))


def _build_server_filter(server_id: str) -> tuple[str, object]:
    normalized = server_id.strip()
    if normalized.isdigit():
        return "servers.id", int(normalized)

    return "servers.external_server_id", normalized