"""
Search Result Registry

Stores structured search results keyed by session and ref_id.
Each [SEARCH_REF:xxx] in an AI response maps to a SearchResult stored here,
allowing the UI to render product cards without the LLM ever re-listing them.
"""

import uuid
from dataclasses import dataclass, field
from typing import Optional


def new_ref_id() -> str:
    """Generate a short unique search reference ID, e.g. 'sr_3f9a1b2c'."""
    return "sr_" + uuid.uuid4().hex[:8]


@dataclass
class ProductItem:
    """A single product extracted from a search result, enriched with a match label."""

    spu_id: str
    title: str
    price: Optional[float] = None
    category_path: Optional[str] = None
    vendor: Optional[str] = None
    image_url: Optional[str] = None
    relevance_score: Optional[float] = None
    # LLM-assigned label: "Highly Relevant" | "Partially Relevant" | "Not Relevant"
    match_label: str = "Partially Relevant"
    tags: list = field(default_factory=list)
    specifications: list = field(default_factory=list)


@dataclass
class SearchResult:
    """
    A complete, self-contained search result block.

    Identified by ref_id (e.g. 'sr_3f9a1b2c').
    Stores the query, LLM quality assessment, and the curated product list
    (only "Highly Relevant" and "Partially Relevant" items — "Not Relevant" are discarded).
    """

    ref_id: str
    query: str

    # Raw API stats
    total_api_hits: int       # total documents matched by the search engine
    returned_count: int       # number of results we actually assessed

    # LLM quality labels breakdown
    perfect_count: int
    partial_count: int
    irrelevant_count: int

    # LLM-written short summary: what the results mainly contain, whether they meet intent, match degree
    quality_summary: str

    # Curated product list (perfect + partial only)
    products: list            # list[ProductItem]


class SearchResultRegistry:
    """
    Session-scoped store: session_id → { ref_id → SearchResult }.

    Lives as a global singleton in the process; Streamlit reruns preserve it
    as long as the worker process is alive.  Session isolation is maintained
    by keying on session_id.
    """

    def __init__(self) -> None:
        self._store: dict[str, dict[str, SearchResult]] = {}

    def register(self, session_id: str, result: SearchResult) -> str:
        """Store a SearchResult and return its ref_id."""
        if session_id not in self._store:
            self._store[session_id] = {}
        self._store[session_id][result.ref_id] = result
        return result.ref_id

    def get(self, session_id: str, ref_id: str) -> Optional[SearchResult]:
        """Look up a single SearchResult by session and ref_id."""
        return self._store.get(session_id, {}).get(ref_id)

    def get_all(self, session_id: str) -> dict:
        """Return all SearchResults for a session (ref_id → SearchResult)."""
        return dict(self._store.get(session_id, {}))

    def clear_session(self, session_id: str) -> None:
        """Remove all search results for a session (e.g. on chat clear)."""
        self._store.pop(session_id, None)


# ── Global singleton ──────────────────────────────────────────────────────────
# Imported by search_tools and app.py; both sides share the same object.
global_registry = SearchResultRegistry()