#this is the sqlite database layer for gacha inventory, spark, and eligma##
"""SQLite database for Blue Archive gacha persistence — async wrapper layer."""
######################################################################
import asyncio
import sqlite3
import logging
from pathlib import Path
from typing import Any

from .constants import ELIGMA_YIELD

log = logging.getLogger(__name__)

_PKG_DIR = Path(__file__).parent
DB_PATH = _PKG_DIR.parent / "data" / "ba_gacha.db"


def _connect() -> sqlite3.Connection:
    """Open a connection with WAL mode for concurrent reads."""
    conn = sqlite3.connect(str(DB_PATH))
    return conn


def _init_db_sync() -> None:
    """Create tables if they don't exist (runs in thread)."""
    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
    with _connect() as conn:
        conn.execute("PRAGMA journal_mode=WAL")
        conn.execute("PRAGMA foreign_keys=ON")
        conn.executescript("""
            CREATE TABLE IF NOT EXISTS inventory (
                user_id    INTEGER NOT NULL,
                student_id INTEGER NOT NULL,
                count      INTEGER NOT NULL DEFAULT 1,
                PRIMARY KEY (user_id, student_id)
            );

            CREATE TABLE IF NOT EXISTS spark (
                user_id   INTEGER NOT NULL,
                banner_id TEXT    NOT NULL,
                points    INTEGER NOT NULL DEFAULT 0,
                PRIMARY KEY (user_id, banner_id)
            );

            CREATE TABLE IF NOT EXISTS eligma (
                user_id INTEGER PRIMARY KEY,
                amount  INTEGER NOT NULL DEFAULT 0
            );
        """)
    log.info("Database initialised at %s", DB_PATH)


async def init_db() -> None:
    """Async wrapper — initialises the database off the event loop."""
    await asyncio.to_thread(_init_db_sync)


# ── Inventory ──────────────────────────────────────────────────────────────

def _add_pull_sync(user_id: int, student_id: int, rarity: int) -> int:
    """Record a pull. Returns eligma earned from duplicates."""
    with _connect() as conn:
        cur = conn.execute(
            "SELECT count FROM inventory WHERE user_id = ? AND student_id = ?",
            (user_id, student_id),
        )
        row = cur.fetchone()
        if row:
            conn.execute("UPDATE inventory SET count = count + 1 WHERE user_id = ? AND student_id = ?",
                         (user_id, student_id))
            eligma = ELIGMA_YIELD.get(rarity, 0)
            _add_eligma_sync(conn, user_id, eligma)
            return eligma
        else:
            conn.execute(
                "INSERT INTO inventory (user_id, student_id, count) VALUES (?, ?, 1)",
                (user_id, student_id),
            )
            return 0


async def add_pull(user_id: int, student_id: int, rarity: int) -> int:
    return await asyncio.to_thread(_add_pull_sync, user_id, student_id, rarity)


def _get_inventory_sync(user_id: int) -> list[tuple[int, int]]:
    with _connect() as conn:
        rows = conn.execute(
            "SELECT student_id, count FROM inventory WHERE user_id = ? ORDER BY student_id",
            (user_id,),
        ).fetchall()
    return rows


async def get_inventory(user_id: int) -> list[tuple[int, int]]:
    return await asyncio.to_thread(_get_inventory_sync, user_id)


def _has_student_sync(user_id: int, student_id: int) -> bool:
    with _connect() as conn:
        row = conn.execute(
            "SELECT 1 FROM inventory WHERE user_id = ? AND student_id = ?",
            (user_id, student_id),
        ).fetchone()
    return row is not None


async def has_student(user_id: int, student_id: int) -> bool:
    return await asyncio.to_thread(_has_student_sync, user_id, student_id)


def _get_inventory_stats_sync(user_id: int) -> dict:
    with _connect() as conn:
        total_pulls = conn.execute(
            "SELECT COALESCE(SUM(count), 0) FROM inventory WHERE user_id = ?",
            (user_id,),
        ).fetchone()[0]
        unique = conn.execute(
            "SELECT COUNT(*) FROM inventory WHERE user_id = ?",
            (user_id,),
        ).fetchone()[0]
    return {"total_pulls": total_pulls, "unique": unique}


async def get_inventory_stats(user_id: int) -> dict:
    return await asyncio.to_thread(_get_inventory_stats_sync, user_id)


# ── Spark ───────────────────────────────────────────────────────────────────

def _get_spark_sync(user_id: int, banner_id: str) -> int:
    with _connect() as conn:
        row = conn.execute(
            "SELECT points FROM spark WHERE user_id = ? AND banner_id = ?",
            (user_id, banner_id),
        ).fetchone()
    return row[0] if row else 0


async def get_spark(user_id: int, banner_id: str) -> int:
    return await asyncio.to_thread(_get_spark_sync, user_id, banner_id)


def _add_spark_sync(user_id: int, banner_id: str, points: int) -> int:
    """Add points to a banner's spark counter. Returns new total."""
    with _connect() as conn:
        conn.execute(
            "INSERT INTO spark (user_id, banner_id, points) VALUES (?, ?, ?) "
            "ON CONFLICT(user_id, banner_id) DO UPDATE SET points = points + ?",
            (user_id, banner_id, points, points),
        )
        row = conn.execute(
            "SELECT points FROM spark WHERE user_id = ? AND banner_id = ?",
            (user_id, banner_id),
        ).fetchone()
    return row[0] if row else 0


async def add_spark(user_id: int, banner_id: str, points: int) -> int:
    return await asyncio.to_thread(_add_spark_sync, user_id, banner_id, points)


def _spend_spark_sync(user_id: int, banner_id: str, cost: int = 200) -> bool:
    """Deduct spark points. Returns True if successful (had enough points)."""
    with _connect() as conn:
        row = conn.execute(
            "SELECT points FROM spark WHERE user_id = ? AND banner_id = ?",
            (user_id, banner_id),
        ).fetchone()
        if not row or row[0] < cost:
            return False
        conn.execute(
            "UPDATE spark SET points = points - ? WHERE user_id = ? AND banner_id = ?",
            (cost, user_id, banner_id),
        )
        return True


async def spend_spark(user_id: int, banner_id: str, cost: int = 200) -> bool:
    return await asyncio.to_thread(_spend_spark_sync, user_id, banner_id, cost)


def _spark_claim_sync(user_id: int, banner_id: str, student_id: int, rarity: int, cost: int = 200) -> tuple[bool, str]:
    """Atomically claim a spark student. Returns (success, message)."""
    with _connect() as conn:
        row = conn.execute(
            "SELECT points FROM spark WHERE user_id = ? AND banner_id = ?",
            (user_id, banner_id),
        ).fetchone()
        if not row or row[0] < cost:
            return False, "Not enough Recruitment Points."
        owned = conn.execute(
            "SELECT 1 FROM inventory WHERE user_id = ? AND student_id = ?",
            (user_id, student_id),
        ).fetchone()
        if owned:
            return False, "already_owned"
        conn.execute("INSERT INTO inventory (user_id, student_id, count) VALUES (?, ?, 1)",
                     (user_id, student_id))
        conn.execute("UPDATE spark SET points = points - ? WHERE user_id = ? AND banner_id = ?",
                     (cost, user_id, banner_id))
        return True, ""


async def spark_claim(user_id: int, banner_id: str, student_id: int, rarity: int, cost: int = 200) -> tuple[bool, str]:
    return await asyncio.to_thread(_spark_claim_sync, user_id, banner_id, student_id, rarity, cost)


# ── Eligma ──────────────────────────────────────────────────────────────────

def _add_eligma_sync(conn: sqlite3.Connection, user_id: int, amount: int) -> None:
    conn.execute(
        "INSERT INTO eligma (user_id, amount) VALUES (?, ?) "
        "ON CONFLICT(user_id) DO UPDATE SET amount = amount + ?",
        (user_id, amount, amount),
    )


def _get_eligma_sync(user_id: int) -> int:
    with _connect() as conn:
        row = conn.execute(
            "SELECT amount FROM eligma WHERE user_id = ?", (user_id,)
        ).fetchone()
    return row[0] if row else 0


async def get_eligma(user_id: int) -> int:
    return await asyncio.to_thread(_get_eligma_sync, user_id)