"""Read-only catalogue view over the frozen, source-derived product data.

Every image path resolves to a byte-exact local file under static/assets/img;
the clone makes no runtime remote request.
"""
from __future__ import annotations

import json
import pathlib
import re
from functools import lru_cache

BASE = pathlib.Path(__file__).resolve().parent
DATA = BASE / "data"
IMG_DIR = BASE / "static/assets/img"
PAGE_DIR = BASE / "static/assets/page"

CARD, HERO, GALLERY, SWATCH = "400x", "1000x", "600x", "150x"
# Storefront-wide promotion observed on the source (15% off, sitewide banner code).
SITEWIDE_DISCOUNT = 0.15
FREE_SHIPPING_THRESHOLD = 100.0


def local_name(src: str, size: str) -> str:
    base = src.partition("?")[0].rsplit("/", 1)[-1]
    stem, _, ext = base.rpartition(".")
    stem = re.sub(r"[^A-Za-z0-9_.-]", "-", stem)[:90]
    return f"{stem}__{size}.{ext}"


def img_url(src: str | None, size: str) -> str | None:
    if not src:
        return None
    name = local_name(src, size)
    return f"/static/assets/img/{name}" if (IMG_DIR / name).exists() else None


def page_url(src: str | None) -> str | None:
    if not src:
        return None
    name = re.sub(r"[^A-Za-z0-9_.-]", "-", src.partition("?")[0].rsplit("/", 1)[-1])[:110]
    return f"/static/assets/page/{name}" if (PAGE_DIR / name).exists() else None


COLOR_FAMILIES = ["White", "Cream", "Beige", "Grey", "Blue", "Brown", "Green",
                  "Multi", "Orange", "Pink", "Red", "Yellow"]
SIZE_ORDER = ["Twin", "Twin XL", "Full", "Queen", "King", "Cali King", "Standard", "Euro"]
FABRICS = ["Brushed Flannel", "Classic Percale", "Heathered Cashmere", "Luxe Sateen",
           "Plush", "Ribbed Cotton TENCEL\u2122", "Super-Plush", "Waffle",
           "Washed Classic Percale", "Washed European Linen"]
PATTERNS = {"Stripes": ("stripe", "striped"), "Florals": ("floral", "bloom", "dandelion", "botanical"),
            "Abstract": ("abstract", "patchwork", "tandem", "weave", "checker", "plaid", "gingham")}
BUNDLE_TYPES = {"Bedding Move-In Bundles": ("move-in",), "Comforter & Duvet Bundles": ("comforter",),
                "Core Sheet Sets": ("core sheet",), "Duvet & Quilt Sets": ("duvet set", "quilt set"),
                "Hardcore Sheet Bundles": ("hardcore",), "No Flat Sheet Set Bundles": ("no flat",),
                "Starter Bundles": ("starter",)}
COMFORTER_TYPES = {"Down": ("down",), "Lightweight": ("lightweight",), "All-Season": ("all-season", "all season")}
BEDDING_LAYERS = {"Essentials": ("essential",), "Base Layer": ("sheet", "pillowcase"),
                  "Top Layer": ("duvet", "comforter", "quilt", "blanket")}


def _hex_family(hex_value: str | None, name: str) -> str | None:
    """Classify a swatch into the source's twelve colour families."""
    lowered = name.lower()
    if any(w in lowered for w in ("stripe", "patchwork", "multi", "plaid", "gingham", "floral", "check")):
        return "Multi"
    if not hex_value or not hex_value.startswith("#") or len(hex_value) != 7:
        for family in COLOR_FAMILIES:
            if family.lower() in lowered:
                return family
        return None
    r, g, b = (int(hex_value[i:i + 2], 16) for i in (1, 3, 5))
    mx, mn = max(r, g, b), min(r, g, b)
    chroma, light = mx - mn, mx / 255
    if chroma < 26:
        if light > 0.93:
            return "White"
        if light > 0.82:
            return "Cream"
        return "Grey"
    import colorsys
    hue = colorsys.rgb_to_hsv(r / 255, g / 255, b / 255)[0] * 360
    if hue < 16 or hue >= 340:
        return "Red" if light > 0.45 and chroma > 70 else "Brown"
    if hue < 42:
        return "Brown" if light < 0.62 else ("Beige" if chroma < 70 else "Orange")
    if hue < 68:
        return "Yellow"
    if hue < 165:
        return "Green"
    if hue < 260:
        return "Blue"
    if hue < 290:
        return "Blue"
    return "Pink"


def _facets_for(product: dict, swatches: dict) -> dict[str, list[str]]:
    title = product["title"].lower()
    tags = {t.lower() for t in product["tags"]}
    colors, sizes, patterns = [], [], []
    for v in product["variants"]:
        name = v.get("option1") or ""
        meta = swatches.get(name, {})
        family = _hex_family(meta.get("hex"), name)
        if family and family not in colors:
            colors.append(family)
        size = v.get("option2")
        if size and size not in sizes:
            sizes.append(size)
        lowered = name.lower()
        for label, needles in PATTERNS.items():
            if any(n in lowered for n in needles) and label not in patterns:
                patterns.append(label)
    if not patterns:
        patterns = ["Solid"]
    fabric = [f for f in FABRICS if f.lower() in title or f.lower() in tags]
    featured = []
    if "bundle" in title or "bundle savings" in tags:
        featured.append("Bundle Savings")
    if any("cooling" in t for t in tags) or "percale" in title:
        featured.append("Cooling")
    if any("hsa" in t for t in tags):
        featured.append("HSA/FSA Eligible")
    bundle = [k for k, needles in BUNDLE_TYPES.items() if any(n in title for n in needles)]
    comforter = [k for k, needles in COMFORTER_TYPES.items()
                 if any(n in title for n in needles)] if "comforter" in title else []
    layers = [k for k, needles in BEDDING_LAYERS.items() if any(n in title for n in needles)]
    return {"product_type": [product["product_type"]] if product["product_type"] else [],
            "color": colors, "size": [s for s in SIZE_ORDER if s in sizes] or sizes,
            "fabric": fabric, "featured": featured, "pattern": patterns,
            "bundle_type": bundle, "comforter_type": comforter, "bedding_layers": layers}


FACET_GROUPS = [("product_type", "Product Type"), ("color", "Color"), ("size", "Size"),
                ("fabric", "Fabric"), ("featured", "Featured"), ("bedding_layers", "Bedding Layers"),
                ("bundle_type", "Bundle Type"), ("pattern", "Pattern"),
                ("comforter_type", "Comforter Type")]
FACET_ORDER = {"color": COLOR_FAMILIES, "size": SIZE_ORDER, "fabric": FABRICS}


def _stable_reviews(handle: str) -> int:
    """Deterministic per-product review count; no source review data is copied."""
    return 40 + (sum(handle.encode()) * 37) % 4000


@lru_cache(maxsize=1)
def swatch_table() -> dict:
    """Site-wide colour table (hex, pattern image, copy) as published by the source."""
    path = DATA / "swatches.json"
    return json.loads(path.read_text(encoding="utf-8")) if path.exists() else {}


@lru_cache(maxsize=1)
def catalog() -> dict:
    raw = json.loads((DATA / "catalog.json").read_text(encoding="utf-8"))
    p0 = set(json.loads((DATA / "p0-products.json").read_text(encoding="utf-8")))
    for handle, p in raw["products"].items():
        p["detail_closed"] = handle in p0
        p["card_image"] = img_url(p["images"][0] if p["images"] else None, CARD)
        p["review_count"] = _stable_reviews(handle)
        p["sale_price"] = round(p["price_min"] * (1 - SITEWIDE_DISCOUNT), 2)
        p["on_sale"] = True
        p["discount_pct"] = int(SITEWIDE_DISCOUNT * 100)
        p["badge"] = _badge(p)
        seen, swatches = set(), []
        for v in p["variants"]:
            key = v.get("option1")
            if key in seen:
                continue
            seen.add(key)
            meta = swatch_table().get(key or "", {})
            swatches.append({"title": key, "hex": meta.get("hex"),
                             "description": meta.get("description"),
                             "image": img_url(v.get("image"), SWATCH)})
        p["swatches"] = swatches
        p["facets"] = _facets_for(p, swatch_table())
    raw["by_handle"] = raw["products"]
    return raw


def _badge(p: dict) -> str | None:
    tags = {t.lower() for t in p["tags"]}
    if "super-plush towels" in tags or "super-plush 2.0" in tags:
        return "FLUFFIEST"
    if any("cooling" in t for t in tags):
        return "COOLING"
    if "newarrivals" in tags:
        return "NEW"
    if "best sellers" in tags:
        return "BEST SELLER"
    return None


def products_for(handles) -> list[dict]:
    by = catalog()["products"]
    return [by[h] for h in handles if h in by]


def collection(handle: str) -> dict | None:
    for c in catalog()["collections"]:
        if c["handle"] == handle:
            return c
    return None


def variant_index() -> dict[int, tuple[str, dict]]:
    idx = {}
    for handle, p in catalog()["products"].items():
        for v in p["variants"]:
            idx[v["id"]] = (handle, v)
    return idx