"""Parser for Del Rio Self Storage (StorEdge/Apollo platform)."""

from __future__ import annotations

import re

from bs4 import BeautifulSoup

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


class Facility035500Parser(BaseParser):
    """Extract storage units from Del Rio Self Storage.

    Unit data is stored in the Apollo state JSON as UnitGroup entries.
    Fallback: MUI button size filters for when Apollo state is absent.
    """

    platform = "custom_facility_035500"

    _UNIT_GROUP_RE = re.compile(
        r'"UnitGroup:[^"]+":\{"id":"[^"]+","name":"([^"]+)","type":"([^"]*)","price":(\d+(?:\.\d+)?)'
    )
    _SIZE_RE = re.compile(
        r"(\d+)\s*['\u2019\u2032]?\s*[xX\u00d7]\s*(\d+)\s*['\u2019\u2032]?"
    )

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

        # Primary: Apollo state UnitGroup entries
        seen: set[tuple[str, float]] = set()
        for m in self._UNIT_GROUP_RE.finditer(html):
            name = m.group(1)
            type_str = m.group(2)
            price = float(m.group(3))

            size_norm = re.sub(r"[^0-9x]", "", name.lower())
            if not re.match(r"^\d+x\d+$", size_norm):
                continue

            parts = size_norm.split("x")
            width, length = int(parts[0]), int(parts[1])
            if width < 2 or length < 2:
                continue

            key = (size_norm, price)
            if key in seen:
                continue
            seen.add(key)

            unit = UnitResult()
            unit.size = f"{width}x{length}"
            unit.price = price
            unit.description = type_str or unit.size
            w, ln, sq = self.normalize_size(unit.size)
            if w is not None:
                unit.metadata = {"width": w, "length": ln, "sqft": sq}
            result.units.append(unit)

        if result.units:
            return result

        # Fallback: MUI button sizes
        soup = BeautifulSoup(html, "lxml")
        seen_sizes: set[str] = set()

        for btn in soup.find_all("button", class_=re.compile(r"MuiButton")):
            text = btn.get_text(strip=True)
            m = self._SIZE_RE.search(text)
            if m:
                w, ln = float(m.group(1)), float(m.group(2))
                if w < 3 or ln < 3:
                    continue
                size_key = f"{int(w)}x{int(ln)}"
                if size_key in seen_sizes:
                    continue
                seen_sizes.add(size_key)
                unit = UnitResult()
                unit.size = f"{int(w)}' x {int(ln)}'"
                unit.metadata = {"width": w, "length": ln, "sqft": w * ln}
                result.units.append(unit)

        # Text fallback
        if not result.units:
            for tag in soup.find_all(["script", "style"]):
                tag.decompose()
            text = soup.get_text(separator="\n")
            for m in self._SIZE_RE.finditer(text):
                w, ln = float(m.group(1)), float(m.group(2))
                if w < 3 or ln < 3:
                    continue
                size_key = f"{int(w)}x{int(ln)}"
                if size_key in seen_sizes:
                    continue
                seen_sizes.add(size_key)
                unit = UnitResult()
                unit.size = f"{int(w)}' x {int(ln)}'"
                unit.metadata = {"width": w, "length": ln, "sqft": w * ln}
                result.units.append(unit)

        if not result.units:
            result.warnings.append("No units found")
        return result