"""Parser for Make Room Storage (mkrmstorage.com) — storedge platform.

The page embeds unit data in a JSON-LD <script type="application/ld+json"> block
as a @graph of Product items. Each item's description field encodes dimensions,
price, and an internal facility ID in the format:

    "{width}x{depth}x{height} - ${price} - {facility_id}"
    or
    "{width}x{depth} - ${price} - {facility_id}"

Example: "10x20x10 - $90.00 - 64696"
"""

from __future__ import annotations

import json
import re

from bs4 import BeautifulSoup

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

# Matches: "{width}x{depth}[x{height}] - ${price} - {rest}"
_DESC_RE = re.compile(
    r"^(\d+(?:\.\d+)?)x(\d+(?:\.\d+)?)(?:x(\d+(?:\.\d+)?))?",
    re.IGNORECASE,
)


class Facility051938Parser(BaseParser):
    """Extract storage units from Make Room Storage (storedge JSON-LD data)."""

    platform = "custom_facility_051938"

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

        # Find all JSON-LD scripts and look for the Product @graph
        for script in soup.find_all("script", type="application/ld+json"):
            text = script.string
            if not text:
                continue
            try:
                data = json.loads(text)
            except (json.JSONDecodeError, ValueError):
                continue

            graph = data.get("@graph")
            if not isinstance(graph, list):
                continue

            # Check that this graph contains Product items
            products = [item for item in graph if item.get("@type") == "Product"]
            if not products:
                continue

            for item in products:
                description = item.get("description", "")
                offers = item.get("offers", {})
                raw_price = offers.get("price")

                # Parse dimensions from description string
                match = _DESC_RE.match(description)
                if not match:
                    continue

                width = float(match.group(1))
                depth = float(match.group(2))
                height_str = match.group(3)
                height = float(height_str) if height_str else None

                size = f"{int(width)}x{int(depth)}"

                metadata: dict = {
                    "width": width,
                    "length": depth,
                    "sqft": width * depth,
                }
                if height is not None:
                    metadata["height"] = height

                price: float | None = None
                if raw_price is not None:
                    try:
                        price = float(raw_price)
                    except (TypeError, ValueError):
                        price = self.normalize_price(str(raw_price))

                unit = UnitResult(
                    size=size,
                    price=price,
                    description=description,
                    metadata=metadata,
                )
                result.units.append(unit)

            # Stop after the first matching graph block
            if result.units:
                break

        if not result.units:
            result.warnings.append("No Product units found in JSON-LD graph")

        return result