"""Session-owned state and validation for secondary Amazon clone surfaces.

These flows model local drafts and previews only. They never create a seller
account, public registry, gift-card balance, payment, or video entitlement.
"""

from __future__ import annotations

import hashlib
import hmac
import re
import secrets
import unicodedata
from datetime import date
from decimal import Decimal, InvalidOperation
from typing import Any


GIFT_CARDS_PATH = "/gift-cards/b/"
GIFT_CARD_PREVIEW_PATH = "/gift-cards/purchase-preview"
GIFT_CARD_BALANCE_PATH = "/gc/balance/"
GIFT_CARD_REDEEM_PATH = "/gc/redeem/"
SELL_PATH = "/b/"
SELL_DRAFT_PATH = "/b/sell/draft"
REGISTRY_PATH = "/gp/browse.html"
REGISTRY_SEARCH_PATH = "/registry/search"
REGISTRY_CREATE_PATH = "/registry/create"
REGISTRY_DETAIL_PATH = "/registry/detail"
PRIME_VIDEO_PATH = "/Amazon-Video/b/"

GIFT_DESIGNS = {
    "classic": "Classic smile",
    "birthday": "Birthday confetti",
    "thanks": "A little thanks",
}
GIFT_AMOUNTS_MINOR = (2500, 5000, 10000, 20000)
SELL_CATEGORIES = {
    "books": "Books",
    "electronics": "Electronics",
    "home": "Home & Kitchen",
    "toys": "Toys & Games",
    "beauty": "Beauty & Personal Care",
}
SELL_CONDITIONS = {
    "new": "New",
    "like-new": "Used - Like New",
    "good": "Used - Good",
}
REGISTRY_TYPES = {
    "wedding": "Wedding Registry",
    "baby": "Baby Registry",
    "gift": "Gift List",
}
_REDEMPTION_PEPPER = secrets.token_bytes(32)
_SAFE_CODE = re.compile(r"[A-Z0-9][A-Z0-9-]{7,31}")
_PRICE = re.compile(r"(?:[1-9][0-9]{0,3}|5000)(?:\.[0-9]{2})?")


class SpecialtyValidationError(ValueError):
    """A public specialty form did not satisfy its strict contract."""


def ensure_specialty_schema(store: Any) -> None:
    """Install isolated additive tables without changing the core schema."""

    with store.connect() as connection:
        connection.executescript(
            """
            CREATE TABLE IF NOT EXISTS specialty_gift_card_previews (
                preview_id INTEGER PRIMARY KEY AUTOINCREMENT,
                session_digest TEXT NOT NULL
                    REFERENCES browser_sessions(session_digest) ON DELETE CASCADE,
                design TEXT NOT NULL CHECK (design IN ('classic','birthday','thanks')),
                amount_minor INTEGER NOT NULL CHECK (amount_minor IN (2500,5000,10000,20000)),
                recipient_kind TEXT NOT NULL CHECK (recipient_kind IN ('self','gift')),
                status TEXT NOT NULL CHECK (status='LOCAL_PREVIEW'),
                created_at TEXT NOT NULL
            );
            CREATE INDEX IF NOT EXISTS specialty_gift_preview_session_idx
                ON specialty_gift_card_previews(session_digest,preview_id DESC);
            CREATE TABLE IF NOT EXISTS specialty_gift_redemption_attempts (
                redemption_id INTEGER PRIMARY KEY AUTOINCREMENT,
                session_digest TEXT NOT NULL
                    REFERENCES browser_sessions(session_digest) ON DELETE CASCADE,
                code_fingerprint TEXT NOT NULL CHECK (length(code_fingerprint)=64),
                status TEXT NOT NULL CHECK (status='NOT_APPLIED'),
                created_at TEXT NOT NULL
            );
            CREATE INDEX IF NOT EXISTS specialty_gift_redemption_session_idx
                ON specialty_gift_redemption_attempts(session_digest,redemption_id DESC);
            CREATE TABLE IF NOT EXISTS specialty_seller_drafts (
                draft_id INTEGER PRIMARY KEY AUTOINCREMENT,
                session_digest TEXT NOT NULL
                    REFERENCES browser_sessions(session_digest) ON DELETE CASCADE,
                title TEXT NOT NULL CHECK (length(title) BETWEEN 5 AND 100),
                category TEXT NOT NULL CHECK (category IN ('books','electronics','home','toys','beauty')),
                item_condition TEXT NOT NULL CHECK (item_condition IN ('new','like-new','good')),
                price_minor INTEGER NOT NULL CHECK (price_minor BETWEEN 100 AND 500000),
                quantity INTEGER NOT NULL CHECK (quantity BETWEEN 1 AND 30),
                description TEXT NOT NULL CHECK (length(description)<=500),
                status TEXT NOT NULL CHECK (status='LOCAL_DRAFT'),
                created_at TEXT NOT NULL,
                updated_at TEXT NOT NULL
            );
            CREATE INDEX IF NOT EXISTS specialty_seller_draft_session_idx
                ON specialty_seller_drafts(session_digest,draft_id DESC);
            CREATE TABLE IF NOT EXISTS specialty_registries (
                registry_id INTEGER PRIMARY KEY AUTOINCREMENT,
                session_digest TEXT NOT NULL
                    REFERENCES browser_sessions(session_digest) ON DELETE CASCADE,
                registry_type TEXT NOT NULL CHECK (registry_type IN ('wedding','baby','gift')),
                owner_name TEXT NOT NULL CHECK (length(owner_name) BETWEEN 2 AND 80),
                registry_name TEXT NOT NULL CHECK (length(registry_name) BETWEEN 3 AND 100),
                event_date TEXT NOT NULL CHECK (length(event_date) IN (0,10)),
                status TEXT NOT NULL CHECK (status='LOCAL_PRIVATE_DRAFT'),
                created_at TEXT NOT NULL
            );
            CREATE INDEX IF NOT EXISTS specialty_registry_session_idx
                ON specialty_registries(session_digest,registry_id DESC);
            """
        )


def _plain_text(value: str, *, field: str, minimum: int, maximum: int) -> str:
    if not isinstance(value, str):
        raise SpecialtyValidationError(f"{field} must be text")
    normalized = " ".join(unicodedata.normalize("NFKC", value).split())
    if not minimum <= len(normalized) <= maximum or any(
        ord(character) < 32 or ord(character) == 127 for character in normalized
    ):
        raise SpecialtyValidationError(f"{field} is invalid")
    return normalized


def _optional_text(value: str, *, field: str, maximum: int) -> str:
    if not isinstance(value, str):
        raise SpecialtyValidationError(f"{field} must be text")
    normalized = " ".join(unicodedata.normalize("NFKC", value).split())
    if len(normalized) > maximum or any(
        ord(character) < 32 or ord(character) == 127 for character in normalized
    ):
        raise SpecialtyValidationError(f"{field} is invalid")
    return normalized


def _positive_id(value: int | str) -> int | None:
    if isinstance(value, bool):
        return None
    raw = str(value)
    if re.fullmatch(r"[1-9][0-9]{0,18}", raw) is None:
        return None
    parsed = int(raw)
    return parsed if parsed <= (1 << 63) - 1 else None


def create_gift_card_preview(
    store: Any, session_digest: str, design: str, amount: str, recipient_kind: str
) -> dict[str, Any]:
    if design not in GIFT_DESIGNS or recipient_kind not in {"self", "gift"}:
        raise SpecialtyValidationError("gift card selection is invalid")
    if re.fullmatch(r"(?:25|50|100|200)", amount or "") is None:
        raise SpecialtyValidationError("gift card amount is invalid")
    ensure_specialty_schema(store)
    store.ensure_session(session_digest)
    with store.connect() as connection:
        cursor = connection.execute(
            """
            INSERT INTO specialty_gift_card_previews(
                session_digest,design,amount_minor,recipient_kind,status,created_at
            ) VALUES (?,?,?,?,'LOCAL_PREVIEW',?)
            """,
            (
                session_digest,
                design,
                int(amount) * 100,
                recipient_kind,
                store.now(connection),
            ),
        )
        preview_id = int(cursor.lastrowid)
        connection.commit()
    return gift_card_preview(store, session_digest, preview_id) or {}


def gift_card_preview(
    store: Any, session_digest: str, preview_id: int | str
) -> dict[str, Any] | None:
    normalized = _positive_id(preview_id)
    if normalized is None:
        return None
    ensure_specialty_schema(store)
    store.ensure_session(session_digest)
    with store.connect() as connection:
        row = connection.execute(
            """
            SELECT preview_id,design,amount_minor,recipient_kind,status,created_at
            FROM specialty_gift_card_previews
            WHERE preview_id=? AND session_digest=?
            """,
            (normalized, session_digest),
        ).fetchone()
    return dict(row) if row else None


def redeem_gift_card(store: Any, session_digest: str, claim_code: str) -> dict[str, Any]:
    normalized = unicodedata.normalize("NFKC", claim_code).strip().upper()
    if _SAFE_CODE.fullmatch(normalized) is None:
        raise SpecialtyValidationError(
            "claim code must use 8 to 32 letters, numbers, or hyphens"
        )
    fingerprint = hmac.new(
        _REDEMPTION_PEPPER, normalized.encode("utf-8"), hashlib.sha256
    ).hexdigest()
    ensure_specialty_schema(store)
    store.ensure_session(session_digest)
    with store.connect() as connection:
        cursor = connection.execute(
            """
            INSERT INTO specialty_gift_redemption_attempts(
                session_digest,code_fingerprint,status,created_at
            ) VALUES (?,?,'NOT_APPLIED',?)
            """,
            (session_digest, fingerprint, store.now(connection)),
        )
        redemption_id = int(cursor.lastrowid)
        connection.commit()
    return {"redemption_id": redemption_id, "status": "NOT_APPLIED"}


def gift_card_balance(store: Any, session_digest: str) -> dict[str, int]:
    ensure_specialty_schema(store)
    store.ensure_session(session_digest)
    with store.connect() as connection:
        attempts = int(
            connection.execute(
                "SELECT COUNT(*) FROM specialty_gift_redemption_attempts WHERE session_digest=?",
                (session_digest,),
            ).fetchone()[0]
        )
    return {"balance_minor": 0, "redemption_attempts": attempts}


def save_seller_draft(
    store: Any, session_digest: str, fields: dict[str, str]
) -> dict[str, Any]:
    title = _plain_text(
        fields.get("title", ""), field="title", minimum=5, maximum=100
    )
    category = fields.get("category", "")
    condition = fields.get("condition", "")
    if category not in SELL_CATEGORIES or condition not in SELL_CONDITIONS:
        raise SpecialtyValidationError("listing category or condition is invalid")
    raw_price = fields.get("price", "")
    if _PRICE.fullmatch(raw_price) is None:
        raise SpecialtyValidationError("price must be between $1.00 and $5,000.00")
    try:
        price_minor = int(Decimal(raw_price) * 100)
    except (InvalidOperation, ValueError):
        raise SpecialtyValidationError("price is invalid") from None
    if not 100 <= price_minor <= 500_000:
        raise SpecialtyValidationError("price must be between $1.00 and $5,000.00")
    raw_quantity = fields.get("quantity", "")
    if re.fullmatch(r"(?:[1-9]|[12][0-9]|30)", raw_quantity) is None:
        raise SpecialtyValidationError("quantity must be 1 through 30")
    description = _optional_text(
        fields.get("description", ""), field="description", maximum=500
    )
    ensure_specialty_schema(store)
    store.ensure_session(session_digest)
    with store.connect() as connection:
        now = store.now(connection)
        cursor = connection.execute(
            """
            INSERT INTO specialty_seller_drafts(
                session_digest,title,category,item_condition,price_minor,quantity,
                description,status,created_at,updated_at
            ) VALUES (?,?,?,?,?,?,?,'LOCAL_DRAFT',?,?)
            """,
            (
                session_digest,
                title,
                category,
                condition,
                price_minor,
                int(raw_quantity),
                description,
                now,
                now,
            ),
        )
        draft_id = int(cursor.lastrowid)
        connection.commit()
    return seller_draft(store, session_digest, draft_id) or {}


def seller_draft(
    store: Any, session_digest: str, draft_id: int | str
) -> dict[str, Any] | None:
    normalized = _positive_id(draft_id)
    if normalized is None:
        return None
    ensure_specialty_schema(store)
    store.ensure_session(session_digest)
    with store.connect() as connection:
        row = connection.execute(
            """
            SELECT draft_id,title,category,item_condition,price_minor,quantity,
                   description,status,created_at,updated_at
            FROM specialty_seller_drafts
            WHERE draft_id=? AND session_digest=?
            """,
            (normalized, session_digest),
        ).fetchone()
    return dict(row) if row else None


def seller_drafts(store: Any, session_digest: str) -> list[dict[str, Any]]:
    ensure_specialty_schema(store)
    store.ensure_session(session_digest)
    with store.connect() as connection:
        rows = connection.execute(
            """
            SELECT draft_id,title,category,item_condition,price_minor,quantity,
                   description,status,created_at,updated_at
            FROM specialty_seller_drafts WHERE session_digest=?
            ORDER BY draft_id DESC LIMIT 12
            """,
            (session_digest,),
        ).fetchall()
    return [dict(row) for row in rows]


def _validated_event_date(value: str) -> str:
    raw = value.strip()
    if not raw:
        return ""
    if re.fullmatch(r"[0-9]{4}-[0-9]{2}-[0-9]{2}", raw) is None:
        raise SpecialtyValidationError("event date is invalid")
    try:
        parsed = date.fromisoformat(raw)
    except ValueError:
        raise SpecialtyValidationError("event date is invalid") from None
    if not 2000 <= parsed.year <= 2100:
        raise SpecialtyValidationError("event date is invalid")
    return raw


def create_registry(
    store: Any, session_digest: str, fields: dict[str, str]
) -> dict[str, Any]:
    registry_type = fields.get("registryType", "")
    if registry_type not in REGISTRY_TYPES:
        raise SpecialtyValidationError("registry type is invalid")
    owner_name = _plain_text(
        fields.get("ownerName", ""), field="owner name", minimum=2, maximum=80
    )
    registry_name = _plain_text(
        fields.get("registryName", ""),
        field="registry name",
        minimum=3,
        maximum=100,
    )
    event_date = _validated_event_date(fields.get("eventDate", ""))
    ensure_specialty_schema(store)
    store.ensure_session(session_digest)
    with store.connect() as connection:
        cursor = connection.execute(
            """
            INSERT INTO specialty_registries(
                session_digest,registry_type,owner_name,registry_name,event_date,
                status,created_at
            ) VALUES (?,?,?,?,?,'LOCAL_PRIVATE_DRAFT',?)
            """,
            (
                session_digest,
                registry_type,
                owner_name,
                registry_name,
                event_date,
                store.now(connection),
            ),
        )
        registry_id = int(cursor.lastrowid)
        connection.commit()
    return registry(store, session_digest, registry_id) or {}


def registry(
    store: Any, session_digest: str, registry_id: int | str
) -> dict[str, Any] | None:
    normalized = _positive_id(registry_id)
    if normalized is None:
        return None
    ensure_specialty_schema(store)
    store.ensure_session(session_digest)
    with store.connect() as connection:
        row = connection.execute(
            """
            SELECT registry_id,registry_type,owner_name,registry_name,event_date,
                   status,created_at
            FROM specialty_registries
            WHERE registry_id=? AND session_digest=?
            """,
            (normalized, session_digest),
        ).fetchone()
    return dict(row) if row else None


def registries(store: Any, session_digest: str) -> list[dict[str, Any]]:
    ensure_specialty_schema(store)
    store.ensure_session(session_digest)
    with store.connect() as connection:
        rows = connection.execute(
            """
            SELECT registry_id,registry_type,owner_name,registry_name,event_date,
                   status,created_at
            FROM specialty_registries WHERE session_digest=?
            ORDER BY registry_id DESC LIMIT 12
            """,
            (session_digest,),
        ).fetchall()
    return [dict(row) for row in rows]


_DEMO_REGISTRIES = (
    {
        "demo_id": "demo-welcome",
        "registry_type": "gift",
        "owner_name": "Amazon Clone Demo",
        "registry_name": "Welcome Home Picks",
        "event_date": "",
        "status": "LOCAL_DEMO",
    },
    {
        "demo_id": "demo-reading",
        "registry_type": "gift",
        "owner_name": "Amazon Clone Demo",
        "registry_name": "A Reader's Shelf",
        "event_date": "",
        "status": "LOCAL_DEMO",
    },
)


def search_registries(
    store: Any, session_digest: str, query: str
) -> tuple[str, list[dict[str, Any]]]:
    normalized = _plain_text(
        query, field="registry search", minimum=2, maximum=60
    )
    needle = normalized.casefold()
    own = [
        {**item, "is_own": True}
        for item in registries(store, session_digest)
        if needle in f"{item['owner_name']} {item['registry_name']}".casefold()
    ]
    demos = [
        {**item, "is_own": False}
        for item in _DEMO_REGISTRIES
        if needle in f"{item['owner_name']} {item['registry_name']}".casefold()
    ]
    return normalized, own + demos