"""Deterministic local commerce models for the source product route families.

Provenance boundary — read before treating anything here as source evidence:

``source-current/playwright-route-inventory-20260821/all-links-probe.json``
records ``Access Denied`` for every one of the 32 ``/pd/`` and 12 ``/pl/``
source URLs, and for both ``/collections/`` and both ``/configure/blinds/``
URLs. No source layout, image, price, rating, review count or specification was
ever observed for those pages, so nothing this module produces may be presented
as source-visually accepted.

* Source-derived: the pathname text only, which the immutable route inventory
  already stores.
* Clone-authored: every price, rating, review count, option, specification and
  image, drawn from the frozen synthetic catalog seeded by
  ``backend/seed_data.py``.

Determinism: the only inputs are the URL and the frozen catalog, so the same
URL always renders the same page. No clock and no randomness anywhere.
"""

from __future__ import annotations

import re
import zlib
from typing import Any, Mapping, Sequence

from backend import store as site_store

_WORD_RE = re.compile(r"[A-Za-z0-9]+")

# URL words that carry no catalog meaning and would only add noise to a scope
# lookup.
_STOPWORDS = frozenset(
    {
        "a", "all", "an", "and", "at", "best", "by", "deal", "deals", "for",
        "from", "in", "lowes", "more", "new", "of", "on", "our", "pd", "pl",
        "shop", "the", "to", "top", "with", "your",
    }
)


# ---------------------------------------------------------------------------
# URL text helpers
# ---------------------------------------------------------------------------


def words(value: str) -> list[str]:
    """Lowercase alphanumeric words from a URL segment."""

    return [word.casefold() for word in _WORD_RE.findall(value.replace("-", " "))]


def meaningful_words(value: str) -> list[str]:
    seen: list[str] = []
    for word in words(value):
        if word in _STOPWORDS or word.isdigit() or word in seen:
            continue
        seen.append(word)
    return seen


def humanize(segment: str) -> str:
    """Readable heading text from one URL segment.

    Words that are already upper case or that carry a digit keep their captured
    spelling, so ``Frigidaire-30-in-Electric-Range`` reads as
    ``Frigidaire 30 in Electric Range`` rather than being re-cased.
    """

    text = re.sub(r"\s+", " ", segment.replace("-", " ").replace("_", " ")).strip()
    if not text:
        return ""
    parts = []
    for word in text.split(" "):
        if word.isupper() or any(character.isdigit() for character in word):
            parts.append(word)
        else:
            parts.append(word[:1].upper() + word[1:])
    return " ".join(parts)


def stable_index(value: str, span: int) -> int:
    """Deterministic index in ``0..span-1`` derived from a URL fragment.

    Numeric source ids drive the index directly so neighbouring item ids do not
    collapse onto one catalog row; anything else falls back to CRC32, which —
    unlike ``hash()`` — is stable across processes.
    """

    if span <= 0:
        return 0
    digits = "".join(character for character in value if character.isdigit())
    if digits:
        return int(digits[-12:]) % span
    return zlib.crc32(value.encode("utf-8")) % span


# ---------------------------------------------------------------------------
# catalog lookups
# ---------------------------------------------------------------------------


def category_index() -> dict[str, dict[str, Any]]:
    return {str(row["id"]): dict(row) for row in site_store.categories()}


def category_label(category_id: str) -> str:
    row = category_index().get(category_id)
    return str(row["label"]) if row else humanize(category_id)


def product_for_item(item_id: str) -> dict[str, Any]:
    """Resolve a source item id onto exactly one local catalog product.

    An id that happens to name a local product returns it; every other id maps
    through :func:`stable_index`, which is what keeps a source PDP URL rendering
    the same synthetic item on every run.
    """

    products = site_store.all_products()
    if item_id.isdigit():
        exact = next((row for row in products if int(row["id"]) == int(item_id)), None)
        if exact is not None:
            return exact
    return products[stable_index(item_id, len(products))]


def related_products(
    product: Mapping[str, Any], *, limit: int = 4
) -> list[dict[str, Any]]:
    """Same-category neighbours, ordered by id, wrapping around the category."""

    siblings = [
        row
        for row in site_store.all_products()
        if row["category_id"] == product["category_id"] and row["id"] != product["id"]
    ]
    if len(siblings) <= limit:
        return siblings
    start = stable_index(str(product["id"]), len(siblings))
    doubled = siblings + siblings
    return doubled[start : start + limit]


# ---------------------------------------------------------------------------
# /pd/{source-slug}/{item-id}
# ---------------------------------------------------------------------------


def product_detail(slug: str, item_id: str) -> dict[str, Any]:
    product = product_for_item(item_id)
    display_title = humanize(slug) or str(product["title"])
    return {
        "source_slug": slug,
        "source_item_id": item_id,
        "display_title": display_title,
        "product": product,
        "category_label": category_label(str(product["category_id"])),
        "related": related_products(product),
        "exact_local_item": item_id.isdigit() and int(item_id) == int(product["id"]),
    }


# ---------------------------------------------------------------------------
# /pl/{title}/{collection-id} (and the deeper refinement form)
# ---------------------------------------------------------------------------


def list_scope(segments: Sequence[str], collection_id: str) -> dict[str, Any]:
    """Pick the catalog slice a source collection URL maps onto.

    Order of preference: a category whose label shares a word with the URL, then
    a single URL word the catalog can actually search on, then a category chosen
    by :func:`stable_index`. Every branch is a pure function of the URL, so the
    same collection id always lands on the same slice.
    """

    url_words = []
    for segment in segments:
        url_words.extend(meaningful_words(segment))

    categories = site_store.categories()
    for row in categories:
        label_words = set(words(str(row["label"])))
        if label_words & set(url_words):
            return {
                "category_id": str(row["id"]),
                "label": str(row["label"]),
                "query": "",
                "basis": "category-word-match",
            }

    for word in sorted(set(url_words), key=len, reverse=True):
        if len(word) < 4:
            continue
        probe = site_store.search(query=word, page_size=1)
        if int(probe["total"]) >= 3:
            return {
                "category_id": "",
                "label": humanize(word),
                "query": word,
                "basis": "catalog-keyword-match",
            }

    row = categories[stable_index(collection_id, len(categories))]
    return {
        "category_id": str(row["id"]),
        "label": str(row["label"]),
        "query": "",
        "basis": "collection-id-mapping",
    }


def list_page(
    segments: Sequence[str],
    collection_id: str,
    *,
    brands: Sequence[str] = (),
    min_price: str = "",
    max_price: str = "",
    rating: str = "",
    pickup: bool = False,
    free_delivery: bool = False,
    sort: str = "relevance",
    page: int = 1,
) -> dict[str, Any]:
    """Run one product-list request against the local catalog."""

    scope = list_scope(segments, collection_id)
    result = site_store.search(
        query=scope["query"],
        category_ids=[scope["category_id"]] if scope["category_id"] else (),
        brand_names=[name for name in brands if name],
        min_price_cents=_cents(min_price),
        max_price_cents=_cents(max_price),
        min_rating=_number(rating),
        pickup_today=pickup,
        free_delivery=free_delivery,
        sort=sort,
        page=page,
    )
    trail = [humanize(segment) for segment in segments if segment]
    return {
        "scope": scope,
        "result": result,
        "trail": trail,
        "heading": trail[0] if trail else scope["label"],
        "refinements": trail[1:],
        "collection_id": collection_id,
    }


def _cents(value: str) -> int | None:
    text = str(value).strip()
    if not text:
        return None
    try:
        return max(0, int(round(float(text) * 100)))
    except ValueError:
        return None


def _number(value: str) -> float | None:
    text = str(value).strip()
    if not text:
        return None
    try:
        return float(text)
    except ValueError:
        return None


# ---------------------------------------------------------------------------
# /collections/{source-slug}/{collection-id}
# ---------------------------------------------------------------------------

PACKAGE_ROLES = (
    "Refrigeration",
    "Cooking",
    "Cleanup",
    "Laundry",
)

# Suite discount in basis points, applied to the sum of the member prices. A
# fixed local rule, not an observed Lowe's promotion.
PACKAGE_DISCOUNT_BASIS_POINTS = 1200


def collection_package(slug: str, collection_id: str) -> dict[str, Any]:
    """A four-piece appliance suite assembled from the local catalog."""

    appliances = [
        row for row in site_store.all_products() if row["category_id"] == "appliances"
    ]
    if not appliances:
        appliances = site_store.all_products()
    start = stable_index(collection_id, len(appliances))
    doubled = appliances + appliances
    members = doubled[start : start + len(PACKAGE_ROLES)]

    list_total = sum(int(row["price_cents"]) for row in members)
    discount = (list_total * PACKAGE_DISCOUNT_BASIS_POINTS) // 10000
    return {
        "source_slug": slug,
        "collection_id": collection_id,
        "display_title": humanize(slug),
        "members": list(zip(PACKAGE_ROLES, members)),
        "product_ids": [int(row["id"]) for row in members],
        "list_total_cents": list_total,
        "discount_cents": discount,
        "package_total_cents": list_total - discount,
    }


# ---------------------------------------------------------------------------
# /configure/blinds/{source-slug}/{item-id}
# ---------------------------------------------------------------------------

BLIND_WIDTHS: tuple[int, ...] = tuple(range(18, 73, 2))
BLIND_HEIGHTS: tuple[int, ...] = tuple(range(24, 85, 6))
BLIND_MOUNTS: tuple[tuple[str, str], ...] = (
    ("inside", "Inside mount"),
    ("outside", "Outside mount"),
)
# (id, label, surcharge in cents)
BLIND_CONTROLS: tuple[tuple[str, str, int], ...] = (
    ("cordless", "Cordless lift", 0),
    ("cord-loop", "Continuous cord loop", 1500),
    ("motorized", "Motorized lift", 12900),
)
BLIND_COLORS: tuple[tuple[str, str], ...] = (
    ("smooth-white", "Smooth White"),
    ("antique-white", "Antique White"),
    ("driftwood", "Driftwood"),
    ("espresso", "Espresso"),
)
BLIND_ROOMS: tuple[tuple[str, str], ...] = (
    ("room-darkening", "Room darkening"),
    ("light-filtering", "Light filtering"),
    ("blackout", "Blackout"),
)

# Local pricing rule: the catalog price covers the first five square feet and
# every additional square foot adds this much. Clone-authored, not observed.
BLIND_INCLUDED_SQFT = 5
BLIND_SQFT_CENTS = 320


def blind_defaults(slug: str, item_id: str) -> dict[str, str]:
    """Deterministic starting configuration derived from the source URL."""

    return {
        "width": str(BLIND_WIDTHS[stable_index(item_id, len(BLIND_WIDTHS))]),
        "height": str(BLIND_HEIGHTS[stable_index(item_id + "h", len(BLIND_HEIGHTS))]),
        "mount": BLIND_MOUNTS[stable_index(slug, len(BLIND_MOUNTS))][0],
        "control": _default_control(slug),
        "color": _default_color(slug),
        "opacity": BLIND_ROOMS[stable_index(slug + "o", len(BLIND_ROOMS))][0],
    }


def _default_control(slug: str) -> str:
    lowered = slug.casefold()
    for control_id, _label, _extra in BLIND_CONTROLS:
        if control_id.replace("-", "") in lowered.replace("-", ""):
            return control_id
    return BLIND_CONTROLS[stable_index(slug + "c", len(BLIND_CONTROLS))][0]


def _default_color(slug: str) -> str:
    lowered = slug.casefold()
    for color_id, label in BLIND_COLORS:
        if all(word in lowered for word in words(label)):
            return color_id
    return BLIND_COLORS[stable_index(slug + "k", len(BLIND_COLORS))][0]


def _choice(options: Sequence[tuple[str, ...]], value: str, fallback: str) -> str:
    identifiers = [str(option[0]) for option in options]
    return value if value in identifiers else fallback


def blind_configuration(
    slug: str, item_id: str, selection: Mapping[str, str]
) -> dict[str, Any]:
    """Server-side quote for one blind configuration.

    Every field is validated against the frozen option lists, so a hand-edited
    query string cannot push an unpriced value into the quote.
    """

    product = product_for_item(item_id)
    defaults = blind_defaults(slug, item_id)

    width = _snap(selection.get("width", defaults["width"]), BLIND_WIDTHS, defaults["width"])
    height = _snap(
        selection.get("height", defaults["height"]), BLIND_HEIGHTS, defaults["height"]
    )
    mount = _choice(BLIND_MOUNTS, selection.get("mount", ""), defaults["mount"])
    control = _choice(BLIND_CONTROLS, selection.get("control", ""), defaults["control"])
    color = _choice(BLIND_COLORS, selection.get("color", ""), defaults["color"])
    opacity = _choice(BLIND_ROOMS, selection.get("opacity", ""), defaults["opacity"])

    square_feet = (width * height) / 144
    oversize = max(0.0, square_feet - BLIND_INCLUDED_SQFT)
    size_cents = int(oversize * BLIND_SQFT_CENTS + 0.5)
    control_cents = next(
        extra for control_id, _label, extra in BLIND_CONTROLS if control_id == control
    )
    base_cents = int(product["price_cents"])
    return {
        "source_slug": slug,
        "source_item_id": item_id,
        "display_title": humanize(slug),
        "product": product,
        "width": width,
        "height": height,
        "mount": mount,
        "control": control,
        "color": color,
        "opacity": opacity,
        "square_feet": round(square_feet, 2),
        "base_cents": base_cents,
        "size_cents": size_cents,
        "control_cents": control_cents,
        "unit_cents": base_cents + size_cents + control_cents,
        "labels": {
            "mount": dict(BLIND_MOUNTS)[mount],
            "control": {
                control_id: label for control_id, label, _extra in BLIND_CONTROLS
            }[control],
            "color": dict(BLIND_COLORS)[color],
            "opacity": dict(BLIND_ROOMS)[opacity],
        },
    }


def _snap(value: str, options: Sequence[int], fallback: str) -> int:
    try:
        number = int(float(str(value)))
    except (TypeError, ValueError):
        return int(fallback)
    return number if number in options else int(fallback)