"""Copy-only Amazon cutover into a distinct WebsiteBench database path."""

from __future__ import annotations

import sqlite3
from collections.abc import Callable
from contextlib import closing
from pathlib import Path

from websitebench.site_backend.copy_cutover import (
    CopyCutoverError,
    publish_transformed_sqlite_copy,
)
from websitebench.site_backend.database import BASE_SCHEMA, utc_now


LEGACY_FILENAME = "amazon.sqlite3"
CANONICAL_FILENAME = "amazon.sqlite3"
NAMESPACE_BACKUP_SUFFIX = ".clawbench-legacy"
UNBOUND_BACKUP_SUFFIX = ".amazon-unbound-legacy"
LEGACY_TABLES = {
    "clawbench_site_binding": "websitebench_site_binding",
    "clawbench_backend_migrations": "websitebench_backend_migrations",
    "clawbench_mail_jobs": "websitebench_mail_jobs",
    "clawbench_payment_flows": "websitebench_payment_flows",
    "clawbench_payment_attempts": "websitebench_payment_attempts",
    "clawbench_payment_events": "websitebench_payment_events",
}
MIGRATION_ID = "namespace-copy-v1:clawbench-to-websitebench"


class NamespaceMigrationError(CopyCutoverError):
    """Raised when a legacy database cannot be migrated without ambiguity."""


def _objects(connection: sqlite3.Connection, kind: str) -> set[str]:
    return {
        str(row[0])
        for row in connection.execute(
            "SELECT name FROM sqlite_master WHERE type=?",
            (kind,),
        )
    }


def _validate_amazon_business_schema(connection: sqlite3.Connection) -> None:
    required_columns = {
        "meta": {"key", "value"},
        "catalog_products": {
            "asin",
            "slug",
            "title",
            "price_minor",
            "currency",
        },
        "accounts": {
            "account_id",
            "email_normalized",
            "password_salt",
            "password_hash",
        },
        "browser_sessions": {"session_digest", "reset_epoch", "created_at"},
    }
    tables = _objects(connection, "table")
    for table, expected in required_columns.items():
        if table not in tables:
            raise NamespaceMigrationError(
                "legacy database does not match the Amazon schema"
            )
        actual = {
            str(row[1])
            for row in connection.execute(f'PRAGMA table_info("{table}")')
        }
        if not expected.issubset(actual):
            raise NamespaceMigrationError(
                "legacy database does not match the Amazon schema"
            )


def _legacy_binding(connection: sqlite3.Connection) -> str | None:
    if "clawbench_site_binding" not in _objects(connection, "table"):
        return None
    rows = connection.execute(
        "SELECT singleton,site_id FROM clawbench_site_binding"
    ).fetchall()
    if len(rows) != 1 or int(rows[0][0]) != 1:
        raise NamespaceMigrationError("legacy site binding is missing or corrupt")
    return str(rows[0][1])


def _validate_canonical(database: Path, *, expected_site_id: str) -> None:
    try:
        with closing(sqlite3.connect(database)) as connection:
            _validate_amazon_business_schema(connection)
            tables = _objects(connection, "table")
            binding = connection.execute(
                "SELECT singleton,site_id FROM websitebench_site_binding"
            ).fetchall()
            integrity = connection.execute("PRAGMA integrity_check").fetchall()
            foreign_keys = connection.execute("PRAGMA foreign_key_check").fetchall()
    except sqlite3.DatabaseError as exc:
        raise NamespaceMigrationError(
            "authorized Amazon copy is not valid SQLite"
        ) from exc
    if (
        binding != [(1, expected_site_id)]
        or integrity != [("ok",)]
        or foreign_keys
        or set(LEGACY_TABLES) & tables
    ):
        raise NamespaceMigrationError("authorized Amazon copy failed validation")


def _publish(
    source: Path,
    canonical: Path,
    *,
    expected_site_id: str,
    transform: Callable[[Path], None],
    validate_source: Callable[[sqlite3.Connection], None],
    publication_hook: Callable[[], None] | None,
) -> None:
    try:
        publish_transformed_sqlite_copy(
            source,
            canonical,
            expected_source_name=LEGACY_FILENAME,
            expected_canonical_name=CANONICAL_FILENAME,
            transform=transform,
            validate_source=validate_source,
            validate_canonical=lambda path: _validate_canonical(
                path, expected_site_id=expected_site_id
            ),
            reserved_paths=tuple(
                source.with_name(source.name + suffix)
                for suffix in (NAMESPACE_BACKUP_SUFFIX, UNBOUND_BACKUP_SUFFIX)
            ),
            publication_hook=publication_hook,
        )
    except CopyCutoverError as exc:
        if isinstance(exc, NamespaceMigrationError):
            raise
        raise NamespaceMigrationError(str(exc)) from exc


def migrate_amazon_source_copy(
    source: Path,
    canonical: Path,
    *,
    expected_site_id: str,
    authorize_unbound: bool,
    prepare_copy: Callable[[Path], None],
    publication_hook: Callable[[], None] | None = None,
) -> bool:
    """Validate and migrate Amazon only after raw snapshot isolation.

    The legacy source is never opened through SQLite. Binding detection,
    business provenance, and namespace selection all inspect the owned working
    snapshot supplied by the shared cutover helper.
    """

    if not source.exists():
        return False

    mode: str | None = None

    def validate_source(connection: sqlite3.Connection) -> None:
        nonlocal mode
        _validate_amazon_business_schema(connection)
        tables = _objects(connection, "table")
        bound_site = _legacy_binding(connection)
        if bound_site is None:
            if "websitebench_site_binding" in tables:
                raise NamespaceMigrationError(
                    "legacy Amazon source is already WebsiteBench-bound"
                )
            if not authorize_unbound:
                raise NamespaceMigrationError(
                    "legacy Amazon database requires explicit site binding"
                )
            mode = "unbound"
            return
        if bound_site != expected_site_id:
            raise NamespaceMigrationError(
                f"legacy database belongs to site {bound_site!r}, "
                f"not {expected_site_id!r}"
            )
        if set(LEGACY_TABLES.values()) & tables:
            raise NamespaceMigrationError(
                "database contains mixed WebsiteBench and ClawBench backend tables"
            )
        missing = set(LEGACY_TABLES) - tables
        if missing:
            raise NamespaceMigrationError(
                "legacy site-backend schema is incomplete: "
                + ", ".join(sorted(missing))
            )
        mode = "namespace"

    def transform(database: Path) -> None:
        if mode == "namespace":
            _migrate_namespace_copy(database, expected_site_id=expected_site_id)
            return
        if mode == "unbound":
            _bind_unbound_copy(
                database,
                expected_site_id=expected_site_id,
                prepare_copy=prepare_copy,
            )
            return
        raise NamespaceMigrationError("Amazon migration mode was not validated")

    _publish(
        source,
        canonical,
        expected_site_id=expected_site_id,
        transform=transform,
        validate_source=validate_source,
        publication_hook=publication_hook,
    )
    return True


def _bind_unbound_copy(
    database: Path,
    *,
    expected_site_id: str,
    prepare_copy: Callable[[Path], None],
) -> None:
    with closing(sqlite3.connect(database, isolation_level=None)) as connection:
        connection.execute("PRAGMA foreign_keys=ON")
        connection.executescript(BASE_SCHEMA)
        connection.execute("BEGIN IMMEDIATE")
        try:
            connection.execute(
                "INSERT INTO websitebench_site_binding"
                "(singleton,site_id,bound_at) VALUES (1,?,?)",
                (expected_site_id, utc_now()),
            )
            connection.execute(
                "INSERT OR IGNORE INTO websitebench_backend_migrations"
                "(migration_id,applied_at) VALUES (?,?)",
                ("site-backend-v1", utc_now()),
            )
            connection.execute("COMMIT")
        except BaseException:
            if connection.in_transaction:
                connection.execute("ROLLBACK")
            raise
    prepare_copy(database)
    _revoke_pre_cutover_sessions(database)


def _revoke_pre_cutover_sessions(database: Path) -> None:
    with closing(sqlite3.connect(database, isolation_level=None)) as connection:
        if "local_auth_sessions" in _objects(connection, "table"):
            connection.execute(
                "UPDATE local_auth_sessions "
                "SET revoked_at=COALESCE("
                "revoked_at, CAST(strftime('%s','now') AS INTEGER))"
            )


def _migrate_namespace_copy(database: Path, *, expected_site_id: str) -> None:
    with closing(sqlite3.connect(database, isolation_level=None)) as connection:
        connection.execute("PRAGMA foreign_keys=ON")
        connection.execute("PRAGMA busy_timeout=30000")
        connection.execute("BEGIN IMMEDIATE")
        try:
            connection.execute(
                "DROP TRIGGER IF EXISTS clawbench_payment_events_no_update"
            )
            connection.execute(
                "DROP TRIGGER IF EXISTS clawbench_payment_events_no_delete"
            )
            connection.execute("DROP INDEX IF EXISTS clawbench_mail_jobs_status_idx")
            connection.execute(
                "DROP INDEX IF EXISTS clawbench_payment_one_active_approval"
            )
            for legacy, canonical_name in LEGACY_TABLES.items():
                connection.execute(
                    f'ALTER TABLE "{legacy}" RENAME TO "{canonical_name}"'
                )
            connection.execute(
                "CREATE INDEX websitebench_mail_jobs_status_idx "
                "ON websitebench_mail_jobs(site_id,status,created_at)"
            )
            connection.execute(
                "CREATE UNIQUE INDEX websitebench_payment_one_active_approval "
                "ON websitebench_payment_attempts(site_id,flow_id) "
                "WHERE status='APPROVED'"
            )
            connection.execute(
                """
                CREATE TRIGGER websitebench_payment_events_no_update
                BEFORE UPDATE ON websitebench_payment_events
                BEGIN
                    SELECT RAISE(ABORT, 'payment events are immutable');
                END
                """
            )
            connection.execute(
                """
                CREATE TRIGGER websitebench_payment_events_no_delete
                BEFORE DELETE ON websitebench_payment_events
                BEGIN
                    SELECT RAISE(ABORT, 'payment events are immutable');
                END
                """
            )
            connection.execute(
                "INSERT OR IGNORE INTO websitebench_backend_migrations"
                "(migration_id,applied_at) VALUES (?,datetime('now'))",
                (MIGRATION_ID,),
            )
            if "local_auth_sessions" in _objects(connection, "table"):
                connection.execute(
                    "UPDATE local_auth_sessions "
                    "SET revoked_at=COALESCE("
                    "revoked_at, CAST(strftime('%s','now') AS INTEGER))"
                )
            connection.execute("COMMIT")
        except BaseException:
            if connection.in_transaction:
                connection.execute("ROLLBACK")
            raise