"""
Database schema and connection management.
Supports SQLite (local dev) and PostgreSQL (production).

Set AP_DB_URL in .env to use Postgres; otherwise falls back to SQLite.
"""

import os
import re
import sqlite3
from pathlib import Path
from contextlib import contextmanager

# Try importing psycopg2 at module level (available if installed)
try:
    import psycopg2
    import psycopg2.extras
    _HAS_PG = True
except ImportError:
    _HAS_PG = False

# Lazy detection — check env var at connection time, not import time
_pg_checked = False
_USE_PG = False
_AP_DB_URL = ""

def _check_pg():
    global _pg_checked, _USE_PG, _AP_DB_URL
    if _pg_checked:
        return
    _pg_checked = True
    _AP_DB_URL = os.getenv("AP_DB_URL", "")
    if _AP_DB_URL and _HAS_PG:
        _USE_PG = True
        print(f"[db] Using PostgreSQL")
    else:
        from config import DB_PATH as _path
        _USE_PG = False
        print(f"[db] Using SQLite at {_path}")


_pg_conn_params = None

def get_connection():
    """Get a database connection (SQLite or Postgres). Always call conn.close() when done."""
    _check_pg()
    if _USE_PG:
        global _pg_conn_params
        if _pg_conn_params is None:
            db_url = _AP_DB_URL
            m = re.match(r'postgresql://([^:]+):(.+)@([^:]+):(\d+)/(\S+)', db_url)
            if m:
                _pg_conn_params = dict(
                    dbname=m.group(5).strip(), user=m.group(1).strip(),
                    password=m.group(2), host=m.group(3).strip(),
                    port=int(m.group(4))
                )
            else:
                _pg_conn_params = dict(dsn=db_url)
        conn = psycopg2.connect(**_pg_conn_params, connect_timeout=10)
        conn.autocommit = True
        return _PgConnectionWrapper(conn)
    else:
        from config import DB_PATH
        conn = sqlite3.connect(DB_PATH)
        conn.row_factory = sqlite3.Row
        conn.execute("PRAGMA journal_mode=WAL")
        conn.execute("PRAGMA foreign_keys=ON")
        return conn


class _PgConnectionWrapper:
    """Wraps psycopg2 connection to provide sqlite3-like interface."""

    def __init__(self, conn):
        self._conn = conn
        self._conn.autocommit = True

    def execute(self, sql, params=None):
        """Execute SQL, converting SQLite syntax to Postgres on the fly."""
        sql = _adapt_sql(sql)
        cur = self._conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
        try:
            cur.execute(sql, params or [])
        except Exception as e:
            # Don't raise on benign errors (e.g., table already exists)
            if 'already exists' in str(e) or 'duplicate key' in str(e):
                self._conn.rollback()
                self._conn.autocommit = True
                return _EmptyCursor()
            raise
        return _PgCursorWrapper(cur)

    def executemany(self, sql, params_list):
        """Execute SQL with many parameter sets."""
        sql = _adapt_sql(sql)
        cur = self._conn.cursor()
        for params in params_list:
            try:
                cur.execute(sql, params)
            except Exception as e:
                if 'already exists' not in str(e) and 'duplicate key' not in str(e):
                    raise
        return cur

    def executescript(self, sql):
        """Execute multiple SQL statements (Postgres doesn't have executescript)."""
        sql = _adapt_sql(sql)
        # Split on semicolons but handle edge cases
        statements = [s.strip() for s in sql.split(';') if s.strip()]
        cur = self._conn.cursor()
        for stmt in statements:
            if not stmt:
                continue
            try:
                cur.execute(stmt)
            except Exception as e:
                if 'already exists' not in str(e):
                    print(f"[db] SQL warning: {str(e).split(chr(10))[0][:80]}")
                self._conn.rollback()
                self._conn.autocommit = True
        return cur

    def commit(self):
        pass  # autocommit mode

    def rollback(self):
        pass

    def close(self):
        try:
            self._conn.close()
        except Exception:
            pass

    def __enter__(self):
        return self

    def __exit__(self, *args):
        self.close()

    def __del__(self):
        self.close()


class _PgCursorWrapper:
    """Wraps psycopg2 cursor to return dict-like rows (like sqlite3.Row)."""

    def __init__(self, cur):
        self._cur = cur

    @property
    def description(self):
        return self._cur.description

    def fetchall(self):
        try:
            rows = self._cur.fetchall()
            # Convert RealDictRow to support both dict and index access
            return [_DictRow(r) for r in rows]
        except psycopg2.ProgrammingError:
            return []

    def fetchone(self):
        try:
            r = self._cur.fetchone()
            return _DictRow(r) if r else None
        except psycopg2.ProgrammingError:
            return None

    @property
    def rowcount(self):
        return self._cur.rowcount


class _DictRow:
    """Row that supports both dict-style and index-style access."""

    def __init__(self, data):
        self._data = dict(data) if data else {}
        self._keys = list(self._data.keys())

    def __getitem__(self, key):
        if isinstance(key, int):
            return self._data[self._keys[key]]
        return self._data[key]

    def __contains__(self, key):
        return key in self._data

    def keys(self):
        return self._keys

    def __iter__(self):
        return iter(self._data.values())

    def __len__(self):
        return len(self._data)


class _EmptyCursor:
    """Dummy cursor for failed-but-benign operations."""

    def fetchall(self):
        return []

    def fetchone(self):
        return None

    @property
    def rowcount(self):
        return 0


def _adapt_sql(sql):
    """Convert SQLite-specific SQL to Postgres-compatible SQL."""
    # ? → %s (parameter placeholders)
    sql = sql.replace('?', '%s')
    # INSERT OR REPLACE → INSERT ... ON CONFLICT DO NOTHING (safe default)
    # INSERT OR IGNORE → INSERT ... ON CONFLICT DO NOTHING
    if 'INSERT OR REPLACE' in sql.upper():
        sql = sql.replace('INSERT OR REPLACE INTO', 'INSERT INTO')
        sql = sql.replace('insert or replace into', 'INSERT INTO')
        # Add ON CONFLICT DO NOTHING at the end (before any trailing whitespace)
        sql = sql.rstrip().rstrip(';') + ' ON CONFLICT DO NOTHING'
    if 'INSERT OR IGNORE' in sql.upper():
        sql = sql.replace('INSERT OR IGNORE INTO', 'INSERT INTO')
        sql = sql.replace('insert or ignore into', 'INSERT INTO')
        sql = sql.rstrip().rstrip(';') + ' ON CONFLICT DO NOTHING'
    # AUTOINCREMENT → remove
    sql = sql.replace('AUTOINCREMENT', '')
    # INTEGER PRIMARY KEY → SERIAL PRIMARY KEY
    sql = sql.replace('INTEGER PRIMARY KEY', 'SERIAL PRIMARY KEY')
    # datetime('now') → NOW()
    sql = sql.replace("datetime('now')", "NOW()")
    sql = sql.replace("(datetime('now'))", "NOW()")
    # REAL → DOUBLE PRECISION (only in CREATE statements)
    if 'CREATE TABLE' in sql.upper():
        sql = sql.replace(' REAL', ' DOUBLE PRECISION')
    # GROUP_CONCAT → STRING_AGG
    sql = sql.replace('GROUP_CONCAT(', 'STRING_AGG(')
    return sql


@contextmanager
def db():
    """Context manager for database connections."""
    _check_pg()
    conn = get_connection()
    try:
        yield conn
        if not _USE_PG:
            conn.commit()
    except Exception:
        if not _USE_PG:
            conn.rollback()
        raise
    finally:
        conn.close()


def init_db():
    """Initialize database tables."""
    _check_pg()
    if _USE_PG:
        # For Postgres, tables should already exist from migration
        # Just verify connectivity
        conn = get_connection()
        try:
            result = conn.execute("SELECT COUNT(*) FROM models")
            row = result.fetchone()
            count = row[0] if row else 0
            print(f"[db] Postgres connected, {count} models in DB")
        except Exception:
            print("[db] Postgres connected, initializing tables...")
            _init_pg_tables(conn)
        conn.close()
    else:
        # SQLite: create tables from schema
        with db() as conn:
            conn.executescript(_SQLITE_SCHEMA)
        from config import DB_PATH as _dbp
        print(f"[db] Initialized SQLite at {_dbp}")


def _init_pg_tables(conn):
    """Create tables in Postgres (used only if migration hasn't run)."""
    # Convert SQLite schema to Postgres and execute
    pg_schema = _adapt_sql(_SQLITE_SCHEMA)
    conn.executescript(pg_schema)


_SQLITE_SCHEMA = """
CREATE TABLE IF NOT EXISTS models (
    id          INTEGER PRIMARY KEY AUTOINCREMENT,
    slug        TEXT UNIQUE NOT NULL,
    display_name TEXT NOT NULL,
    provider    TEXT NOT NULL,
    tier        TEXT,
    active      INTEGER DEFAULT 1,
    created_at  TEXT DEFAULT (datetime('now'))
);

CREATE TABLE IF NOT EXISTS openrouter_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    context_length  INTEGER,
    prompt_price    REAL,
    completion_price REAL,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    FOREIGN KEY (model_slug) REFERENCES models(slug)
);

CREATE TABLE IF NOT EXISTS github_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    repo            TEXT NOT NULL,
    stars           INTEGER,
    forks           INTEGER,
    open_issues     INTEGER,
    pushed_at       TEXT,
    commits_24h     INTEGER,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    FOREIGN KEY (model_slug) REFERENCES models(slug)
);

CREATE TABLE IF NOT EXISTS twitter_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    query           TEXT NOT NULL,
    tweet_id        TEXT,
    text            TEXT,
    author          TEXT,
    likes           INTEGER DEFAULT 0,
    retweets        INTEGER DEFAULT 0,
    replies         INTEGER DEFAULT 0,
    created_at      TEXT,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    FOREIGN KEY (model_slug) REFERENCES models(slug)
);

CREATE TABLE IF NOT EXISTS reddit_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    subreddit       TEXT NOT NULL,
    post_id         TEXT UNIQUE,
    title           TEXT,
    score           INTEGER,
    num_comments    INTEGER,
    upvote_ratio    REAL,
    created_at      TEXT,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    FOREIGN KEY (model_slug) REFERENCES models(slug)
);

CREATE TABLE IF NOT EXISTS huggingface_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    hf_model_id     TEXT NOT NULL,
    downloads_30d   INTEGER,
    downloads_7d    INTEGER,
    likes           INTEGER,
    trending_score  REAL,
    trending_rank   INTEGER,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    FOREIGN KEY (model_slug) REFERENCES models(slug)
);

CREATE TABLE IF NOT EXISTS hn_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    story_id        TEXT NOT NULL,
    title           TEXT,
    score           INTEGER,
    num_comments    INTEGER,
    author          TEXT,
    created_at      TEXT,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    FOREIGN KEY (model_slug) REFERENCES models(slug),
    UNIQUE(story_id, model_slug)
);

CREATE TABLE IF NOT EXISTS latency_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    provider_name   TEXT,
    provider_tag    TEXT,
    latency_30m     REAL,
    throughput_30m  REAL,
    uptime_5m       REAL,
    uptime_30m      REAL,
    uptime_1d       REAL,
    endpoint_count  INTEGER,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    FOREIGN KEY (model_slug) REFERENCES models(slug)
);

CREATE TABLE IF NOT EXISTS sdk_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    package         TEXT NOT NULL,
    registry        TEXT NOT NULL,
    provider        TEXT NOT NULL,
    downloads_day   INTEGER,
    downloads_week  INTEGER,
    downloads_month INTEGER,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now'))
);

CREATE TABLE IF NOT EXISTS stackoverflow_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    question_id     INTEGER NOT NULL,
    title           TEXT,
    score           INTEGER,
    answer_count    INTEGER,
    view_count      INTEGER,
    is_answered     INTEGER,
    tags            TEXT,
    created_at      TEXT,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    FOREIGN KEY (model_slug) REFERENCES models(slug),
    UNIQUE(question_id, model_slug)
);

CREATE TABLE IF NOT EXISTS devto_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    article_id      INTEGER NOT NULL,
    title           TEXT,
    reactions       INTEGER,
    comments        INTEGER,
    reading_time    INTEGER,
    tags            TEXT,
    published_at    TEXT,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    FOREIGN KEY (model_slug) REFERENCES models(slug),
    UNIQUE(article_id, model_slug)
);

CREATE TABLE IF NOT EXISTS lobsters_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    short_id        TEXT NOT NULL,
    title           TEXT,
    url             TEXT,
    score           INTEGER,
    flags           INTEGER,
    comment_count   INTEGER,
    tags            TEXT,
    created_at      TEXT,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    FOREIGN KEY (model_slug) REFERENCES models(slug),
    UNIQUE(short_id, model_slug)
);

CREATE TABLE IF NOT EXISTS bluesky_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    query           TEXT NOT NULL,
    post_uri        TEXT NOT NULL,
    text            TEXT,
    author          TEXT,
    likes           INTEGER DEFAULT 0,
    reposts         INTEGER DEFAULT 0,
    replies         INTEGER DEFAULT 0,
    created_at      TEXT,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    FOREIGN KEY (model_slug) REFERENCES models(slug),
    UNIQUE(post_uri, model_slug)
);

CREATE TABLE IF NOT EXISTS github_discussions_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    discussion_id   INTEGER NOT NULL,
    title           TEXT,
    body_preview    TEXT,
    comments        INTEGER DEFAULT 0,
    reactions       INTEGER DEFAULT 0,
    author          TEXT,
    repo            TEXT,
    created_at      TEXT,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    FOREIGN KEY (model_slug) REFERENCES models(slug),
    UNIQUE(discussion_id, model_slug)
);

CREATE TABLE IF NOT EXISTS mastodon_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    post_uri        TEXT NOT NULL,
    instance        TEXT,
    text            TEXT,
    author          TEXT,
    favourites      INTEGER DEFAULT 0,
    boosts          INTEGER DEFAULT 0,
    replies         INTEGER DEFAULT 0,
    created_at      TEXT,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    FOREIGN KEY (model_slug) REFERENCES models(slug),
    UNIQUE(post_uri, model_slug)
);

CREATE TABLE IF NOT EXISTS v2ex_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    topic_id        INTEGER NOT NULL,
    title           TEXT,
    content_preview TEXT,
    replies         INTEGER DEFAULT 0,
    node            TEXT,
    author          TEXT,
    created_at      TEXT,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    FOREIGN KEY (model_slug) REFERENCES models(slug),
    UNIQUE(topic_id, model_slug)
);

CREATE TABLE IF NOT EXISTS lemmy_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    post_ap_id      TEXT NOT NULL,
    community       TEXT,
    instance        TEXT,
    title           TEXT,
    body_preview    TEXT,
    score           INTEGER DEFAULT 0,
    comments        INTEGER DEFAULT 0,
    upvotes         INTEGER DEFAULT 0,
    downvotes       INTEGER DEFAULT 0,
    created_at      TEXT,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    FOREIGN KEY (model_slug) REFERENCES models(slug),
    UNIQUE(post_ap_id, model_slug)
);

CREATE TABLE IF NOT EXISTS google_trends_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    search_term     TEXT,
    interest        INTEGER,
    timestamp       TEXT,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    UNIQUE(model_slug, search_term, timestamp)
);

CREATE TABLE IF NOT EXISTS arxiv_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    paper_id        TEXT NOT NULL,
    title           TEXT,
    abstract_preview TEXT,
    categories      TEXT,
    authors_count   INTEGER,
    published_at    TEXT,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now')),
    UNIQUE(paper_id, model_slug)
);

CREATE TABLE IF NOT EXISTS lmsys_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    model_slug      TEXT NOT NULL,
    lmsys_name      TEXT,
    elo_rating      REAL,
    num_battles     INTEGER,
    ci_lower        REAL,
    ci_upper        REAL,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now'))
);

CREATE TABLE IF NOT EXISTS devtools_signals (
    id              INTEGER PRIMARY KEY AUTOINCREMENT,
    tool_type       TEXT NOT NULL,
    tool_id         TEXT NOT NULL,
    tool_name       TEXT,
    provider        TEXT,
    installs        INTEGER,
    rating          REAL,
    rating_count    INTEGER,
    collected_at    TEXT NOT NULL DEFAULT (datetime('now'))
);

CREATE INDEX IF NOT EXISTS idx_or_model_time    ON openrouter_signals(model_slug, collected_at);
CREATE INDEX IF NOT EXISTS idx_gh_model_time    ON github_signals(model_slug, collected_at);
CREATE INDEX IF NOT EXISTS idx_tw_model_time    ON twitter_signals(model_slug, collected_at);
CREATE INDEX IF NOT EXISTS idx_rd_model_time    ON reddit_signals(model_slug, collected_at);
CREATE INDEX IF NOT EXISTS idx_hf_model_time    ON huggingface_signals(model_slug, collected_at);
CREATE INDEX IF NOT EXISTS idx_hn_model_time    ON hn_signals(model_slug, collected_at);
CREATE INDEX IF NOT EXISTS idx_lat_model_time   ON latency_signals(model_slug, collected_at);
CREATE INDEX IF NOT EXISTS idx_sdk_pkg_time     ON sdk_signals(package, collected_at);
CREATE INDEX IF NOT EXISTS idx_bs_model_time    ON bluesky_signals(model_slug, collected_at);
CREATE INDEX IF NOT EXISTS idx_so_model_time    ON stackoverflow_signals(model_slug, collected_at);
CREATE INDEX IF NOT EXISTS idx_dt_model_time    ON devto_signals(model_slug, collected_at);
CREATE INDEX IF NOT EXISTS idx_lb_model_time    ON lobsters_signals(model_slug, collected_at);
CREATE INDEX IF NOT EXISTS idx_ghd_model_time   ON github_discussions_signals(model_slug, collected_at);
CREATE INDEX IF NOT EXISTS idx_mst_model_time   ON mastodon_signals(model_slug, collected_at);
CREATE INDEX IF NOT EXISTS idx_v2x_model_time   ON v2ex_signals(model_slug, collected_at);
CREATE INDEX IF NOT EXISTS idx_lmy_model_time   ON lemmy_signals(model_slug, collected_at);
"""