"""Parser for West Side Storage (StorageUnitSoftware site).

URL: https://4statestorage.storageunitsoftware.com/pages/rent
Standard SUS Bootstrap card layout with div.card.rounded-0 containers.
"""

from __future__ import annotations

import re

from bs4 import BeautifulSoup

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


class Facility003868Parser(BaseParser):
    """Extract storage units from West Side Storage.

    This is a standard StorageUnitSoftware Bootstrap card layout site.
    Units appear as div.card.rounded-0 containers with h4.primary-color
    for the size and strong.price for pricing. When inventory is empty,
    the page shows a text-danger message instead of cards.
    """

    platform = "custom_facility_003868"

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

        # Check for "no available units" message (common SUS empty state)
        no_units_msg = soup.select_one("p.text-danger")
        if no_units_msg and "no available units" in no_units_msg.get_text(strip=True).lower():
            result.warnings.append("Facility reports no available units")
            return result

        # Strategy 1: Bootstrap card layout (modern SUS sites)
        cards = soup.select("div.card.rounded-0")
        unit_cards = [c for c in cards if c.select_one("strong.price, .price.primary-color")]

        # Strategy 2: SUS-specific class containers
        if not unit_cards:
            unit_cards = soup.select(".sus-unit-row, .sus-unit-card, .sus-unit-item")

        # Strategy 3: data-attribute fallback
        if not unit_cards:
            unit_cards = soup.select("[data-unit-id], [data-unit]")

        if not unit_cards:
            result.warnings.append("No unit elements found")
            return result

        for card in unit_cards:
            unit = self._parse_card(card)
            if unit and (unit.size or unit.price):
                result.units.append(unit)

        return result

    def _parse_card(self, card) -> UnitResult | None:
        """Parse a single SUS Bootstrap card into a UnitResult."""
        unit = UnitResult()

        # Size: h4.primary-color contains "Name (WxL)" or just "WxL"
        heading = card.select_one("h4.primary-color")
        if heading:
            heading_text = heading.get_text(strip=True)
            w, ln, sq = self.normalize_size(heading_text)
            if w is not None:
                unit.size = heading_text
                unit.metadata = {"width": w, "length": ln, "sqft": sq}

        # Price: strong.price.primary-color or strong.price
        price_el = card.select_one("strong.price.primary-color") or card.select_one("strong.price")
        if price_el:
            # Check for strikethrough (street rate) + discounted (web rate) pattern
            struck = price_el.select_one("s")
            if struck:
                unit.price = self.normalize_price(struck.get_text(strip=True))
                price_span = price_el.select_one("span")
                if price_span:
                    span_text = re.sub(r"/\s*month", "", price_span.get_text(strip=True)).strip()
                    unit.sale_price = self.normalize_price(span_text)
            else:
                price_text = price_el.get_text(strip=True)
                price_text = re.sub(r"/\s*month\*?", "", price_text).strip()
                unit.sale_price = self.normalize_price(price_text)
                if unit.sale_price is None:
                    price_match = re.search(r"\$([\d,]+(?:\.\d+)?)", price_text)
                    if price_match:
                        unit.sale_price = self.normalize_price(price_match.group(1))

        # Description from visible card body
        card_body = card.select_one(".card-body")
        visible = card_body if card_body else card
        for hidden in visible.select(".d-none"):
            hidden.decompose()
        unit.description = visible.get_text(separator=" ", strip=True)[:200]

        # Availability from button/link text
        text_lower = (unit.description or "").lower()
        if "rent now" in text_lower:
            unit.scarcity = "Available"
        elif "waiting list" in text_lower or "waitlist" in text_lower:
            unit.scarcity = "Waitlist"
        elif "sold out" in text_lower or "no units" in text_lower:
            unit.scarcity = "Unavailable"

        # Amenities
        meta = unit.metadata or {}
        if any(kw in text_lower for kw in ["climate", "temperature", "heated", "cooled"]):
            meta["climateControlled"] = True
        if any(kw in text_lower for kw in ["drive-up", "drive up", "driveup"]):
            meta["driveUpAccess"] = True
        if meta:
            unit.metadata = meta

        return unit