"""Parser for Good Guys Storage Llc (loc8nearme.com directory listing)."""

from __future__ import annotations

import re

from bs4 import BeautifulSoup

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


class Facility001526Parser(BaseParser):
    """Extract storage units from Good Guys Storage Llc.

    The facility URL points to a loc8nearme.com directory listing page,
    not a direct facility website.  These pages sometimes contain
    embedded unit/pricing tables; this parser looks for them and falls
    back gracefully when the page only has business-directory info.
    """

    platform = "custom_facility_001526"

    _SIZE_PRICE_RE = re.compile(
        r"(\d+)\s*['\u2019\u2032]?\s*[xX\u00d7]\s*(\d+)\s*['\u2019\u2032]?"
        r"[^\$]{0,120}"
        r"\$\s*(\d[\d,.]*)",
        re.DOTALL,
    )

    _PRICE_SIZE_RE = re.compile(
        r"\$\s*(\d[\d,.]*)"
        r".{0,120}"
        r"(\d+)\s*['\u2019\u2032]?\s*[xX\u00d7]\s*(\d+)\s*['\u2019\u2032]?",
        re.DOTALL,
    )

    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()

        body_text = soup.get_text(separator="\n")

        # Detect if the facility is marked as closed
        if re.search(r"(?i)temporarily\s+closed", body_text):
            result.warnings.append("Facility is listed as TEMPORARILY CLOSED")

        # Detect directory-only pages with no pricing content
        is_directory = bool(
            re.search(r"(?i)loc8nearme\.com", html)
            or re.search(r"(?i)hours,?\s*directions,?\s*reviews", body_text)
        )

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

        # Try size-then-price pattern
        for m in self._SIZE_PRICE_RE.finditer(body_text):
            w_str, l_str, price_str = m.group(1), m.group(2), m.group(3)
            size_text = f"{w_str}x{l_str}"
            key = (size_text, price_str)
            if key in seen:
                continue
            seen.add(key)

            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}
            unit.price = self.normalize_price(price_str)
            unit.description = m.group(0).strip()[:200]
            if unit.size or unit.price:
                result.units.append(unit)

        # Try price-then-size pattern
        if not result.units:
            for m in self._PRICE_SIZE_RE.finditer(body_text):
                price_str, w_str, l_str = m.group(1), m.group(2), m.group(3)
                size_text = f"{w_str}x{l_str}"
                key = (size_text, price_str)
                if key in seen:
                    continue
                seen.add(key)

                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}
                unit.price = self.normalize_price(price_str)
                unit.description = m.group(0).strip()[:200]
                if unit.size or unit.price:
                    result.units.append(unit)

        if not result.units:
            if is_directory:
                result.warnings.append(
                    "Page is a loc8nearme.com directory listing with no unit pricing data"
                )
            else:
                result.warnings.append("No units found")

        return result