# -----------------------------------------------------------------------------
# Lou-Ka — Location court terme
# connectors/locationdechalets.py : Location de Chalets Lanaudière
#   (locationdechalets.com) — petit parc de ~10 chalets avec spa privé à
#   Notre-Dame-de-la-Merci et Saint-Donat (Lanaudière).
#
# Méthode : sitemap.xml → /fr/chalets/<slug>/ + lastmod (clé du cache détail).
#   Pages statiques (CMS maison) riches mais sans JSON-LD :
#     - h1 « Chalet Spa Le Héron … Capacité de 2 personnes » ;
#     - bloc CARACTÉRISTIQUES (« N personnes maximum / N chambre(s) /
#       N salle(s) de bain ») ;
#     - sections INTÉRIEUR / EXTÉRIEUR / INCLUS en <ul><li> → amenities ;
#     - « EN SUS … Animaux : 10 $ / jour » → pets = conditions ;
#     - bloc Coordonnées (rue, ville, « Lanaudière (Québec) », code postal) ;
#     - no CITQ dans le pied de page ; lat/lng dans le lien Google Maps (@…) ;
#     - TARIF RÉGULIER « 2 nuits : 498 $ … » → price_night = total/2 nuits.
#       ⚠️ anti-scrape : zéros de bourrage blancs sur blanc
#       (<span style='color: #ffffff;'>0</span>) à retirer AVANT le parsing ;
#     - galerie : background:url(/fichiersUploadOpt/…) du slider.
# -----------------------------------------------------------------------------
from __future__ import annotations

import html as _html
import re

from ..schema import StListing
from .base import StConnector

SITE = "https://www.locationdechalets.com"
SITEMAP = SITE + "/sitemap.xml"

_TAG_RE = re.compile(r"<[^>]+>")

# ville → région (repli quand la ligne « … (Québec) » manque)
_CITY_REGION = {
    "chute-st-philippe": "Laurentides",
    "chute-saint-philippe": "Laurentides",
    "la macaza": "Laurentides",
    "val-david": "Laurentides",
    "notre-dame-de-la-merci": "Lanaudière",
    "saint-donat": "Lanaudière",
    "st-donat": "Lanaudière",
}


def _text(fragment: str) -> str:
    return _html.unescape(re.sub(r"\s+", " ", _TAG_RE.sub(" ", fragment))).strip()


class LocationDeChalets(StConnector):
    source_id = "locationdechalets"
    request_delay = 1.0

    # -- page détail ----------------------------------------------------------
    def _detail(self, url: str) -> dict:
        h = self.get(url).text
        d: dict = {}

        m = re.search(r"(?s)<h1[^>]*>(.*?)</h1>", h)
        if m:
            d["title"] = _text(re.split(r"<br\s*/?>", m.group(1))[0])
        # « Capacité de 2 personnes » / « Capacité de 2 à 4 personnes » (max)
        m = re.search(r"Capacité de (?:\d+\s+à\s+)?(\d+) personnes", h)
        if m:
            d["capacity"] = int(m.group(1))

        # description : après <strong>Description</strong>, jusqu'à la
        # section suivante ; certaines pages n'ont pas ce marqueur → repli
        # sur le plus long <p> éditorial
        m = re.search(r"(?s)<strong>Description</strong>(.*?)"
                      r"(?:CARACTÉRISTIQUES|Caractéristiques|Disponibilités"
                      r"|<strong>INTÉRIEUR)", h)
        if m:
            texte = re.sub(r"<br\s*/?>", "\n", m.group(1))
            texte = _html.unescape(_TAG_RE.sub(" ", texte))
            texte = re.sub(r"[ \t]+", " ", texte)
            texte = re.sub(r"\n\s+", "\n", texte).strip()
            d["description"] = texte[:5000]
        else:
            paras = [_text(p) for p in
                     re.findall(r"(?s)<p[^>]*>(.*?)</p>", h)]
            paras = [p for p in paras if len(p) > 150
                     and "Coordonnées" not in p
                     and "Contactez-nous" not in p
                     and "Découvrez nos chalets" not in p]
            if paras:
                d["description"] = max(paras, key=len)[:5000]

        # sections (deux styles : MAJUSCULES ou « Caractéristiques : ») :
        # <ul> qui suit chaque entête → amenities + compteurs
        amen: list[str] = []
        for sec in (r"CARACT[EÉ]RISTIQUES", r"INT[EÉ]RIEUR",
                    r"EXT[EÉ]RIEUR", r"INCLUS"):
            for m in re.finditer(sec, h, re.I):
                mu = re.search(r"(?s)<ul[^>]*>(.*?)</ul>",
                               h[m.start():m.start() + 3500])
                if not mu:
                    continue
                for li in re.findall(r"(?s)<li[^>]*>(.*?)</li>", mu.group(1)):
                    t = _text(li)
                    if t and t not in amen:
                        amen.append(t)
                break
        # compteurs extraits des puces (« 2 chambres (1 lit queen…) »,
        # « 1 salle de bain », « 2 personnes maximum ») + du texte qui suit
        # l'entête CARACTÉRISTIQUES (pages où ce sont des <p>, pas des <li>)
        blob = " | ".join(amen)
        m = re.search(r"CARACT[EÉ]RISTIQUES", h, re.I)
        if m:
            blob += " | " + _text(h[m.start():m.start() + 700])
        m = re.search(r"(\d+)\s+personnes?\s+maximum", blob)
        if m:
            d.setdefault("capacity", int(m.group(1)))
        m = re.search(r"(\d+(?:[.,]5)?)\s+chambres?", blob)
        if m:
            d["bedrooms"] = float(m.group(1).replace(",", "."))
        m = re.search(r"(\d+(?:[.,]5)?)\s+salles?\s+de\s+bain", blob)
        if m:
            d["bathrooms"] = float(m.group(1).replace(",", "."))
        amen = [a for a in amen
                if not re.fullmatch(r"\d+\s+(personnes?\s+maximum"
                                    r"|chambres?|salles?\s+de\s+bain)", a)]
        if amen:
            d["amenities"] = amen

        # frais : « Animaux : 10 $ / jour » (section EN SUS)
        m = re.search(r"Animaux\s*:\s*([\d,]+\s*\$[^<]*)", h)
        if m:
            d["pets_fee"] = _text(m.group(1))

        # coordonnées : rue / ville / « Lanaudière (Québec) » / code postal
        m = re.search(r"(?s)<div class=\"coord[^\"]*\"[^>]*>(.*?)</div>", h)
        if m:
            lines = [_text(x) for x in re.split(r"<br\s*/?>|</p>", m.group(1))]
            lines = [x for x in lines if x and "Coordonnées" not in x
                     and not re.fullmatch(r"[\d,]+", x)]
            reg = next((x for x in lines if "(Québec)" in x), "")
            if reg:
                j = lines.index(reg)
                d["region"] = reg.split("(")[0].strip()
                if j >= 1:
                    d["city"] = lines[j - 1].strip(", ")
                if j >= 2:
                    d["address"] = lines[j - 2].strip(", ")
                if j + 1 < len(lines):
                    d["postal_code"] = lines[j + 1]
            else:
                # variante sans ligne « … (Québec) » : rue / ville / postal
                postal = next((x for x in lines
                               if re.fullmatch(r"[A-Z]\d[A-Z]\s?\d[A-Z]\d",
                                               x.strip())), "")
                rest = [x for x in lines if x != postal]
                if len(rest) >= 2:
                    d["address"] = rest[0].strip(", ")
                    d["city"] = rest[1].strip(", ")
                if postal:
                    d["postal_code"] = postal.strip()

        # (pas de lat/lng : le lien Google Maps pointe l'agence, pas le
        # chalet — le géocodage se fera en aval sur adresse+ville)
        m = re.search(r"CITQ\D{0,25}(\d{6})", h)
        if m:
            d["citq"] = m.group(1)

        # TARIF RÉGULIER : « 2 nuits : 498 $ » (en <p> ou en <table>) →
        # 249 $/nuit. ⚠️ anti-scrape : chiffres de bourrage blancs sur blanc,
        # PARFOIS IMBRIQUÉS (<span #fff>0<span #000>4</span></span>98) → on
        # élimine itérativement les <span> les plus internes : blancs = jetés
        # avec leur contenu, autres = dépliés (contenu conservé).
        i = h.find("TARIF RÉGULIER")
        if i >= 0:
            frag = h[i:i + 2500]
            for _ in range(20):
                frag2 = re.sub(
                    r"<span([^>]*)>([^<]*)</span>",
                    lambda m: (m.group(2).replace("0", "")
                               if re.search(r"color:\s*#f{3,6}\b",
                                            m.group(1), re.I)
                               else m.group(2)),
                    frag)
                if frag2 == frag:
                    break
                frag = frag2
            frag = _text(frag)
            m = re.search(r"(\d+)\s*nuits?\s*:\s*(\d[\d\s]*)\s*\$", frag)
            if m:
                nights = int(m.group(1))
                total = float(m.group(2).replace(" ", ""))
                if nights and 20 <= total / nights <= 20000:
                    d["price_night"] = round(total / nights)
                    d["price_ref"] = f"{nights} nuits : {total:g} $"

        # galerie du slider
        imgs: list[str] = []
        for u in re.findall(r"background:\s*url\(([^)]+)\)", h):
            u = u.strip("'\" ")
            if u.startswith("/fichiersUploadOpt/"):
                u = SITE + u
            if u.startswith("https://") and u not in imgs:
                imgs.append(u)
            if len(imgs) >= 20:
                break
        if imgs:
            d["images"] = imgs
        return d

    # -- contrat --------------------------------------------------------------
    def fetch(self) -> list[StListing]:
        xml = self.get(SITEMAP).text
        entries = re.findall(r"(?s)<url>\s*<loc>([^<]+)</loc>"
                             r"(?:\s*<lastmod>([^<]*)</lastmod>)?", xml)

        listings: list[StListing] = []
        vus: set[str] = set()
        for url, lastmod in entries:
            m = re.match(r"https://www\.locationdechalets\.com/fr/chalets/"
                         r"([^/]+)/?$", url)
            if not m:
                continue
            slug = m.group(1)
            if slug in vus:
                continue
            vus.add(slug)

            det = self.detail(slug, lastmod or "v1",
                              lambda u=url: self._detail(u))
            title = det.get("title") or ""
            if not title:
                continue

            city = det.get("city") or ""
            region = det.get("region") \
                or _CITY_REGION.get(city.lower(), "Lanaudière")

            price = det.get("price_night")
            details = {k: v for k, v in {
                "postal_code": det.get("postal_code") or "",
                "price_ref": det.get("price_ref") or "",
                "pets_fee": det.get("pets_fee") or "",
            }.items() if v}

            listings.append(StListing(
                source=self.source_id,
                external_id=slug,
                url=url,
                title=title,
                property_type="Chalet",
                address=det.get("address") or "",
                city=city,
                region=region,
                price_night=float(price) if price else None,
                price_label=f"à partir de {price:g} $ / nuit" if price else "",
                capacity=float(det["capacity"]) if det.get("capacity") else None,
                bedrooms=det.get("bedrooms"),
                bathrooms=det.get("bathrooms"),
                pets="conditions" if det.get("pets_fee") else None,
                citq=det.get("citq") or "",
                description=det.get("description") or "",
                amenities=det.get("amenities") or [],
                details=details,
                images=det.get("images") or [],
                lat=det.get("lat"),
                lng=det.get("lng"),
            ))
        return listings