# -----------------------------------------------------------------------------
# Lou-Ka — Location court terme
# connectors/glampinghub.py : Glamping Hub (glampinghub.com) — hébergements
# insolites (dômes, yourtes, pods, cabanes…), ~200 fiches au Québec.
#
# Méthode : l'endpoint AJAX de la page de recherche est ouvert (aucun anti-bot) :
#   GET https://glampinghub.com/search-accommodations/?lang=en&page=N
#       &q=Quebec, Canada&location={"state": "Quebec", "country": "Canada"}
#       &adults=2&…&numberOfResultsPerPage=24
#   → search_results[…] + total_results. Chaque fiche est TRÈS riche : nom,
#   catégorie, ville + coordonnées, prix (estimated_rate.daily_rate en devise
#   originale, CAD au Québec), chambres/lits, capacité par unité
#   (units_distribution), note sur 5, commodités (nested_features), photos.
#   Une seule requête paginée suffit pour la liste ; seule la DESCRIPTION
#   n'y figure pas → elle est prise sur la page détail (aucun anti-bot non
#   plus), dans le bloc SSR <noscript id="description-content">, avec repli
#   sur la <meta name="description">. Cache permanent dans louka_ct.db.
#
# URL publique : https://glampinghub.com<absolute_url_en>. Région touristique
# déduite des coordonnées (centroïdes partagés avec airbnb.py).
# Réglages env : LOUKA_GLAMPINGHUB_LIMIT (nb max de fiches, 0 = tout),
#                LOUKA_GLAMPINGHUB_DETAIL_LIMIT (fetchs détail/sync, défaut 250).
# -----------------------------------------------------------------------------
from __future__ import annotations

import html as _html
import os
import re
import sys

from ..schema import StListing
from .base import StConnector
from .airbnb import _region_from_latlng


class _DetailSkip(Exception):
    """Fiche détail sautée (budget épuisé) — pas de mise en cache."""


_DESC_RE = re.compile(r'<noscript id="description-content">(.*?)</noscript>',
                      re.S)
_META_RE = re.compile(r'<meta name="description" content="([^"]+)"')

SITE = "https://glampinghub.com"
API = f"{SITE}/search-accommodations/"
PAGE_SIZE = 24

# Catégorie Glamping Hub → type canonique Lou-Ka
_CATEGORIES = {
    "cabins": "Chalet", "cottages": "Chalet", "log cabins": "Chalet",
    "vacation rentals": "Maison", "villas": "Maison",
    "designer rentals": "Maison", "unique stays": "Autre",
    "tiny houses": "Mini-maison", "hobbit houses": "Mini-maison",
    "domes": "Dôme", "yurts": "Yourte", "tipis": "Prêt-à-camper",
    "pods": "Prêt-à-camper", "bell tents": "Prêt-à-camper",
    "safari tents": "Prêt-à-camper", "tented cabins": "Prêt-à-camper",
    "canvas tents": "Prêt-à-camper", "airstreams": "Prêt-à-camper",
    "caravans": "Prêt-à-camper", "campervans": "Prêt-à-camper",
    "tree houses": "Autre", "barns": "Autre", "boats": "Autre",
    "islands": "Autre", "castles": "Autre", "condos": "Condo",
    "apartments": "Appartement", "lodges": "Auberge",
    "bed and breakfasts": "Gîte",
}


def _num(v) -> float | None:
    try:
        return float(v) if v not in (None, "") else None
    except (TypeError, ValueError):
        return None


class GlampingHub(StConnector):
    source_id = "glampinghub"
    request_delay = 0.8

    # -- liste --------------------------------------------------------------
    def _search_page(self, page: int) -> dict:
        resp = self.get(API, params={
            "lang": "en",
            "page": page,
            "q": "Quebec, Canada",
            "location": '{"state": "Quebec", "country": "Canada"}',
            "adults": 2, "children": 0, "infants": 0,
            "sort": "-ranking_engine_boost",
            "source": "rentalsearch",
            "numberOfResultsPerPage": PAGE_SIZE,
        }, headers={"Accept": "application/json",
                    "X-Requested-With": "XMLHttpRequest",
                    "Referer": f"{SITE}/rentalsearch/"})
        return resp.json()

    def _all_items(self) -> list[dict]:
        items: list[dict] = []
        page, total = 0, 1
        while len(items) < min(total, 2000) and page < 100:
            data = self._search_page(page)
            batch = data.get("search_results") or []
            total = data.get("total_results") or 0
            if not batch:
                break
            items.extend(batch)
            page += 1
        return items

    # -- description (page détail, SSR ouvert) --------------------------------
    @staticmethod
    def _parse_description(html: str) -> dict:
        """{description} depuis le bloc <noscript> SSR (repli : meta)."""
        desc = ""
        m = _DESC_RE.search(html or "")
        if m:
            txt = re.sub(r"<br\s*/?>|</p>|</h2>", "\n", m.group(1))
            txt = _html.unescape(re.sub(r"<[^>]+>", " ", txt))
            lines = [re.sub(r"\s+", " ", ln).strip() for ln in txt.split("\n")]
            # écarter le bruit : lignes « … », slogan SEO de bas de bloc et
            # liste de commodités hors-plateforme (pas une description)
            lines = [ln for ln in lines if ln and ln not in ("...", "…")
                     and not re.match(r"^Book your dream .*!$", ln)
                     and not ln.startswith("Amenities not shown on")]
            desc = "\n".join(lines).strip()
        if len(desc) < 40:              # fiche laconique (« … ») : repli meta
            mm = _META_RE.search(html or "")
            meta = _html.unescape(mm.group(1)).strip() if mm else ""
            if len(meta) > len(desc):
                desc = meta
        return {"description": desc[:6000]} if desc else {}

    def _enrich_details(self, listings: list[StListing]) -> None:
        """Complète la description via la page détail, sous budget (les hits
        de cache sont gratuits, seuls les fetchs réseau comptent)."""
        limit = max(0, int(os.environ.get("LOUKA_GLAMPINGHUB_DETAIL_LIMIT",
                                          "250") or 250))
        used = enriched = 0
        for lst in listings:
            if not lst.url.startswith(SITE + "/"):
                continue
            def fetch_fn(url=lst.url):
                nonlocal used
                if used >= limit:
                    raise _DetailSkip
                used += 1
                return self._parse_description(self.get(url).text)

            try:
                d = self.detail(lst.external_id, "v1", fetch_fn)
            except _DetailSkip:
                continue
            except Exception:  # noqa: BLE001 — une fiche ne bloque pas le run
                continue
            if d.get("description") and len(d["description"]) > \
                    len(lst.description or ""):
                lst.description = d["description"]
                enriched += 1
        print(f"[glampinghub] détail : {enriched} descriptions"
              f" ({used}/{limit} fetchs réseau)", file=sys.stderr)

    # -- contrat --------------------------------------------------------------
    def fetch(self) -> list[StListing]:
        limit = int(os.environ.get("LOUKA_GLAMPINGHUB_LIMIT", "0") or 0)
        listings: list[StListing] = []
        seen: set[str] = set()
        for it in self._all_items():
            gid = str(it.get("id") or "").strip()
            title = (it.get("name_en") or "").strip()
            loc = it.get("location") or {}
            if not gid or gid in seen or not title:
                continue
            if (loc.get("state_en") or "").strip().lower() != "quebec":
                continue
            seen.add(gid)

            lat = lng = None
            coords = (loc.get("coords") or "").split(",")
            if len(coords) == 2:
                lat, lng = _num(coords[0]), _num(coords[1])

            path = it.get("absolute_url_en") or ""
            if not path:
                for u in it.get("absolute_url") or []:
                    if (u or {}).get("lang") == "en":
                        path = u.get("url") or ""
                        break

            images = []
            for ph in (it.get("images") or [])[:15]:
                u = (ph or {}).get("url") or ""
                if u.startswith("//"):
                    u = "https:" + u
                if u.startswith("https://") and u not in images:
                    images.append(u)

            # prix : tarif nuit de base en devise originale (CAD au Québec)
            price_night, price_label = None, ""
            rate = it.get("estimated_rate") or {}
            daily = _num(rate.get("daily_rate"))
            if daily and (it.get("original_currency") or "") == "CAD":
                price_night = daily
                price_label = f"à partir de {daily:.0f} $ CAD / nuit"

            units = it.get("units_distribution") or []
            capacity = max((_num(u.get("capacity")) or 0 for u in units),
                           default=0) or None

            amenities = []
            for f in it.get("nested_features") or []:
                name = (f or {}).get("name_en") or ""
                if f.get("active") and name and name not in amenities:
                    amenities.append(name)

            category = (it.get("category_en") or "").strip()
            details = {k: v for k, v in {
                "category": category,
                "units": len(units) or None,
                "min_stay": rate.get("min_stay"),
                "verified": bool(it.get("verified_accommodation")) or None,
                "remarkable": [f.get("name_en") for f in
                               (it.get("remarkable_features") or [])
                               if (f or {}).get("name_en")] or None,
            }.items() if v}

            rating = _num(it.get("average_rate"))
            listings.append(StListing(
                source=self.source_id,
                external_id=gid,
                url=SITE + path if path else SITE,
                title=title,
                property_type=_CATEGORIES.get(category.lower(), "Autre"),
                city=loc.get("city_en") or "",
                region=_region_from_latlng(lat, lng),
                price_night=price_night,
                price_label=price_label,
                capacity=capacity,
                bedrooms=_num(it.get("bedrooms_number")),
                beds=_num(it.get("beds_number")),
                rating=rating if rating else None,
                amenities=amenities,
                details=details,
                images=images,
                lat=lat,
                lng=lng,
            ))
            if limit and len(listings) >= limit:
                break
        self._enrich_details(listings)
        return listings