"""Parser for Stor N Lok (cisnorthplatte.com)."""

from __future__ import annotations

import re

from bs4 import BeautifulSoup

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


class Facility003456Parser(BaseParser):
    """Extract storage units from Stor N Lok.

    The facility page lists unit sizes in <div> elements under a description
    section.  Each line has the format:  WxH  door_type,
    where door_type is W (walk-through) or O (overhead).
    No pricing is published; prices require calling the facility.
    """

    platform = "custom_facility_003456"

    # Matches e.g. "4×8", "10 x 20", "5x10"
    _SIZE_RE = re.compile(r"(\d+)\s*[xX\u00d7]\s*(\d+)")

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

        # Look for the description section containing unit sizes
        description_section = soup.find("section", class_="description-wrap")
        if not description_section:
            description_section = soup

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

        for div in description_section.find_all("div"):
            text = div.get_text(strip=True)
            if not text:
                continue

            matches = list(self._SIZE_RE.finditer(text))
            if not matches:
                continue

            for match in matches:
                width = int(match.group(1))
                length = int(match.group(2))

                # Skip tiny dimensions (favicon sizes, etc.)
                if width < 3 or length < 3:
                    continue

                key = (width, length)
                if key in seen:
                    continue
                seen.add(key)

                size_str = f"{width}x{length}"
                unit = UnitResult()
                unit.size = size_str
                w_norm, l_norm, sqft = self.normalize_size(size_str)
                if w_norm is not None:
                    unit.metadata = {"width": w_norm, "length": l_norm, "sqft": sqft}

                door_type = self._extract_door_type(text)
                if door_type:
                    unit.description = f"{size_str} - {door_type}"
                    if unit.metadata:
                        unit.metadata["door_type"] = door_type
                else:
                    unit.description = size_str

                result.units.append(unit)

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

        return result

    @staticmethod
    def _extract_door_type(text: str) -> str | None:
        """Extract door type from text like '4x8  W,' or '10x10  O,'."""
        if re.search(r"\bO\s*&\s*W\b", text):
            return "Overhead & Walk-through"
        if re.search(r"\bW\b", text) and not re.search(r"\bO\b", text):
            return "Walk-through"
        if re.search(r"\bO\b", text) and not re.search(r"\bW\b", text):
            return "Overhead"
        return None