"""Parser for modSTORAGE — Laramie, WY (facility 101861).

This is a React/Next.js SPA site (modstorage.com) that renders unit cards as
mobile-optimised card elements. Each unit is a ``div.flex.md:hidden.flex-col``
card containing size, amenity type, promotional pricing ($0 first month), the
ongoing monthly price, the regular (crossed-out) price, and optional scarcity.
"""

from __future__ import annotations

import re

from bs4 import BeautifulSoup, Tag

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


class Facility101861Parser(BaseParser):
    """Extract storage units from modSTORAGE Laramie WY.

    Page structure (per unit card):
        <div class="flex md:hidden flex-col p-4 gap-3">
          <!-- size -->
          <span class="text-xl font-bold">5' x 5'</span>
          <!-- amenity/type -->
          <span class="text-xs text-muted-foreground">Drive Up</span>
          <!-- optional scarcity badge, e.g. "2 left" or "Only 2 left" -->
          <!-- promotional label, e.g. "Totally FREE Move In" -->
          <p class="text-[11px] text-primary font-medium ...">Totally FREE Move In</p>
          <!-- first-month price (often $0.00) -->
          <span class="text-2xl font-bold text-primary">$0.00</span>
          <!-- "then $XX.XX/mo" ongoing price -->
          <span class="text-sm text-muted-foreground">then $19.99/mo</span>
          <!-- regular/strikethrough price -->
          <span class="text-sm line-through ...">$34.99</span>
        </div>

    Pricing mapping:
        ``price``       = regular (strikethrough) price — the non-promotional rate
        ``sale_price``  = ongoing monthly rate after promotion (``then $XX/mo``)
        ``promotion``   = first-month promo text (e.g. "Totally FREE Move In – $0.00 1st mo")
    """

    platform = "custom_facility_101861"

    # Matches "then $XX.XX/mo" in muted spans
    _THEN_PRICE_RE = re.compile(r"then\s+\$([\d,]+(?:\.\d+)?)\s*/\s*mo", re.IGNORECASE)
    # Matches plain scarcity text such as "2 left" or "Only 2 left"
    _SCARCITY_RE = re.compile(r"(?:only\s+)?(\d+)\s+left", re.IGNORECASE)

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

        # Target the mobile unit cards rendered by the React SPA.
        # The desktop variant (div.md:flex.hidden) duplicates the same data, so
        # we parse only the mobile cards to avoid double-counting.
        cards = soup.find_all(
            "div",
            class_=lambda c: c and "md:hidden" in c and "flex-col" in c and "p-4" in c,
        )

        if not cards:
            result.warnings.append("No unit cards found — page structure may have changed")
            return result

        for card in cards:
            unit = self._parse_card(card, url)
            if unit is not None:
                result.units.append(unit)

        if not result.units:
            result.warnings.append(f"Cards found ({len(cards)}) but no units extracted")

        return result

    def _parse_card(self, card: Tag, url: str) -> UnitResult | None:
        """Extract a single UnitResult from a unit card element."""

        # --- Size ---
        size_span = card.find("span", class_=lambda c: c and "text-xl" in c and "font-bold" in c)
        if not size_span:
            return None
        raw_size = size_span.get_text(strip=True)
        width, length, sqft = self.normalize_size(raw_size)
        if width is None:
            return None
        size = f"{int(width)}' x {int(length)}'"

        # --- Amenity / unit type ---
        amenity_span = card.find(
            "span",
            class_=lambda c: c and "text-xs" in c and "text-muted-foreground" in c,
        )
        amenity = amenity_span.get_text(strip=True) if amenity_span else None

        # --- Scarcity ---
        # The scarcity text may appear in various inline spans; scan all text.
        card_text = card.get_text(separator=" ", strip=True)
        scarcity_match = self._SCARCITY_RE.search(card_text)
        scarcity = scarcity_match.group(0).strip() if scarcity_match else None

        # --- First-month promotional price (e.g. "$0.00 1st mo") ---
        promo_label_el = card.find("p", class_=lambda c: c and "text-primary" in c and "font-medium" in c)
        promo_label = promo_label_el.get_text(strip=True) if promo_label_el else None

        first_price_span = card.find(
            "span",
            class_=lambda c: c and "text-2xl" in c and "font-bold" in c and "text-primary" in c,
        )
        first_price_text = first_price_span.get_text(strip=True) if first_price_span else None
        first_price = self.normalize_price(first_price_text) if first_price_text else None

        # Build promotion string
        promotion: str | None = None
        if promo_label and first_price is not None:
            promotion = f"{promo_label} – {first_price_text} 1st mo"
        elif promo_label:
            promotion = promo_label

        # --- Ongoing monthly price (sale_price) ---
        # Appears in a "text-sm text-muted-foreground" span containing "then $..."
        then_spans = card.find_all(
            "span",
            class_=lambda c: c and "text-sm" in c and "text-muted-foreground" in c,
        )
        sale_price: float | None = None
        for span in then_spans:
            m = self._THEN_PRICE_RE.search(span.get_text(strip=True))
            if m:
                sale_price = self.normalize_price(m.group(1))
                break

        # If no "then" span exists the first_price IS the ongoing price
        if sale_price is None and first_price is not None and first_price > 0:
            sale_price = first_price
            promotion = None  # no special promo in this case

        # --- Regular / strikethrough price ---
        strike_span = card.find("span", class_=lambda c: c and "line-through" in c)
        regular_price: float | None = None
        if strike_span:
            regular_price = self.normalize_price(strike_span.get_text(strip=True))

        return UnitResult(
            size=size,
            description=amenity,
            price=regular_price,
            sale_price=sale_price,
            promotion=promotion,
            scarcity=scarcity,
            url=url,
            metadata={
                "width": width,
                "length": length,
                "sqft": sqft,
                "amenity": amenity,
            },
        )