"""Parser for Storage 501 (www.storage501.com).

This is a Duda-based site. The homepage has no pricing data.
The /storage-information page lists unit sizes (e.g. "5 x 10 feet")
but does NOT publish prices -- customers must call for pricing.

The parser extracts sizes from dmNewParagraph elements that contain
the "N x N feet" pattern. No prices are available on this site.
"""

from __future__ import annotations

import re

from bs4 import BeautifulSoup

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


class Facility004528Parser(BaseParser):
    """Extract storage units from Storage 501."""

    platform = "custom_facility_004528"

    # Matches patterns like "5 x 10 feet", "10 x 25 feet", "8 x 10 feet"
    _SIZE_FEET_RE = re.compile(
        r"(\d+)\s*x\s*(\d+)\s*feet",
        re.IGNORECASE,
    )

    # Fallback: matches "5'x10'" style dimensions
    _SIZE_PRIME_RE = re.compile(
        r"(\d+)\s*['\u2032]\s*[xX\u00d7]\s*(\d+)\s*['\u2032]?"
    )

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

        for tag in soup.find_all(["script", "style"]):
            tag.decompose()

        seen: set[tuple[int, int]] = set()

        # Strategy 1: Look for "N x N feet" in paragraph elements
        paragraphs = soup.find_all(
            "div", class_=re.compile(r"dmNewParagraph")
        )
        for p in paragraphs:
            text = p.get_text(separator=" ", strip=True)
            for m in self._SIZE_FEET_RE.finditer(text):
                w, ln = int(m.group(1)), int(m.group(2))
                if (w, ln) in seen or w < 3 or ln < 3:
                    continue
                seen.add((w, ln))
                size_str = f"{w}x{ln}"
                unit = UnitResult()
                unit.size = size_str
                _, _, sq = self.normalize_size(size_str)
                unit.metadata = {"width": w, "length": ln, "sqft": sq}
                result.units.append(unit)

        # Strategy 2: Fall back to full-page text scan for prime notation
        if not result.units:
            body_text = soup.get_text(separator="\n")
            for m in self._SIZE_PRIME_RE.finditer(body_text):
                w, ln = int(m.group(1)), int(m.group(2))
                if (w, ln) in seen or w < 3 or ln < 3:
                    continue
                seen.add((w, ln))
                size_str = f"{w}x{ln}"
                unit = UnitResult()
                unit.size = size_str
                _, _, sq = self.normalize_size(size_str)
                unit.metadata = {"width": w, "length": ln, "sqft": sq}
                result.units.append(unit)

        if not result.units:
            result.warnings.append("No units found on page")
        else:
            result.warnings.append(
                "No prices listed on site; sizes extracted without pricing"
            )

        return result