Nat20-Notes/backend/app/database.py

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

from . import config
from .config import campaign_audio_dir, campaign_transcript_dir, campaign_notes_dir

_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 users (
                id TEXT PRIMARY KEY,
                username TEXT UNIQUE NOT NULL,
                password_hash TEXT NOT NULL,
                is_admin INTEGER NOT NULL DEFAULT 0,
                created_at REAL NOT NULL
            )
        """)
        conn.execute("""
            CREATE TABLE IF NOT EXISTS campaign_shares (
                campaign_id TEXT NOT NULL REFERENCES campaigns(id) ON DELETE CASCADE,
                user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
                role TEXT NOT NULL DEFAULT 'editor',
                PRIMARY KEY (campaign_id, user_id)
            )
        """)
        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,
                created_by TEXT REFERENCES users(id) ON DELETE SET NULL
            )
        """)
        try:
            conn.execute("ALTER TABLE campaigns ADD COLUMN created_by TEXT REFERENCES users(id) ON DELETE SET NULL")
        except Exception:
            pass
        conn.execute("""
            CREATE TABLE IF NOT EXISTS campaign_settings (
                campaign_id TEXT NOT NULL REFERENCES campaigns(id) ON DELETE CASCADE,
                key TEXT NOT NULL,
                value TEXT NOT NULL,
                UNIQUE(campaign_id, key)
            )
        """)
        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, created_by) VALUES (?, ?, '', ?, NULL)",
                ("default", "Default Campaign", now()),
            )
            conn.execute("UPDATE sessions SET campaign_id = 'default' WHERE campaign_id IS NULL")
            campaign_audio_dir("default").mkdir(parents=True, exist_ok=True)
            campaign_transcript_dir("default").mkdir(parents=True, exist_ok=True)
            campaign_notes_dir("default").mkdir(parents=True, exist_ok=True)

        # seed global settings (just onboarding_completed)
        existing_global = {r["key"] for r in conn.execute("SELECT key FROM settings")}
        for k, v in config.GLOBAL_SETTINGS.items():
            if k not in existing_global:
                conn.execute("INSERT INTO settings (key, value) VALUES (?, ?)", (k, v))

        # seed default campaign settings from CAMPAIGN_SETTINGS (migrate old global rows)
        existing_cs = {r["key"] for r in conn.execute(
            "SELECT key FROM campaign_settings WHERE campaign_id = 'default'"
        )}
        for k, v in config.CAMPAIGN_SETTINGS.items():
            if k not in existing_cs:
                # If this key was previously stored in global settings, carry it over
                old_row = conn.execute("SELECT value FROM settings WHERE key = ?", (k,)).fetchone()
                val = old_row["value"] if old_row else v
                conn.execute(
                    "INSERT INTO campaign_settings (campaign_id, key, value) VALUES (?, ?, ?)",
                    ("default", k, val),
                )


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():
            if k not in config.GLOBAL_SETTINGS:
                continue
            conn.execute(
                "INSERT INTO settings (key, value) VALUES (?, ?) "
                "ON CONFLICT(key) DO UPDATE SET value=excluded.value",
                (k, str(v)),
            )


def get_campaign_settings(campaign_id: str) -> dict:
    conn = get_conn()
    rows = conn.execute(
        "SELECT key, value FROM campaign_settings WHERE campaign_id = ?", (campaign_id,)
    ).fetchall()
    return {r["key"]: r["value"] for r in rows}


def update_campaign_settings(campaign_id: str, patch: dict):
    with tx() as conn:
        for k, v in patch.items():
            conn.execute(
                "INSERT INTO campaign_settings (campaign_id, key, value) VALUES (?, ?, ?) "
                "ON CONFLICT(campaign_id, key) DO UPDATE SET value=excluded.value",
                (campaign_id, 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 = "", created_by: str | None = None) -> dict:
    campaign_id = new_id()
    with tx() as conn:
        conn.execute(
            "INSERT INTO campaigns (id, name, description, created_at, created_by) VALUES (?, ?, ?, ?, ?)",
            (campaign_id, name, description, now(), created_by),
        )
        # Inherit CAMPAIGN_SETTINGS from the "default" campaign as a starting point
        parent = conn.execute(
            "SELECT key, value FROM campaign_settings WHERE campaign_id = 'default'"
        ).fetchall()
        inherited = {r["key"]: r["value"] for r in parent}
        for k, v in config.CAMPAIGN_SETTINGS.items():
            val = inherited.get(k, v)
            conn.execute(
                "INSERT INTO campaign_settings (campaign_id, key, value) VALUES (?, ?, ?)",
                (campaign_id, k, val),
            )
    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)

# ── Users ──────────────────────────────────────────────────────────────────

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


def get_user_by_username(username: str) -> dict | None:
    row = get_conn().execute("SELECT * FROM users WHERE username = ?", (username,)).fetchone()
    return dict(row) if row else None


def create_user(username: str, password_hash: str, is_admin: bool = False) -> dict:
    uid = new_id()
    with tx() as conn:
        conn.execute(
            "INSERT INTO users (id, username, password_hash, is_admin, created_at) VALUES (?, ?, ?, ?, ?)",
            (uid, username, password_hash, 1 if is_admin else 0, now()),
        )
    return get_user(uid)


def update_user_password(user_id: str, password_hash: str):
    with tx() as conn:
        conn.execute("UPDATE users SET password_hash = ? WHERE id = ?", (password_hash, user_id))


def list_users() -> list[dict]:
    rows = get_conn().execute(
        "SELECT id, username, is_admin, created_at FROM users ORDER BY created_at"
    ).fetchall()
    return [dict(r) for r in rows]


# ── Campaign sharing ──────────────────────────────────────────────────────

def share_campaign(campaign_id: str, user_id: str, role: str = "editor"):
    with tx() as conn:
        conn.execute(
            "INSERT OR REPLACE INTO campaign_shares (campaign_id, user_id, role) VALUES (?, ?, ?)",
            (campaign_id, user_id, role),
        )


def unshare_campaign(campaign_id: str, user_id: str):
    with tx() as conn:
        conn.execute(
            "DELETE FROM campaign_shares WHERE campaign_id = ? AND user_id = ?",
            (campaign_id, user_id),
        )


def get_campaign_shares(campaign_id: str) -> list[dict]:
    rows = get_conn().execute("""
        SELECT u.id, u.username, cs.role
        FROM campaign_shares cs
        JOIN users u ON u.id = cs.user_id
        WHERE cs.campaign_id = ?
    """, (campaign_id,)).fetchall()
    return [dict(r) for r in rows]


def get_user_campaigns(user_id: str) -> list[dict]:
    rows = get_conn().execute("""
        SELECT c.*, cs.role as access_role,
            (SELECT COUNT(*) FROM sessions s WHERE s.campaign_id = c.id) as session_count
        FROM campaigns c
        LEFT JOIN campaign_shares cs ON cs.campaign_id = c.id
        WHERE c.created_by = ? OR cs.user_id = ?
        ORDER BY c.created_at DESC
    """, (user_id, user_id)).fetchall()
    return [dict(r) for r in rows]


def can_access_campaign(user_id: str, campaign_id: str) -> bool:
    row = get_conn().execute("""
        SELECT 1 FROM campaigns WHERE id = ? AND created_by = ?
        UNION
        SELECT 1 FROM campaign_shares WHERE campaign_id = ? AND user_id = ?
    """, (campaign_id, user_id, campaign_id, user_id)).fetchone()
    return row is not None


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