"""Parser for Store More Self Storage (Bagby Transfer & Storage).

StorEdge-powered site with unit data embedded as JSON-LD Product entries.
URL: https://www.bagbytransfer.com/storage-locations

This is a multi-location site with 5+ "Sites" distinguished by the product
``category`` field (e.g. "Site 5 WEST ROME-HUFFAKER - CC"). We filter to
only the site matching the target facility's address.
"""

from __future__ import annotations

import json

from bs4 import BeautifulSoup

from src.parsers.base import BaseParser, ParseResult, UnitResult


class Facility004533Parser(BaseParser):
    """Extract storage units from Bagby Transfer & Storage JSON-LD.

    Filters to the target facility location based on address keywords
    matched against the product category field.
    """

    platform = "custom_facility_004533"

    # The target facility is at 117 Huffaker Rd NW, Rome, GA 30165.
    # Products for this location have "HUFFAKER" or "Huff" in their category.
    _LOCATION_KEYWORDS = ["huffaker", "huff"]

    def parse(self, html: str, url: str = "") -> ParseResult:
        soup = BeautifulSoup(html, "lxml")
        result = ParseResult(platform=self.platform, parser_name=self.__class__.__name__)

        all_products = self._extract_products(soup)
        if not all_products:
            result.warnings.append("No units found in JSON-LD Product entries")
            return result

        # Group products by category to detect multi-location pages
        categories: dict[str, list[dict]] = {}
        for product in all_products:
            cat = (
                product.get("category", "")
                or product.get("offers", {}).get("category", "")
                or ""
            )
            categories.setdefault(cat, []).append(product)

        is_multi_location = len(categories) > 1

        if is_multi_location:
            # Filter to categories matching our target location
            matched_cats = [
                cat
                for cat in categories
                if any(kw in cat.lower() for kw in self._LOCATION_KEYWORDS)
            ]

            if not matched_cats:
                result.warnings.append(
                    f"Multi-location page with {len(categories)} site categories "
                    f"({', '.join(sorted(categories.keys())[:5])}...) but could not "
                    f"identify target facility (Huffaker Rd). "
                    f"Returning 0 units to avoid data contamination."
                )
                return result

            target_products = []
            for cat in matched_cats:
                target_products.extend(categories[cat])

            result.warnings.append(
                f"Multi-location page with {len(categories)} site categories; "
                f"filtered to {len(matched_cats)} matching categories "
                f"({', '.join(matched_cats)}) with {len(target_products)} units "
                f"(excluded {len(all_products) - len(target_products)} units "
                f"from other locations)"
            )
        else:
            target_products = all_products

        # Build UnitResult objects from filtered products
        for product in target_products:
            size_text = product.get("description", "")
            if not size_text:
                continue

            offers = product.get("offers", {})
            if isinstance(offers, list):
                offers = offers[0] if offers else {}

            price_raw = offers.get("price")
            category = product.get("category", "") or offers.get("category", "")

            unit = UnitResult()
            unit.size = size_text
            w, ln, sq = self.normalize_size(size_text)
            if w is not None:
                unit.metadata = {"width": w, "length": ln, "sqft": sq}
            if price_raw is not None:
                unit.price = self.normalize_price(str(price_raw))
            if category:
                unit.description = f"{size_text} - {category}"
            else:
                unit.description = size_text

            if unit.size or unit.price:
                result.units.append(unit)

        if not result.units:
            result.warnings.append("No units found after filtering to target facility")

        return result

    def _extract_products(self, soup: BeautifulSoup) -> list[dict]:
        """Collect all JSON-LD Product entries from the page."""
        products: list[dict] = []
        for script in soup.find_all("script", type="application/ld+json"):
            try:
                data = json.loads(script.string or "")
            except (json.JSONDecodeError, TypeError):
                continue

            if isinstance(data, dict) and "@graph" in data:
                products.extend(
                    item
                    for item in data["@graph"]
                    if isinstance(item, dict) and item.get("@type") == "Product"
                )
            elif isinstance(data, dict) and data.get("@type") == "Product":
                products.append(data)
            elif isinstance(data, list):
                products.extend(
                    item
                    for item in data
                    if isinstance(item, dict) and item.get("@type") == "Product"
                )

        return products