"""Parser for Mountain View Mini Storage of Buffalo, WY.

This is a Squarespace site that lists units as accordion items.
Each accordion item has a title with the size (e.g. "10 x 10") and
a description containing the price (e.g. "$50/month").

The "Indoor covered parking" item is a special case: the title has no
dimensions but the description body lists two sub-sizes with prices
inline ("10x15 $70/month" and "10x25 $90/month").

The "Uncovered outdoor parking" item has no price (call for pricing)
and is skipped.
"""

from __future__ import annotations

import re

from bs4 import BeautifulSoup

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


class Facility023093Parser(BaseParser):
    """Extract storage units from Mountain View Mini Storage of Buffalo, WY."""

    platform = "custom_facility_023093"

    # Matches title sizes like "10 x 10", "10 x 25", "8 x 20 Con Ex"
    _TITLE_SIZE_RE = re.compile(r"(\d+)\s*[xX]\s*(\d+)", re.IGNORECASE)

    # Matches "$50/month" or "$50/mo" anywhere in text
    _PRICE_RE = re.compile(r"\$([\d,]+(?:\.\d+)?)\s*/\s*mo(?:nth)?", re.IGNORECASE)

    # Matches inline size+price pairs in description like "10x15 $70/month"
    _INLINE_UNIT_RE = re.compile(
        r"(\d+)\s*[xX]\s*(\d+)\s+\$([\d,]+(?:\.\d+)?)\s*/\s*mo(?:nth)?",
        re.IGNORECASE,
    )

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

        accordion_items = soup.find_all("li", class_="accordion-item")

        for item in accordion_items:
            title_el = item.find("span", class_="accordion-item__title")
            desc_el = item.find("div", class_="accordion-item__description")

            if not title_el:
                continue

            title_text = title_el.get_text(strip=True)
            desc_text = desc_el.get_text(separator=" ", strip=True) if desc_el else ""

            title_size_match = self._TITLE_SIZE_RE.search(title_text)

            if title_size_match:
                # Standard unit: size is in the title, price is in the description
                width = float(title_size_match.group(1))
                length = float(title_size_match.group(2))

                # Build a clean size label; include any suffix (e.g. "Con Ex")
                suffix_text = title_text[title_size_match.end():].strip()
                size_label = f"{int(width)} x {int(length)}"
                if suffix_text:
                    size_label = f"{size_label} {suffix_text}"

                price = None
                price_match = self._PRICE_RE.search(desc_text)
                if price_match:
                    price = self.normalize_price(f"${price_match.group(1)}")

                unit = UnitResult(
                    size=size_label,
                    price=price,
                    description=desc_text,
                    metadata={"width": width, "length": length, "sqft": width * length},
                )

                if unit.size or unit.price:
                    result.units.append(unit)

            elif "covered parking" in title_text.lower():
                # Special case: "Indoor covered parking" — two sub-sizes in description
                for inline_match in self._INLINE_UNIT_RE.finditer(desc_text):
                    width = float(inline_match.group(1))
                    length = float(inline_match.group(2))
                    price = self.normalize_price(f"${inline_match.group(3)}")

                    unit = UnitResult(
                        size=f"{int(width)} x {int(length)}",
                        price=price,
                        description=f"Indoor covered parking — {int(width)}x{int(length)}",
                        metadata={
                            "width": width,
                            "length": length,
                            "sqft": width * length,
                            "amenities": ["indoor", "covered parking"],
                        },
                    )
                    result.units.append(unit)

            # "Uncovered outdoor parking" has no price, skip it

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

        return result