"""Parser for Stor-It Self Storage - Caldwell (facility 038686).

This facility uses the Candee platform (WordPress plugin). Unit data is loaded
via an AJAX call and embedded in ``data-unit-info`` JSON attributes on
``.unitsList.lineItem.unitMasterData`` elements. The snapshot stored on disk
is the AJAX response HTML fragment (not the full page).
"""

from __future__ import annotations

import json
import logging

from bs4 import BeautifulSoup

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

logger = logging.getLogger(__name__)


class Facility038686Parser(BaseParser):
    """Extract storage units from Stor-It Self Storage - Caldwell (Candee platform).

    Each unit is represented by a ``<div class="unitsList lineItem unitMasterData">``
    element whose ``data-unit-info`` attribute contains a JSON object with all
    relevant fields: ``rental_name``, ``price``, ``strike_through``, ``width``,
    ``length``, ``unit_type``, ``inside``, ``available``, ``total_available``,
    ``discount_name``, and ``discounts``.
    """

    platform = "custom_facility_038686"

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

        unit_items = soup.select(".unitsList.lineItem.unitMasterData")
        if not unit_items:
            result.warnings.append("No Candee unit items found (expected .unitsList.lineItem.unitMasterData)")
            return result

        for item in unit_items:
            unit_info_raw = item.get("data-unit-info", "")
            if not unit_info_raw:
                continue

            try:
                info = json.loads(unit_info_raw)
            except json.JSONDecodeError as exc:
                logger.debug("Failed to parse data-unit-info: %s", exc)
                result.warnings.append(f"Could not parse data-unit-info JSON: {exc}")
                continue

            rental_name = info.get("rental_name", "")
            unit_type = info.get("unit_type", "")
            width = info.get("width")
            length = info.get("length")
            price_raw = info.get("price")
            strike_through_raw = info.get("strike_through")
            discount_name = info.get("discount_name")
            discounts = info.get("discounts", [])
            total_available = info.get("total_available")
            inside = info.get("inside")

            # Build size string
            if width and length:
                size = f"{int(width)}' x {int(length)}'"
                sqft = float(width) * float(length)
            else:
                # Fall back to parsing the rental_name
                w, l, sqft = self.normalize_size(rental_name)
                if w and l:
                    size = f"{int(w)}' x {int(l)}'"
                    width, length = w, l
                else:
                    size = rental_name
                    sqft = None

            # Prices
            price: float | None = None
            sale_price: float | None = None

            if price_raw is not None:
                try:
                    price_val = float(str(price_raw).replace(",", ""))
                except (ValueError, TypeError):
                    price_val = None
            else:
                price_val = None

            # strike_through holds the original (higher) price when a discount applies
            if strike_through_raw and str(strike_through_raw) not in ("0", ""):
                try:
                    strike_val = float(str(strike_through_raw).replace(",", ""))
                except (ValueError, TypeError):
                    strike_val = None
                if strike_val:
                    price = strike_val
                    sale_price = price_val
                else:
                    price = price_val
            else:
                price = price_val

            # Promotion text from first discount
            promotion: str | None = None
            if discounts:
                first_discount = discounts[0]
                promo_name = first_discount.get("name") or discount_name
                if promo_name:
                    promotion = promo_name
            elif discount_name:
                promotion = discount_name

            # Scarcity
            scarcity: str | None = None
            if total_available is not None:
                try:
                    avail_count = int(total_available)
                    if 0 < avail_count <= 3:
                        scarcity = f"Only {avail_count} left"
                except (ValueError, TypeError):
                    pass

            # Description: use rental_name for full context including unit type
            description = rental_name if rental_name else unit_type

            # Amenity metadata
            is_climate = "climate" in unit_type.lower() or "climate" in rental_name.lower()
            is_parking = "parking" in unit_type.lower()
            is_interior = bool(inside) or "interior" in unit_type.lower()

            metadata: dict = {
                "unit_type": unit_type,
                "facility_id": info.get("rental_id"),
                "prop_id": item.get("data-facility"),
                "is_parking": is_parking,
                "is_climate_controlled": is_climate,
                "is_interior": is_interior,
            }
            if width and length:
                metadata["width"] = width
                metadata["length"] = length
            if sqft is not None:
                metadata["sqft"] = sqft

            result.units.append(
                UnitResult(
                    size=size,
                    description=description,
                    price=price,
                    sale_price=sale_price,
                    promotion=promotion,
                    scarcity=scarcity,
                    url=url or None,
                    metadata=metadata,
                )
            )

        if not result.units:
            result.warnings.append("No units could be extracted from Candee unit items")

        return result