from __future__ import annotations

import json
from copy import deepcopy
from functools import lru_cache
from html import escape
from pathlib import Path
from typing import Any, Iterable, Mapping
from urllib.parse import urlencode


FIXTURE_PATH = Path(__file__).resolve().parent / "fixtures" / "review-evidence.json"
SOURCE_AGGREGATE_PROVENANCE = "source_snapshot_aggregate"
LOCAL_REVIEW_PROVENANCE = "local_user_review"
REVIEW_SORTS = frozenset({"recent", "helpful"})


@lru_cache(maxsize=1)
def _fixture() -> dict[str, Any]:
    payload = json.loads(FIXTURE_PATH.read_text(encoding="utf-8"))
    if payload.get("schema") != "amazon-clone.review-evidence.v1":
        raise ValueError("Unsupported review evidence schema")
    products = payload.get("products")
    if not isinstance(products, dict):
        raise ValueError("Review evidence products must be an object")
    return payload


def supported_review_asins() -> tuple[str, ...]:
    """Return ASINs with source-observed review aggregates."""

    return tuple(_fixture()["products"])


def get_review_evidence(asin: str) -> dict[str, Any] | None:
    """Return a caller-safe copy of an ASIN's immutable source evidence."""

    product = _fixture()["products"].get(asin.upper())
    return deepcopy(product) if product is not None else None


def _bounded_text(value: object, field: str, *, maximum: int) -> str:
    if not isinstance(value, str):
        raise ValueError(f"{field} must be text")
    result = " ".join(value.split())
    if not result:
        raise ValueError(f"{field} must not be empty")
    if len(result) > maximum:
        raise ValueError(f"{field} is too long")
    return result


def _boolean(review: Mapping[str, Any], field: str, default: bool) -> bool:
    value = review.get(field, default)
    if not isinstance(value, bool):
        raise ValueError(f"{field} must be a boolean")
    return value


def _normalize_local_review(review: Mapping[str, Any]) -> dict[str, Any]:
    if review.get("provenance") != LOCAL_REVIEW_PROVENANCE:
        raise ValueError("Local reviews must carry provenance=local_user_review")

    rating = review.get("rating")
    if isinstance(rating, bool) or not isinstance(rating, int) or not 1 <= rating <= 5:
        raise ValueError("rating must be an integer from 1 to 5")
    helpful_count = review.get("helpful_count", 0)
    if (
        isinstance(helpful_count, bool)
        or not isinstance(helpful_count, int)
        or helpful_count < 0
    ):
        raise ValueError("helpful_count must be a non-negative integer")

    created_at = review.get("created_at", "")
    updated_at = review.get("updated_at", created_at)
    if created_at and not isinstance(created_at, str):
        raise ValueError("created_at must be text")
    if updated_at and not isinstance(updated_at, str):
        raise ValueError("updated_at must be text")
    review_id = review.get("id", "")
    if review_id and not isinstance(review_id, (str, int)):
        raise ValueError("id must be text or an integer")

    verified_purchase = _boolean(review, "verified_purchase", False)
    viewer_found_helpful = _boolean(review, "viewer_found_helpful", False)
    owned_by_viewer = _boolean(review, "owned_by_viewer", False)
    can_mark_helpful = _boolean(review, "can_mark_helpful", not owned_by_viewer)
    if owned_by_viewer and can_mark_helpful:
        raise ValueError("review owners cannot mark their own review helpful")

    return {
        "id": str(review_id),
        "provenance": LOCAL_REVIEW_PROVENANCE,
        "author_display_name": _bounded_text(
            review.get("author_display_name"), "author_display_name", maximum=128
        ),
        "rating": rating,
        "title": _bounded_text(review.get("title"), "title", maximum=200),
        "body": _bounded_text(review.get("body"), "body", maximum=10000),
        "created_at": created_at.strip(),
        "updated_at": updated_at.strip(),
        "verified_purchase": verified_purchase,
        "helpful_count": helpful_count,
        "viewer_found_helpful": viewer_found_helpful,
        "owned_by_viewer": owned_by_viewer,
        "can_mark_helpful": can_mark_helpful,
    }


def normalize_local_reviews(
    reviews: Iterable[Mapping[str, Any]], *, star: int | None = None
) -> list[dict[str, Any]]:
    """Validate local rows without allowing them to masquerade as source reviews."""

    if star is not None and (isinstance(star, bool) or star not in range(1, 6)):
        raise ValueError("star filter must be 1 through 5")
    normalized = [_normalize_local_review(review) for review in reviews]
    if star is not None:
        normalized = [review for review in normalized if review["rating"] == star]
    return normalized


def build_review_view(
    asin: str,
    local_reviews: Iterable[Mapping[str, Any]] = (),
    *,
    star: int | None = None,
    product_label: str | None = None,
    source_rating_summary: Mapping[str, Any] | None = None,
) -> dict[str, Any] | None:
    """Build a UI view while keeping source aggregates and local rows separate."""

    evidence = get_review_evidence(asin)
    known_product_label = None
    if product_label is not None:
        known_product_label = _bounded_text(
            product_label, "product_label", maximum=1000
        )
    if source_rating_summary is not None and not isinstance(
        source_rating_summary, Mapping
    ):
        raise ValueError("source_rating_summary must be a mapping")
    captured_summary = (
        evidence["rating_summary"]
        if evidence is not None
        else (dict(source_rating_summary) if source_rating_summary is not None else None)
    )
    if evidence is None and known_product_label is None and captured_summary is None:
        return None
    if star is not None and (isinstance(star, bool) or star not in range(1, 6)):
        raise ValueError("star filter must be 1 through 5")

    all_local = normalize_local_reviews(local_reviews)
    filtered_local = (
        all_local
        if star is None
        else [review for review in all_local if review["rating"] == star]
    )
    rating_total = sum(review["rating"] for review in all_local)
    local_average = round(rating_total / len(all_local), 1) if all_local else None
    local_by_star = {
        value: sum(review["rating"] == value for review in all_local)
        for value in range(5, 0, -1)
    }

    return {
        "asin": asin.upper(),
        "product_label": (
            evidence["product_label"] if evidence is not None else known_product_label
        ),
        "source_aggregate_available": captured_summary is not None,
        "source_rating_summary": captured_summary,
        "source_histogram": evidence.get("histogram") if evidence is not None else None,
        "source_topics": evidence.get("source_topics", []) if evidence is not None else [],
        "source_topic_provenance": (
            evidence.get("topic_provenance") if evidence is not None else None
        ),
        "source_excerpts": evidence.get("source_excerpts", []) if evidence is not None else [],
        "individual_review_evidence": (
            evidence["individual_review_evidence"]
            if evidence is not None
            else {
                "available": False,
                "missing_fields": [
                    "aggregate_rating",
                    "aggregate_count",
                    "author",
                    "title",
                    "date",
                    "rating",
                    "helpful_count",
                ],
            }
        ),
        "local_summary": {
            "rating": local_average,
            "review_count": len(all_local),
            "provenance": LOCAL_REVIEW_PROVENANCE,
            "count_by_star": local_by_star,
        },
        "owned_review": next(
            (review for review in all_local if review["owned_by_viewer"]), None
        ),
        "local_reviews": filtered_local,
        "active_star": star,
    }


def _review_href(
    asin: str,
    *,
    star: int | None,
    sort: str,
    base_path: str,
) -> str:
    query: dict[str, str] = {}
    if star is not None:
        query["reviewStar"] = str(star)
    if sort != "recent":
        query["reviewSort"] = sort
    suffix = f"?{urlencode(query)}" if query else ""
    return f"{base_path}{suffix}#customerReviews"


def _write_panel(
    view: Mapping[str, Any], account_name: str | None, form_error: str | None
) -> str:
    asin = str(view["asin"])
    error_html = (
        f'<div class="review-form-error" role="alert">{escape(form_error)}</div>'
        if form_error
        else ""
    )
    if account_name is None:
        signin_target = f"/product-reviews/{asin}#reviewComposer"
        return (
            '<section id="reviewComposer" class="review-write-panel review-signin-panel">'
            '<h3>Review this product</h3>'
            '<p>Share your experience with other shoppers.</p>'
            '<a class="review-signin-cta" href="/ap/signin?'
            + escape(urlencode({"openid.return_to": signin_target}), quote=True)
            + '">Sign in to write a review</a></section>'
        )

    owned = view["owned_review"]
    selected_rating = int(owned["rating"]) if owned else 5
    rating_options = "".join(
        f'<option value="{value}"{" selected" if value == selected_rating else ""}>'
        f"{value} out of 5 stars</option>"
        for value in range(5, 0, -1)
    )
    existing_title = escape(owned["title"] if owned else "", quote=True)
    existing_body = escape(owned["body"] if owned else "")
    return f"""
    <section id="reviewComposer" class="review-write-panel">
      <h3>{'Edit your review' if owned else 'Write a customer review'}</h3>
      <p>Posting as <strong>{escape(account_name)}</strong>.</p>
      {error_html}
      <form class="review-write-form" method="post" action="/product-reviews/{asin}">
        <label>Overall rating<select name="rating" required>{rating_options}</select></label>
        <label>Add a headline<input name="headline" maxlength="200" required value="{existing_title}"></label>
        <label>Add a written review<textarea name="body" maxlength="10000" rows="6" required>{existing_body}</textarea></label>
        <button type="submit">{'Update review' if owned else 'Submit review'}</button>
      </form>
    </section>
    """


def _local_review_card(asin: str, review: Mapping[str, Any]) -> str:
    verified = (
        '<span class="review-verified">Verified Purchase</span>'
        if review["verified_purchase"]
        else ""
    )
    date = (
        f'<time datetime="{escape(review["created_at"], quote=True)}">'
        f'{escape(review["created_at"])}</time>'
        if review["created_at"]
        else ""
    )
    edited = (
        '<span class="review-edited">Edited</span>'
        if review["updated_at"] and review["updated_at"] != review["created_at"]
        else ""
    )
    if review["owned_by_viewer"]:
        helpful_action = (
            '<button class="review-helpful-button" type="button" disabled '
            'title="You cannot mark your own review as helpful">Your review</button>'
        )
    elif review["can_mark_helpful"]:
        pressed = "true" if review["viewer_found_helpful"] else "false"
        label = "Helpful ✓" if review["viewer_found_helpful"] else "Helpful"
        helpful_action = (
            f'<form class="review-helpful-form" method="post" action="/product-reviews/{asin}/helpful">'
            f'<input type="hidden" name="reviewId" value="{escape(review["id"], quote=True)}">'
            f'<button class="review-helpful-button" type="submit" aria-pressed="{pressed}">{label}</button>'
            "</form>"
        )
    else:
        helpful_action = ""

    return (
        '<article class="local-review-card" '
        f'data-viewer-found-helpful="{str(review["viewer_found_helpful"]).lower()}" '
        f'data-owned-by-viewer="{str(review["owned_by_viewer"]).lower()}" '
        f'data-can-mark-helpful="{str(review["can_mark_helpful"]).lower()}">'
        f'<div class="review-author">{escape(review["author_display_name"])}</div>'
        f'<div class="review-card-rating" aria-label="{review["rating"]} out of 5 stars">'
        f'{"★" * review["rating"]}{"☆" * (5 - review["rating"])}</div>'
        f'<h4>{escape(review["title"])}</h4>'
        f'<div class="review-card-meta">{verified}{date}{edited}</div>'
        f'<p>{escape(review["body"])}</p>'
        '<div class="review-card-actions">'
        f'<span class="review-helpful">{review["helpful_count"]} people found this helpful</span>'
        f"{helpful_action}</div></article>"
    )


def _source_rating_summary_html(summary: Mapping[str, Any]) -> str:
    """Render a captured aggregate without manufacturing a rating for zero reviews."""

    rating = summary.get("rating")
    rating_count = summary.get("rating_count")
    rating_count_display = summary.get("rating_count_display")
    if rating_count is None:
        if not isinstance(rating_count_display, str) or not rating_count_display.strip():
            raise ValueError(
                "source rating_count needs an exact integer or captured display copy"
            )
        display_count = rating_count_display.strip()
    elif (
        isinstance(rating_count, bool)
        or not isinstance(rating_count, int)
        or rating_count < 0
    ):
        raise ValueError("source rating_count must be a non-negative integer")
    else:
        display_count = (
            rating_count_display.strip()
            if isinstance(rating_count_display, str) and rating_count_display.strip()
            else f"{rating_count:,}"
        )

    if rating is None:
        if rating_count != 0:
            raise ValueError("a missing source rating is valid only with zero ratings")
        zero_copy = summary.get("zero_rating_copy")
        if not isinstance(zero_copy, str) or not zero_copy.strip():
            zero_copy = f"There are {rating_count:,} customer reviews"
        return (
            '<div class="review-no-source-rating">'
            f"{escape(zero_copy.strip())}</div>"
        )

    if (
        isinstance(rating, bool)
        or not isinstance(rating, (int, float))
        or not 1 <= rating <= 5
    ):
        raise ValueError("source rating must be null or a number from 1 to 5")
    count_label = summary.get("count_label")
    if not isinstance(count_label, str) or not count_label.strip():
        raise ValueError("source count_label must be non-empty text")
    display_rating = str(rating)
    return (
        f'<div class="review-average" aria-label="{display_rating} out of 5 stars">'
        '<span aria-hidden="true">★★★★★</span>'
        f"<strong>{display_rating} out of 5</strong></div>"
        f"<div>{escape(display_count)} {escape(count_label.strip())}</div>"
    )


def render_reviews_section(
    asin: str,
    local_reviews: Iterable[Mapping[str, Any]] = (),
    *,
    star: int | None = None,
    sort: str = "recent",
    account_name: str | None = None,
    base_path: str | None = None,
    form_error: str | None = None,
    product_label: str | None = None,
    source_rating_summary: Mapping[str, Any] | None = None,
) -> str:
    """Render source aggregates and separately attributed local review rows."""

    view = build_review_view(
        asin,
        local_reviews,
        star=star,
        product_label=product_label,
        source_rating_summary=source_rating_summary,
    )
    if view is None:
        return ""
    if sort not in REVIEW_SORTS:
        raise ValueError("review sort must be recent or helpful")
    review_base_path = base_path or f"/dp/{view['asin']}"
    if (
        not review_base_path.startswith("/")
        or review_base_path.startswith("//")
        or "\\" in review_base_path
    ):
        raise ValueError("review base path must be a same-origin path")

    source_aggregate_available = bool(view["source_aggregate_available"])
    summary = view["source_rating_summary"]
    source_summary_html = (
        _source_rating_summary_html(summary)
        if source_aggregate_available and isinstance(summary, Mapping)
        else ""
    )
    histogram = view["source_histogram"]
    histogram_html = ""
    if histogram:
        histogram_rows = []
        for value in range(5, 0, -1):
            percent = histogram["percent_by_star"][str(value)]
            href = _review_href(
                view["asin"],
                star=value,
                sort=sort,
                base_path=review_base_path,
            )
            histogram_rows.append(
                '<a class="review-histogram-row" '
                f'href="{escape(href, quote=True)}" data-review-star-filter="{value}">'
                f"<span>{value} star</span>"
                '<progress class="review-histogram-track" max="100" '
                f'value="{percent}" aria-label="{percent} percent"></progress>'
                f"<span>{percent}%</span></a>"
            )
        histogram_html = (
            '<div class="review-histogram">' + "".join(histogram_rows) + "</div>"
        )

    topics_html = ""
    if view["source_topics"]:
        topics = "".join(
            '<li><span class="review-topic-label">'
            f'{escape(topic["label"])}</span> '
            f'<span class="review-topic-count">{topic["mentions"]:,}</span></li>'
            for topic in view["source_topics"]
        )
        topics_html = (
            '<div class="review-topics"><h3>Customers say</h3>'
            f'<ul aria-label="Common review topics">{topics}</ul></div>'
        )

    filters: list[str] = []
    for value, label in ((None, "All stars"), (5, "5 star"), (4, "4 star"), (3, "3 star"), (2, "2 star"), (1, "1 star")):
        href = _review_href(
            view["asin"], star=value, sort=sort, base_path=review_base_path
        )
        active = ' aria-current="page"' if star == value else ""
        data_value = "all" if value is None else str(value)
        filters.append(
            f'<a href="{escape(href, quote=True)}" data-review-star-filter="{data_value}"{active}>{label}</a>'
        )

    sort_links = []
    for value, label in (("recent", "Most recent"), ("helpful", "Most helpful")):
        href = _review_href(
            view["asin"], star=star, sort=value, base_path=review_base_path
        )
        active = ' aria-current="page"' if sort == value else ""
        sort_links.append(
            f'<a href="{escape(href, quote=True)}" data-review-sort="{value}"{active}>{label}</a>'
        )

    local_cards = "".join(
        _local_review_card(view["asin"], review)
        for review in view["local_reviews"]
    )
    local_reviews_html = (
        local_cards
        if local_cards
            else '<p class="review-empty">No customer reviews match this filter yet.</p>'
    )
    local_count = view["local_summary"]["review_count"]
    write_panel = _write_panel(view, account_name, form_error)
    rating_summary_html = (
        f"""
      <div class="review-summary-layout">
        <div class="review-source-summary">
          {source_summary_html}
          {histogram_html}
        </div>
        {topics_html}
      </div>
        """
        if source_aggregate_available
        else '<p class="review-empty">There are no customer ratings for this item yet.</p>'
    )

    return f"""
    <section id="customerReviews" class="customer-reviews" data-asin="{escape(view['asin'], quote=True)}">
      <h2>Customer reviews</h2>
      {rating_summary_html}
      {write_panel}
      <div class="review-local-list">
        <div class="review-local-heading"><div><h3>Customer reviews</h3></div><span>{local_count} reviews</span></div>
        <div class="review-toolbar">
          <nav class="review-filters" aria-label="Filter customer reviews">{''.join(filters)}</nav>
          <nav class="review-sorts" aria-label="Sort customer reviews">{''.join(sort_links)}</nav>
        </div>
        {local_reviews_html}
      </div>
    </section>
    """


__all__ = [
    "FIXTURE_PATH",
    "LOCAL_REVIEW_PROVENANCE",
    "SOURCE_AGGREGATE_PROVENANCE",
    "build_review_view",
    "get_review_evidence",
    "normalize_local_reviews",
    "render_reviews_section",
    "supported_review_asins",
]