import json
import sqlite3
import threading
import time
import uuid
from contextlib import contextmanager

from . import config

_local = threading.local()


def get_conn():
    if not hasattr(_local, "conn"):
        _local.conn = sqlite3.connect(config.DB_PATH, check_same_thread=False)
        _local.conn.row_factory = sqlite3.Row
        _local.conn.execute("PRAGMA foreign_keys = ON")
    return _local.conn


@contextmanager
def tx():
    conn = get_conn()
    try:
        yield conn
        conn.commit()
    except Exception:
        conn.rollback()
        raise


def init_db():
    with tx() as conn:
        conn.execute("""
            CREATE TABLE IF NOT EXISTS settings (
                key TEXT PRIMARY KEY,
                value TEXT NOT NULL
            )
        """)
        conn.execute("""
            CREATE TABLE IF NOT EXISTS sessions (
                id TEXT PRIMARY KEY,
                name TEXT NOT NULL,
                original_filename TEXT NOT NULL,
                video_path TEXT,
                audio_path TEXT,
                transcript_path TEXT,
                status TEXT NOT NULL DEFAULT 'uploaded',
                created_at REAL NOT NULL
            )
        """)
        conn.execute("""
            CREATE TABLE IF NOT EXISTS speakers (
                id TEXT PRIMARY KEY,
                session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
                raw_label TEXT NOT NULL,
                display_name TEXT,
                UNIQUE(session_id, raw_label)
            )
        """)
        conn.execute("""
            CREATE TABLE IF NOT EXISTS notes (
                session_id TEXT PRIMARY KEY REFERENCES sessions(id) ON DELETE CASCADE,
                dm_notes TEXT,
                player_recap TEXT,
                player_recap_prompt TEXT,
                generated_at REAL
            )
        """)
        # migrate older databases that lack the prompt column
        try:
            conn.execute("ALTER TABLE notes ADD COLUMN player_recap_prompt TEXT")
        except Exception:
            pass
        conn.execute("""
            CREATE TABLE IF NOT EXISTS jobs (
                id TEXT PRIMARY KEY,
                session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
                job_type TEXT NOT NULL,        -- 'transcribe' | 'summarize'
                status TEXT NOT NULL DEFAULT 'queued',  -- queued|running|done|error
                progress TEXT,                 -- free-text progress message
                error TEXT,
                error_stage TEXT,               -- which pipeline stage failed, e.g. 'transcription'
                error_detail TEXT,               -- full traceback, for logs/advanced view only
                created_at REAL NOT NULL,
                updated_at REAL NOT NULL
            )
        """)
        conn.execute("""
            CREATE TABLE IF NOT EXISTS campaigns (
                id TEXT PRIMARY KEY,
                name TEXT NOT NULL,
                description TEXT NOT NULL DEFAULT '',
                created_at REAL NOT NULL
            )
        """)
        try:
            conn.execute("ALTER TABLE sessions ADD COLUMN campaign_id TEXT REFERENCES campaigns(id) ON DELETE SET NULL")
        except Exception:
            pass
        default = conn.execute("SELECT id FROM campaigns WHERE id = 'default'").fetchone()
        if not default:
            conn.execute(
                "INSERT INTO campaigns (id, name, description, created_at) VALUES (?, ?, '', ?)",
                ("default", "Default Campaign", now()),
            )
            conn.execute("UPDATE sessions SET campaign_id = 'default' WHERE campaign_id IS NULL")

        # seed defaults if empty
        existing = {r["key"] for r in conn.execute("SELECT key FROM settings")}
        for k, v in config.DEFAULT_SETTINGS.items():
            if k not in existing:
                conn.execute("INSERT INTO settings (key, value) VALUES (?, ?)", (k, v))


def get_settings() -> dict:
    conn = get_conn()
    rows = conn.execute("SELECT key, value FROM settings").fetchall()
    return {r["key"]: r["value"] for r in rows}


def update_settings(patch: dict):
    with tx() as conn:
        for k, v in patch.items():
            conn.execute(
                "INSERT INTO settings (key, value) VALUES (?, ?) "
                "ON CONFLICT(key) DO UPDATE SET value=excluded.value",
                (k, str(v)),
            )


def new_id() -> str:
    return uuid.uuid4().hex[:12]


def now() -> float:
    return time.time()


def create_job(session_id: str, job_type: str) -> str:
    job_id = new_id()
    with tx() as conn:
        conn.execute(
            "INSERT INTO jobs (id, session_id, job_type, status, created_at, updated_at) "
            "VALUES (?, ?, ?, 'queued', ?, ?)",
            (job_id, session_id, job_type, now(), now()),
        )
    return job_id


def update_job(job_id: str, **fields):
    if not fields:
        return
    fields["updated_at"] = now()
    cols = ", ".join(f"{k} = ?" for k in fields)
    with tx() as conn:
        conn.execute(f"UPDATE jobs SET {cols} WHERE id = ?", (*fields.values(), job_id))


def get_job(job_id: str) -> dict | None:
    row = get_conn().execute("SELECT * FROM jobs WHERE id = ?", (job_id,)).fetchone()
    return dict(row) if row else None

def create_campaign(name: str, description: str = "") -> dict:
    campaign_id = new_id()
    with tx() as conn:
        conn.execute(
            "INSERT INTO campaigns (id, name, description, created_at) VALUES (?, ?, ?, ?)",
            (campaign_id, name, description, now()),
        )
    from .config import campaign_audio_dir, campaign_transcript_dir, campaign_notes_dir
    campaign_audio_dir(campaign_id).mkdir(parents=True, exist_ok=True)
    campaign_transcript_dir(campaign_id).mkdir(parents=True, exist_ok=True)
    campaign_notes_dir(campaign_id).mkdir(parents=True, exist_ok=True)
    return get_campaign(campaign_id)

def list_campaigns() -> list[dict]:
    rows = get_conn().execute(
        "SELECT c.*, (SELECT COUNT(*) FROM sessions s WHERE s.campaign_id = c.id) as session_count "
        "FROM campaigns c ORDER BY c.created_at DESC"
    ).fetchall()
    return [dict(r) for r in rows]

def get_campaign(campaign_id: str) -> dict | None:
    row = get_conn().execute(
        "SELECT c.*, (SELECT COUNT(*) FROM sessions s WHERE s.campaign_id = c.id) as session_count "
        "FROM campaigns c WHERE c.id = ?", (campaign_id,)
    ).fetchone()
    return dict(row) if row else None

def update_campaign(campaign_id: str, name: str | None = None, description: str | None = None) -> dict | None:
    fields = {}
    if name is not None: fields["name"] = name
    if description is not None: fields["description"] = description
    if not fields:
        return get_campaign(campaign_id)
    with tx() as conn:
        cols = ", ".join(f"{k} = ?" for k in fields)
        conn.execute(f"UPDATE campaigns SET {cols} WHERE id = ?", (*fields.values(), campaign_id))
    return get_campaign(campaign_id)

def delete_campaign(campaign_id: str) -> bool:
    with tx() as conn:
        conn.execute("UPDATE sessions SET campaign_id = NULL WHERE campaign_id = ?", (campaign_id,))
        conn.execute("DELETE FROM campaigns WHERE id = ?", (campaign_id,))
    return True