Blame for tasks/leetcode/environment/reference/clone/leetcode_app/store.py

"""Site-owned SQLite business schema for the LeetCode offline clone.

The vendored ``websitebench.site_backend`` runtime owns the shared library
tables (site binding, mail jobs, payment ledger) and
``websitebench.local_clone_auth`` owns accounts, sessions and verification
flows. Everything below is this site's own business state, held in the same
site-bound database file:

* ``leetcode_questions``   — the seeded local question catalogue
* ``leetcode_profiles``    — username/account binding created during signup
* ``leetcode_drafts``      — the editor buffer per (member, question, language)
* ``leetcode_submissions`` — every graded submission, server-side
* ``leetcode_progress``    — solved / attempted status per member

Migrations are forward-only, recorded in ``leetcode_schema_migrations`` and
safe to re-run. Seeding is deterministic: the catalogue is rewritten from
:mod:`leetcode_app.content` on every boot, and every generated timestamp comes
from a fixed base clock plus a row counter, never from the wall clock.
"""

from __future__ import annotations

import json
import sqlite3
import threading
from contextlib import closing
from datetime import UTC, datetime, timedelta
from pathlib import Path
from typing import Any

from backend.site_backend_integration import open_site_services
from websitebench.local_clone_auth import LocalAuthStore
from websitebench.site_backend import SiteBackend

from . import content
from .content import Question


SITE_ID = "leetcode"

# One fixed base clock for the whole clone, so an identical operation sequence
# always produces identical stored state.
BASE_CLOCK = datetime(2026, 8, 20, 9, 0, 0, tzinfo=UTC)
STEP_SECONDS = 61

SOLVED = "solved"
ATTEMPTED = "attempted"

_MIGRATIONS: dict[str, str] = {
    "0001_catalogue": """
        CREATE TABLE IF NOT EXISTS leetcode_questions (
            slug TEXT PRIMARY KEY,
            number INTEGER NOT NULL UNIQUE,
            title TEXT NOT NULL,
            difficulty TEXT NOT NULL
                CHECK (difficulty IN ('Easy', 'Medium', 'Hard')),
            category TEXT NOT NULL,
            topics_json TEXT NOT NULL,
            companies_json TEXT NOT NULL,
            languages_json TEXT NOT NULL,
            acceptance REAL NOT NULL CHECK (acceptance >= 0),
            frequency INTEGER NOT NULL CHECK (frequency BETWEEN 0 AND 100),
            contest_point INTEGER NOT NULL CHECK (contest_point >= 0),
            detail_json TEXT NOT NULL
        );
        CREATE INDEX IF NOT EXISTS idx_leetcode_questions_category
            ON leetcode_questions (category, number);
    """,
    "0002_members": """
        CREATE TABLE IF NOT EXISTS leetcode_profiles (
            subject_id TEXT PRIMARY KEY,
            account_id TEXT NOT NULL UNIQUE,
            username TEXT NOT NULL,
            username_normalized TEXT NOT NULL UNIQUE,
            email_normalized TEXT NOT NULL UNIQUE,
            created_at TEXT NOT NULL
        );
    """,
    "0003_work": """
        CREATE TABLE IF NOT EXISTS leetcode_drafts (
            subject_id TEXT NOT NULL,
            question_slug TEXT NOT NULL,
            language TEXT NOT NULL,
            source TEXT NOT NULL,
            updated_at TEXT NOT NULL,
            PRIMARY KEY (subject_id, question_slug, language)
        );
        CREATE TABLE IF NOT EXISTS leetcode_submissions (
            id INTEGER PRIMARY KEY,
            subject_id TEXT NOT NULL,
            question_slug TEXT NOT NULL,
            language TEXT NOT NULL,
            status TEXT NOT NULL,
            message TEXT NOT NULL DEFAULT '',
            passed INTEGER NOT NULL CHECK (passed >= 0),
            total INTEGER NOT NULL CHECK (total >= 0),
            runtime_ms INTEGER,
            memory_mb REAL,
            runtime_percentile REAL,
            memory_percentile REAL,
            failing_input TEXT,
            failing_output TEXT,
            failing_expected TEXT,
            source TEXT NOT NULL,
            created_at TEXT NOT NULL
        );
        CREATE INDEX IF NOT EXISTS idx_leetcode_submissions_member
            ON leetcode_submissions (subject_id, id DESC);
        CREATE INDEX IF NOT EXISTS idx_leetcode_submissions_question
            ON leetcode_submissions (subject_id, question_slug, id DESC);
        CREATE TABLE IF NOT EXISTS leetcode_progress (
            subject_id TEXT NOT NULL,
            question_slug TEXT NOT NULL,
            status TEXT NOT NULL CHECK (status IN ('solved', 'attempted')),
            first_solved_at TEXT,
            last_submitted_at TEXT NOT NULL,
            attempts INTEGER NOT NULL DEFAULT 0 CHECK (attempts >= 0),
            PRIMARY KEY (subject_id, question_slug)
        );
    """,
}

_BUSINESS_TABLES = (
    "leetcode_progress",
    "leetcode_submissions",
    "leetcode_drafts",
    "leetcode_profiles",
)

_SERVICES_LOCK = threading.Lock()
_SERVICES: tuple[SiteBackend, LocalAuthStore] | None = None


# ---------------------------------------------------------------------------
# lifecycle
# ---------------------------------------------------------------------------


def services() -> tuple[SiteBackend, LocalAuthStore]:
    """Process-wide bound backend + auth pair with the business schema ready."""

    global _SERVICES
    with _SERVICES_LOCK:
        if _SERVICES is None:
            backend, auth = open_site_services()
            migrate(backend.lifecycle.database_path)
            seed_catalogue(backend.lifecycle.database_path)
            _SERVICES = (backend, auth)
        return _SERVICES


def close_services() -> None:
    global _SERVICES
    with _SERVICES_LOCK:
        _SERVICES = None


def database_path() -> Path:
    return services()[0].lifecycle.database_path


def _connect(path: Path) -> sqlite3.Connection:
    connection = sqlite3.connect(str(path), timeout=15)
    connection.row_factory = sqlite3.Row
    connection.execute("PRAGMA foreign_keys = ON")
    connection.execute("PRAGMA busy_timeout = 5000")
    return connection


def connect() -> sqlite3.Connection:
    return _connect(database_path())


def migrate(path: Path) -> list[str]:
    """Apply every pending forward migration. Safe to run repeatedly."""

    applied_now: list[str] = []
    with closing(_connect(path)) as connection, connection:
        connection.execute(
            """
            CREATE TABLE IF NOT EXISTS leetcode_schema_migrations (
                migration_id TEXT PRIMARY KEY,
                applied_at TEXT NOT NULL
            )
            """
        )
        applied = {
            str(row["migration_id"])
            for row in connection.execute(
                "SELECT migration_id FROM leetcode_schema_migrations"
            )
        }
        for migration_id, ddl in _MIGRATIONS.items():
            if migration_id in applied:
                continue
            connection.executescript(ddl)
            connection.execute(
                "INSERT INTO leetcode_schema_migrations (migration_id, applied_at)"
                " VALUES (?, ?)",
                (migration_id, BASE_CLOCK.isoformat().replace("+00:00", "Z")),
            )
            applied_now.append(migration_id)
    return applied_now


def applied_migrations(path: Path | None = None) -> list[str]:
    target = path or database_path()
    with closing(_connect(target)) as connection:
        return [
            str(row["migration_id"])
            for row in connection.execute(
                "SELECT migration_id FROM leetcode_schema_migrations"
                " ORDER BY migration_id"
            )
        ]


def seed_catalogue(path: Path) -> int:
    """Write the deterministic question catalogue. Idempotent by slug."""

    rows = [
        (
            item.slug,
            item.number,
            item.title,
            item.difficulty,
            item.category,
            json.dumps(list(item.topics), separators=(",", ":")),
            json.dumps(list(item.companies), separators=(",", ":")),
            json.dumps(list(item.languages), separators=(",", ":")),
            item.acceptance,
            item.frequency,
            item.contest_point,
            json.dumps(
                content.detail_payload(item), separators=(",", ":"), sort_keys=True
            ),
        )
        for item in content.iter_questions()
    ]
    with closing(_connect(path)) as connection, connection:
        connection.executemany(
            """
            INSERT INTO leetcode_questions (
                slug, number, title, difficulty, category, topics_json,
                companies_json, languages_json, acceptance, frequency,
                contest_point, detail_json
            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            ON CONFLICT(slug) DO UPDATE SET
                number = excluded.number,
                title = excluded.title,
                difficulty = excluded.difficulty,
                category = excluded.category,
                topics_json = excluded.topics_json,
                companies_json = excluded.companies_json,
                languages_json = excluded.languages_json,
                acceptance = excluded.acceptance,
                frequency = excluded.frequency,
                contest_point = excluded.contest_point,
                detail_json = excluded.detail_json
            """,
            rows,
        )
    return len(rows)


def reset() -> None:
    """Clear member state and re-seed. Used by tests and the reset endpoint."""

    backend, auth = services()

    def _site_reset(connection: sqlite3.Connection) -> None:
        for table in _BUSINESS_TABLES:
            connection.execute(f"DELETE FROM {table}")
        backend.lifecycle.reset_embedded(connection, confirm_site_id=SITE_ID)

    auth.reset_site_state(site_reset=_site_reset, seed_accounts=[])
    seed_catalogue(backend.lifecycle.database_path)


# ---------------------------------------------------------------------------
# deterministic clock
# ---------------------------------------------------------------------------


def _stamp(connection: sqlite3.Connection) -> str:
    row = connection.execute("SELECT COUNT(*) FROM leetcode_submissions").fetchone()
    sequence = int(row[0]) if row is not None else 0
    moment = BASE_CLOCK + timedelta(seconds=STEP_SECONDS * sequence)
    return moment.isoformat().replace("+00:00", "Z")


def profile_stamp(connection: sqlite3.Connection) -> str:
    row = connection.execute("SELECT COUNT(*) FROM leetcode_profiles").fetchone()
    sequence = int(row[0]) if row is not None else 0
    moment = BASE_CLOCK + timedelta(seconds=STEP_SECONDS * sequence)
    return moment.isoformat().replace("+00:00", "Z")


# ---------------------------------------------------------------------------
# catalogue reads
# ---------------------------------------------------------------------------


def _question_row(row: sqlite3.Row) -> dict[str, Any]:
    return {
        "slug": row["slug"],
        "number": int(row["number"]),
        "title": row["title"],
        "difficulty": row["difficulty"],
        "category": row["category"],
        "topics": json.loads(row["topics_json"]),
        "companies": json.loads(row["companies_json"]),
        "languages": json.loads(row["languages_json"]),
        "acceptance": float(row["acceptance"]),
        "frequency": int(row["frequency"]),
        "contest_point": int(row["contest_point"]),
        "detail": json.loads(row["detail_json"]),
    }


def question_count() -> int:
    with closing(connect()) as connection:
        row = connection.execute("SELECT COUNT(*) FROM leetcode_questions").fetchone()
        return int(row[0]) if row is not None else 0


def load_question(slug: str) -> dict[str, Any] | None:
    with closing(connect()) as connection:
        row = connection.execute(
            "SELECT * FROM leetcode_questions WHERE slug = ?", (slug,)
        ).fetchone()
    return _question_row(row) if row is not None else None


def catalogue_question(slug: str) -> Question | None:
    """The in-process question object used by the verdict model."""

    return content.question(slug)


# ---------------------------------------------------------------------------
# member profiles
# ---------------------------------------------------------------------------


def normalize_username(username: str) -> str:
    return " ".join(username.split()).casefold()


def username_taken(username: str) -> bool:
    with closing(connect()) as connection:
        return (
            connection.execute(
                "SELECT 1 FROM leetcode_profiles WHERE username_normalized = ?",
                (normalize_username(username),),
            ).fetchone()
            is not None
        )


def create_profile(
    connection: sqlite3.Connection,
    *,
    account_id: str,
    username: str,
    email: str,
) -> str:
    """Create the business member row inside the auth store's transaction."""

    subject_id = f"member_{normalize_username(username)}"
    connection.execute(
        """
        INSERT INTO leetcode_profiles (
            subject_id, account_id, username, username_normalized,
            email_normalized, created_at
        ) VALUES (?, ?, ?, ?, ?, ?)
        """,
        (
            subject_id,
            account_id,
            username,
            normalize_username(username),
            email,
            profile_stamp(connection),
        ),
    )
    return subject_id


def profile_for_email(email: str) -> dict[str, Any] | None:
    with closing(connect()) as connection:
        row = connection.execute(
            "SELECT * FROM leetcode_profiles WHERE email_normalized = ?",
            (email.strip().casefold(),),
        ).fetchone()
    return dict(row) if row is not None else None


def profile_for_username(username: str) -> dict[str, Any] | None:
    with closing(connect()) as connection:
        row = connection.execute(
            "SELECT * FROM leetcode_profiles WHERE username_normalized = ?",
            (normalize_username(username),),
        ).fetchone()
    return dict(row) if row is not None else None


def profile_for_subject(subject_id: str) -> dict[str, Any] | None:
    with closing(connect()) as connection:
        row = connection.execute(
            "SELECT * FROM leetcode_profiles WHERE subject_id = ?", (subject_id,)
        ).fetchone()
    return dict(row) if row is not None else None


def resolve_login_email(identifier: str) -> str:
    """Map a username-or-email login identifier onto the account email."""

    candidate = identifier.strip()
    if "@" in candidate:
        return candidate.casefold()
    profile = profile_for_username(candidate)
    if profile is None:
        # Keep the failure path indistinguishable: hand the auth store a
        # syntactically valid address that owns no account.
        return "unknown-member@leetcode.invalid"
    return str(profile["email_normalized"])


# ---------------------------------------------------------------------------
# drafts
# ---------------------------------------------------------------------------


def save_draft(subject_id: str, slug: str, language: str, source: str) -> str:
    with closing(connect()) as connection, connection:
        updated_at = profile_stamp(connection)
        connection.execute(
            """
            INSERT INTO leetcode_drafts (
                subject_id, question_slug, language, source, updated_at
            ) VALUES (?, ?, ?, ?, ?)
            ON CONFLICT(subject_id, question_slug, language) DO UPDATE SET
                source = excluded.source,
                updated_at = excluded.updated_at
            """,
            (subject_id, slug, language, source, updated_at),
        )
    return updated_at


def load_draft(subject_id: str, slug: str, language: str) -> dict[str, Any] | None:
    with closing(connect()) as connection:
        row = connection.execute(
            "SELECT source, updated_at FROM leetcode_drafts"
            " WHERE subject_id = ? AND question_slug = ? AND language = ?",
            (subject_id, slug, language),
        ).fetchone()
    return dict(row) if row is not None else None


# ---------------------------------------------------------------------------
# submissions and progress
# ---------------------------------------------------------------------------


def record_submission(
    subject_id: str,
    slug: str,
    language: str,
    source: str,
    verdict: Any,
) -> dict[str, Any]:
    """Persist one graded submission and update the member's progress."""

    failing = verdict.failing
    with closing(connect()) as connection, connection:
        connection.execute("BEGIN IMMEDIATE")
        created_at = _stamp(connection)
        cursor = connection.execute(
            """
            INSERT INTO leetcode_submissions (
                subject_id, question_slug, language, status, message, passed,
                total, runtime_ms, memory_mb, runtime_percentile,
                memory_percentile, failing_input, failing_output,
                failing_expected, source, created_at
            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            """,
            (
                subject_id,
                slug,
                language,
                verdict.status,
                verdict.message,
                verdict.passed,
                verdict.total,
                verdict.runtime_ms,
                verdict.memory_mb,
                verdict.runtime_percentile,
                verdict.memory_percentile,
                failing.input if failing is not None else None,
                failing.output if failing is not None else None,
                failing.expected if failing is not None else None,
                source,
                created_at,
            ),
        )
        submission_id = int(cursor.lastrowid or 0)
        solved = verdict.status == "Accepted"
        existing = connection.execute(
            "SELECT status, first_solved_at, attempts FROM leetcode_progress"
            " WHERE subject_id = ? AND question_slug = ?",
            (subject_id, slug),
        ).fetchone()
        attempts = (int(existing["attempts"]) if existing is not None else 0) + 1
        first_solved_at = existing["first_solved_at"] if existing is not None else None
        if solved and first_solved_at is None:
            first_solved_at = created_at
        status = SOLVED if (solved or first_solved_at is not None) else ATTEMPTED
        connection.execute(
            """
            INSERT INTO leetcode_progress (
                subject_id, question_slug, status, first_solved_at,
                last_submitted_at, attempts
            ) VALUES (?, ?, ?, ?, ?, ?)
            ON CONFLICT(subject_id, question_slug) DO UPDATE SET
                status = excluded.status,
                first_solved_at = excluded.first_solved_at,
                last_submitted_at = excluded.last_submitted_at,
                attempts = excluded.attempts
            """,
            (subject_id, slug, status, first_solved_at, created_at, attempts),
        )
    return {"submission_id": submission_id, "created_at": created_at}


def submission(subject_id: str, submission_id: int) -> dict[str, Any] | None:
    with closing(connect()) as connection:
        row = connection.execute(
            "SELECT * FROM leetcode_submissions WHERE id = ? AND subject_id = ?",
            (submission_id, subject_id),
        ).fetchone()
    return dict(row) if row is not None else None


def submissions(
    subject_id: str,
    *,
    slug: str | None = None,
    limit: int = 20,
    offset: int = 0,
) -> list[dict[str, Any]]:
    query = (
        "SELECT s.*, q.title, q.number FROM leetcode_submissions s"
        " JOIN leetcode_questions q ON q.slug = s.question_slug"
        " WHERE s.subject_id = ?"
    )
    parameters: list[Any] = [subject_id]
    if slug is not None:
        query += " AND s.question_slug = ?"
        parameters.append(slug)
    query += " ORDER BY s.id DESC LIMIT ? OFFSET ?"
    parameters.extend([limit, offset])
    with closing(connect()) as connection:
        return [dict(row) for row in connection.execute(query, parameters)]


def submission_count(subject_id: str, *, slug: str | None = None) -> int:
    query = "SELECT COUNT(*) FROM leetcode_submissions WHERE subject_id = ?"
    parameters: list[Any] = [subject_id]
    if slug is not None:
        query += " AND question_slug = ?"
        parameters.append(slug)
    with closing(connect()) as connection:
        row = connection.execute(query, parameters).fetchone()
    return int(row[0]) if row is not None else 0


def progress_map(subject_id: str | None) -> dict[str, str]:
    if not subject_id:
        return {}
    with closing(connect()) as connection:
        return {
            str(row["question_slug"]): str(row["status"])
            for row in connection.execute(
                "SELECT question_slug, status FROM leetcode_progress"
                " WHERE subject_id = ?",
                (subject_id,),
            )
        }


def progress_summary(subject_id: str | None) -> dict[str, Any]:
    """Solved/attempted counts by difficulty, plus the totals shown on /progress/."""

    totals = {"Easy": 0, "Medium": 0, "Hard": 0}
    solved = {"Easy": 0, "Medium": 0, "Hard": 0}
    attempted = {"Easy": 0, "Medium": 0, "Hard": 0}
    with closing(connect()) as connection:
        for row in connection.execute(
            "SELECT difficulty, COUNT(*) AS total FROM leetcode_questions"
            " GROUP BY difficulty"
        ):
            totals[str(row["difficulty"])] = int(row["total"])
        if subject_id:
            for row in connection.execute(
                """
                SELECT q.difficulty AS difficulty, p.status AS status,
                       COUNT(*) AS total
                FROM leetcode_progress p
                JOIN leetcode_questions q ON q.slug = p.question_slug
                WHERE p.subject_id = ?
                GROUP BY q.difficulty, p.status
                """,
                (subject_id,),
            ):
                bucket = solved if str(row["status"]) == SOLVED else attempted
                bucket[str(row["difficulty"])] = int(row["total"])
        submissions_total = (
            submission_count(subject_id) if subject_id else 0
        )
        accepted_total = 0
        if subject_id:
            row = connection.execute(
                "SELECT COUNT(*) FROM leetcode_submissions"
                " WHERE subject_id = ? AND status = 'Accepted'",
                (subject_id,),
            ).fetchone()
            accepted_total = int(row[0]) if row is not None else 0
    return {
        "totals": totals,
        "solved": solved,
        "attempted": attempted,
        "total_questions": sum(totals.values()),
        "total_solved": sum(solved.values()),
        "total_attempted": sum(attempted.values()),
        "submissions": submissions_total,
        "accepted": accepted_total,
        "acceptance_rate": (
            round(accepted_total * 100 / submissions_total, 1)
            if submissions_total
            else 0.0
        ),
    }


def last_submitted_map(subject_id: str | None) -> dict[str, str]:
    if not subject_id:
        return {}
    with closing(connect()) as connection:
        return {
            str(row["question_slug"]): str(row["last_submitted_at"])
            for row in connection.execute(
                "SELECT question_slug, last_submitted_at FROM leetcode_progress"
                " WHERE subject_id = ?",
                (subject_id,),
            )
        }