"""Site-owned donation, favorite, and recurring-plan semantics for ioby.

The live site was observed in its archival/closed state, so none of its
production donation or account endpoints were mutated.  These tables model the
frozen WebsiteBench journeys locally.  Payment outcomes come only from the
generated ``websitebench.site_backend`` local sandbox; this module never
accepts card data and never contacts ioby or a payment provider.
"""

from __future__ import annotations

import sqlite3
import uuid
from datetime import UTC, datetime
from typing import Any, Mapping


PROJECT_SLUG = "make-block-bloom"
PROJECT_TITLE = "Make the Block Bloom"


SCHEMA = """
CREATE TABLE IF NOT EXISTS ioby_schema_migrations (
    version TEXT PRIMARY KEY,
    applied_at TEXT NOT NULL
);

CREATE TABLE IF NOT EXISTS ioby_donations (
    id TEXT PRIMARY KEY,
    owner_key TEXT NOT NULL,
    account_id TEXT,
    project_slug TEXT NOT NULL,
    project_title TEXT NOT NULL,
    status TEXT NOT NULL CHECK(status IN ('draft','confirmed','canceled')),
    cadence TEXT NOT NULL CHECK(cadence IN ('one-time','monthly')),
    amount_cents INTEGER NOT NULL CHECK(amount_cents BETWEEN 100 AND 10000000),
    tip_cents INTEGER NOT NULL DEFAULT 0 CHECK(tip_cents BETWEEN 0 AND 10000000),
    donor_name TEXT,
    donor_email TEXT,
    recognition TEXT NOT NULL DEFAULT 'public'
        CHECK(recognition IN ('public','anonymous')),
    dedication TEXT,
    payment_snapshot_token TEXT NOT NULL UNIQUE,
    payment_flow_id TEXT,
    payment_attempt_id TEXT,
    receipt_number TEXT UNIQUE,
    created_at TEXT NOT NULL,
    updated_at TEXT NOT NULL,
    confirmed_at TEXT
);
CREATE INDEX IF NOT EXISTS ioby_donations_owner_idx
    ON ioby_donations(owner_key, created_at DESC);
CREATE INDEX IF NOT EXISTS ioby_donations_account_idx
    ON ioby_donations(account_id, created_at DESC);

CREATE TABLE IF NOT EXISTS ioby_recurring_plans (
    id TEXT PRIMARY KEY,
    donation_id TEXT NOT NULL UNIQUE
        REFERENCES ioby_donations(id) ON DELETE CASCADE,
    account_id TEXT,
    owner_key TEXT NOT NULL,
    project_slug TEXT NOT NULL,
    amount_cents INTEGER NOT NULL,
    status TEXT NOT NULL CHECK(status IN ('active','canceled')),
    next_local_run TEXT,
    canceled_at TEXT,
    created_at TEXT NOT NULL,
    updated_at TEXT NOT NULL
);

CREATE TABLE IF NOT EXISTS ioby_favorites (
    account_id TEXT NOT NULL,
    project_slug TEXT NOT NULL,
    created_at TEXT NOT NULL,
    PRIMARY KEY(account_id, project_slug)
);

CREATE TABLE IF NOT EXISTS ioby_receipts (
    receipt_number TEXT PRIMARY KEY,
    donation_id TEXT NOT NULL UNIQUE
        REFERENCES ioby_donations(id) ON DELETE CASCADE,
    owner_key TEXT NOT NULL,
    account_id TEXT,
    project_slug TEXT NOT NULL,
    amount_cents INTEGER NOT NULL,
    cadence TEXT NOT NULL,
    created_at TEXT NOT NULL
);

CREATE TABLE IF NOT EXISTS ioby_project_totals (
    project_slug TEXT PRIMARY KEY,
    confirmed_amount_cents INTEGER NOT NULL DEFAULT 0,
    confirmed_donation_count INTEGER NOT NULL DEFAULT 0,
    updated_at TEXT NOT NULL
);
"""


def now() -> str:
    return datetime.now(UTC).replace(microsecond=0).isoformat().replace("+00:00", "Z")


def _id(prefix: str) -> str:
    return f"{prefix}_{uuid.uuid4().hex}"


def _opaque_snapshot_token() -> str:
    """Return an opaque 256-bit token without adding a hash mechanism."""

    return uuid.uuid4().hex + uuid.uuid4().hex


def migrate(connection: sqlite3.Connection) -> None:
    connection.executescript(SCHEMA)
    columns = {
        str(row[1])
        for row in connection.execute("PRAGMA table_info(ioby_donations)").fetchall()
    }
    if "payment_snapshot_token" not in columns:
        connection.execute(
            "ALTER TABLE ioby_donations ADD COLUMN payment_snapshot_token TEXT"
        )
    missing = connection.execute(
        "SELECT id FROM ioby_donations WHERE payment_snapshot_token IS NULL"
    ).fetchall()
    for row in missing:
        connection.execute(
            "UPDATE ioby_donations SET payment_snapshot_token=? WHERE id=?",
            (_opaque_snapshot_token(), row[0]),
        )
    connection.execute(
        "INSERT OR IGNORE INTO ioby_schema_migrations(version,applied_at) VALUES (?,?)",
        ("001-local-community-donations", now()),
    )
    connection.execute(
        "INSERT OR IGNORE INTO ioby_schema_migrations(version,applied_at) VALUES (?,?)",
        ("002-atomic-receipts-and-opaque-payment-snapshots", now()),
    )
    connection.execute(
        """INSERT OR IGNORE INTO ioby_receipts(
            receipt_number,donation_id,owner_key,account_id,project_slug,
            amount_cents,cadence,created_at
        )
        SELECT receipt_number,id,owner_key,account_id,project_slug,
               amount_cents + tip_cents,cadence,COALESCE(confirmed_at,updated_at)
        FROM ioby_donations
        WHERE status='confirmed' AND receipt_number IS NOT NULL"""
    )


def _public(row: sqlite3.Row | None) -> dict[str, Any] | None:
    return dict(row) if row is not None else None


def seed_demo(connection: sqlite3.Connection, account_id: str) -> None:
    """Install deterministic offline history for the seeded local donor."""

    connection.execute(
        """INSERT OR IGNORE INTO ioby_donations(
            id,owner_key,account_id,project_slug,project_title,status,cadence,
            amount_cents,tip_cents,donor_name,donor_email,recognition,dedication,
            payment_snapshot_token,receipt_number,created_at,updated_at,confirmed_at
        ) VALUES (?,?,?,?,?,'confirmed','one-time',2500,0,?,?,?,?, ?,?,?,?,?)""",
        (
            "donation_seed_history",
            "seed:ioby-demo-donor",
            account_id,
            PROJECT_SLUG,
            PROJECT_TITLE,
            "Morgan Neighbor",
            "demo@ioby.local",
            "public",
            "For greener blocks.",
            "0000000000000000000000000000000000000000000000000000000000000001",
            "IOBY-LOCAL-SEED-001",
            "2026-01-15T15:00:00Z",
            "2026-01-15T15:00:00Z",
            "2026-01-15T15:00:00Z",
        ),
    )
    connection.execute(
        """INSERT OR IGNORE INTO ioby_donations(
            id,owner_key,account_id,project_slug,project_title,status,cadence,
            amount_cents,tip_cents,donor_name,donor_email,recognition,
            payment_snapshot_token,receipt_number,created_at,updated_at,confirmed_at
        ) VALUES (?,?,?,?,?,'confirmed','monthly',1000,0,?,?,?, ?,?,?,?,?)""",
        (
            "donation_seed_recurring",
            "seed:ioby-demo-donor",
            account_id,
            PROJECT_SLUG,
            PROJECT_TITLE,
            "Morgan Neighbor",
            "demo@ioby.local",
            "anonymous",
            "0000000000000000000000000000000000000000000000000000000000000002",
            "IOBY-LOCAL-SEED-002",
            "2026-02-01T15:00:00Z",
            "2026-02-01T15:00:00Z",
            "2026-02-01T15:00:00Z",
        ),
    )
    connection.execute(
        """INSERT OR IGNORE INTO ioby_recurring_plans(
            id,donation_id,account_id,owner_key,project_slug,amount_cents,status,
            next_local_run,created_at,updated_at
        ) VALUES (?,?,?,?,?,1000,'active',?,?,?)""",
        (
            "recurring_seed_plan",
            "donation_seed_recurring",
            account_id,
            "seed:ioby-demo-donor",
            PROJECT_SLUG,
            "2026-09-01T15:00:00Z",
            "2026-02-01T15:00:00Z",
            "2026-02-01T15:00:00Z",
        ),
    )
    connection.execute(
        """INSERT INTO ioby_project_totals(
            project_slug,confirmed_amount_cents,confirmed_donation_count,updated_at
        ) VALUES (?,?,?,?)
        ON CONFLICT(project_slug) DO UPDATE SET
            confirmed_amount_cents=(
                SELECT COALESCE(SUM(amount_cents + tip_cents),0)
                FROM ioby_donations
                WHERE project_slug=excluded.project_slug AND status='confirmed'
            ),
            confirmed_donation_count=(
                SELECT COUNT(*) FROM ioby_donations
                WHERE project_slug=excluded.project_slug AND status='confirmed'
            ),
            -- Seeding replays on every start.  Stamping a new time when the
            -- recomputed totals are unchanged would rewrite durable state on a
            -- restart that changed no business row, so only a real change to
            -- the totals moves the timestamp.
            updated_at=CASE
                WHEN confirmed_amount_cents=(
                        SELECT COALESCE(SUM(amount_cents + tip_cents),0)
                        FROM ioby_donations
                        WHERE project_slug=excluded.project_slug
                          AND status='confirmed'
                    )
                    AND confirmed_donation_count=(
                        SELECT COUNT(*) FROM ioby_donations
                        WHERE project_slug=excluded.project_slug
                          AND status='confirmed'
                    )
                THEN updated_at
                ELSE excluded.updated_at
            END""",
        (PROJECT_SLUG, 3500, 2, now()),
    )


def create_draft(
    connection: sqlite3.Connection,
    *,
    owner_key: str,
    account_id: str | None,
    project_slug: str,
    amount_cents: int,
    cadence: str,
) -> dict[str, Any]:
    donation_id = _id("donation")
    timestamp = now()
    connection.execute(
        """INSERT INTO ioby_donations(
            id,owner_key,account_id,project_slug,project_title,status,cadence,
            amount_cents,payment_snapshot_token,created_at,updated_at
        ) VALUES (?,?,?,?,?,'draft',?,?,?,?,?)""",
        (
            donation_id,
            owner_key,
            account_id,
            project_slug,
            PROJECT_TITLE,
            cadence,
            amount_cents,
            _opaque_snapshot_token(),
            timestamp,
            timestamp,
        ),
    )
    return get_donation(
        connection,
        donation_id,
        owner_key=owner_key,
        account_id=account_id,
    )  # type: ignore[return-value]


def get_donation(
    connection: sqlite3.Connection,
    donation_id: str,
    *,
    owner_key: str | None,
    account_id: str | None,
) -> dict[str, Any] | None:
    row = connection.execute(
        "SELECT * FROM ioby_donations WHERE id=?", (donation_id,)
    ).fetchone()
    if row is None:
        return None
    if row["owner_key"] != owner_key and not (
        account_id and row["account_id"] == account_id
    ):
        return None
    return _public(row)


def update_details(
    connection: sqlite3.Connection,
    donation_id: str,
    values: Mapping[str, Any],
    *,
    owner_key: str,
    account_id: str | None,
) -> dict[str, Any] | None:
    existing = get_donation(
        connection, donation_id, owner_key=owner_key, account_id=account_id
    )
    if existing is None or existing["status"] != "draft":
        return None
    allowed = {"donor_name", "donor_email", "recognition", "dedication", "tip_cents"}
    clean = {key: value for key, value in values.items() if key in allowed}
    if clean:
        assignments = ",".join(f"{key}=?" for key in clean)
        connection.execute(
            f"""UPDATE ioby_donations
                SET {assignments},payment_snapshot_token=?,updated_at=?
                WHERE id=?""",
            (*clean.values(), _opaque_snapshot_token(), now(), donation_id),
        )
    return get_donation(
        connection, donation_id, owner_key=owner_key, account_id=account_id
    )


def payment_facts(donation: Mapping[str, Any]) -> dict[str, Any]:
    """Return immutable sandbox facts without inventing a site-side hash."""

    return {
        "owner": str(donation["owner_key"]),
        "amount_minor": int(donation["amount_cents"]) + int(donation["tip_cents"]),
        "currency": "USD",
        "fingerprint": str(donation["payment_snapshot_token"]),
    }


def record_payment_approval(
    connection: sqlite3.Connection,
    donation_id: str,
    *,
    owner_key: str,
    account_id: str | None,
    payment_flow_id: str,
    payment_attempt_id: str,
) -> dict[str, Any] | None:
    donation = get_donation(
        connection, donation_id, owner_key=owner_key, account_id=account_id
    )
    if donation is None or donation["status"] != "draft":
        return None
    connection.execute(
        """UPDATE ioby_donations
           SET payment_flow_id=?,payment_attempt_id=?,updated_at=?
           WHERE id=? AND status='draft'""",
        (payment_flow_id, payment_attempt_id, now(), donation_id),
    )
    return get_donation(
        connection, donation_id, owner_key=owner_key, account_id=account_id
    )


def confirm_donation(
    connection: sqlite3.Connection,
    *,
    donation_id: str,
    owner_key: str,
    account_id: str | None,
    payment_flow_id: str,
    payment_attempt_id: str,
) -> dict[str, Any] | None:
    donation = get_donation(
        connection, donation_id, owner_key=owner_key, account_id=account_id
    )
    if donation is None:
        return None
    if donation["status"] == "confirmed":
        return donation
    if donation["status"] != "draft":
        return None
    timestamp = now()
    receipt = f"IOBY-LOCAL-{uuid.uuid4().hex[:12].upper()}"
    changed = connection.execute(
        """UPDATE ioby_donations
           SET status='confirmed',account_id=COALESCE(account_id,?),
               payment_flow_id=?,payment_attempt_id=?,receipt_number=?,
               confirmed_at=?,updated_at=?
           WHERE id=? AND status='draft'""",
        (
            account_id,
            payment_flow_id,
            payment_attempt_id,
            receipt,
            timestamp,
            timestamp,
            donation_id,
        ),
    ).rowcount
    if changed != 1:
        return get_donation(
            connection, donation_id, owner_key=owner_key, account_id=account_id
        )
    connection.execute(
        """INSERT INTO ioby_receipts(
            receipt_number,donation_id,owner_key,account_id,project_slug,
            amount_cents,cadence,created_at
        ) VALUES (?,?,?,?,?,?,?,?)""",
        (
            receipt,
            donation_id,
            owner_key,
            account_id,
            donation["project_slug"],
            int(donation["amount_cents"]) + int(donation["tip_cents"]),
            donation["cadence"],
            timestamp,
        ),
    )
    connection.execute(
        """INSERT INTO ioby_project_totals(
            project_slug,confirmed_amount_cents,confirmed_donation_count,updated_at
        ) VALUES (?,?,1,?)
        ON CONFLICT(project_slug) DO UPDATE SET
            confirmed_amount_cents=confirmed_amount_cents+excluded.confirmed_amount_cents,
            confirmed_donation_count=confirmed_donation_count+1,
            updated_at=excluded.updated_at""",
        (
            donation["project_slug"],
            int(donation["amount_cents"]) + int(donation["tip_cents"]),
            timestamp,
        ),
    )
    if donation["cadence"] == "monthly":
        connection.execute(
            """INSERT INTO ioby_recurring_plans(
                id,donation_id,account_id,owner_key,project_slug,amount_cents,
                status,next_local_run,created_at,updated_at
            ) VALUES (?,?,?,?,?,?,'active',?,?,?)""",
            (
                _id("recurring"),
                donation_id,
                account_id,
                owner_key,
                donation["project_slug"],
                donation["amount_cents"],
                "next local monthly cycle",
                timestamp,
                timestamp,
            ),
        )
    return get_donation(
        connection, donation_id, owner_key=owner_key, account_id=account_id
    )


def claim_donations(
    connection: sqlite3.Connection, *, owner_key: str, account_id: str
) -> None:
    connection.execute(
        "UPDATE ioby_donations SET account_id=? WHERE owner_key=? AND account_id IS NULL",
        (account_id, owner_key),
    )
    connection.execute(
        "UPDATE ioby_recurring_plans SET account_id=? WHERE owner_key=? AND account_id IS NULL",
        (account_id, owner_key),
    )


def list_donations(connection: sqlite3.Connection, account_id: str) -> list[dict[str, Any]]:
    return [
        dict(row)
        for row in connection.execute(
            """SELECT * FROM ioby_donations
               WHERE account_id=? AND status='confirmed'
               ORDER BY confirmed_at DESC, created_at DESC""",
            (account_id,),
        )
    ]


def list_recurring(connection: sqlite3.Connection, account_id: str) -> list[dict[str, Any]]:
    return [
        dict(row)
        for row in connection.execute(
            """SELECT r.*,d.project_title FROM ioby_recurring_plans r
               JOIN ioby_donations d ON d.id=r.donation_id
               WHERE r.account_id=? ORDER BY r.created_at DESC""",
            (account_id,),
        )
    ]


def cancel_recurring(
    connection: sqlite3.Connection, plan_id: str, account_id: str
) -> dict[str, Any] | None:
    row = connection.execute(
        "SELECT * FROM ioby_recurring_plans WHERE id=? AND account_id=?",
        (plan_id, account_id),
    ).fetchone()
    if row is None:
        return None
    if row["status"] == "active":
        timestamp = now()
        connection.execute(
            """UPDATE ioby_recurring_plans
               SET status='canceled',canceled_at=?,updated_at=?
               WHERE id=? AND account_id=? AND status='active'""",
            (timestamp, timestamp, plan_id, account_id),
        )
    return _public(
        connection.execute(
            "SELECT * FROM ioby_recurring_plans WHERE id=? AND account_id=?",
            (plan_id, account_id),
        ).fetchone()
    )


def is_favorite(connection: sqlite3.Connection, account_id: str, project_slug: str) -> bool:
    return connection.execute(
        "SELECT 1 FROM ioby_favorites WHERE account_id=? AND project_slug=?",
        (account_id, project_slug),
    ).fetchone() is not None


def set_favorite(
    connection: sqlite3.Connection,
    account_id: str,
    project_slug: str,
    *,
    saved: bool,
) -> bool:
    """Set a server-known project's saved state idempotently.

    A target state is used instead of a toggle so a retried POST cannot undo
    the user's first successful request.  The public app supplies the account
    from the authenticated session and this function rejects project names
    outside the frozen local inventory.
    """

    if project_slug != PROJECT_SLUG:
        raise ValueError("unknown local project")
    if saved:
        connection.execute(
            "INSERT OR IGNORE INTO ioby_favorites("
            "account_id,project_slug,created_at) VALUES (?,?,?)",
            (account_id, project_slug, now()),
        )
    else:
        connection.execute(
            "DELETE FROM ioby_favorites WHERE account_id=? AND project_slug=?",
            (account_id, project_slug),
        )
    return saved