# -----------------------------------------------------------------------------
# Lou-Ka — Location court terme
# connectors/origine.py : Ôrigine artisans hôteliers (originehotels.com)
#   — ex-Hôtellerie Champêtre : réseau de 35 hôtels et auberges indépendants
#   dans 15 régions touristiques du Québec. Réservation en direct sur la fiche.
#
# Méthode : site Drupal, HTML serveur, accessible en direct (le sitemap ne
#   liste pas les fiches → l'annuaire /fr/hotels-auberges fournit l'inventaire,
#   liens /fr/hotels-auberges/<région>/<slug>). La fiche (cache détail « v1 »)
#   est très balisée :
#     h1 (titre, div .visually-hidden à écarter), .header-hotel-place
#     (« La Malbaie - Charlevoix » → ville + région), .hotel-map-address h4
#     (adresse civique), .hotel-map-citq (« Numéro CITQ: 012272 »),
#     .hotel-map-view (data-lat/data-lng), .hotel-map-infos (téléphone, site
#     web de l'hôtel), .text-cta-head/.text-cta-content (présentation),
#     .activity-list-services-item (« Services offerts »),
#     .utility-list-item (types de chambre — leur div prix est toujours vide).
#   PRIX : les seuls montants de la fiche sont les forfaits de l'hôtel
#     (.package-item-v2 : « Tarif du jour 209,00$ », « Évasion | 2 nuits
#     698,00$ »…). price_night = minimum des forfaits ramenés à la nuit
#     (« | N nuits » → ÷ N) en écartant les échelles de rabais long séjour
#     (« 3e nuitée à 50% », « 5 nuits et plus… ») dont le total est ambigu.
#   PHOTOS : /sites/default/files/styles/<style>/public/ dans les répertoires
#     hotel-gallerie (héro), galerie-texte-image et hotel-chamgres-et-services
#     (sic) ; on écarte forfaits-hotels-packages-galerie et order_email_hotels
#     (images d'AUTRES hôtels / bons de commande). Dédoublonnage sur le nom de
#     fichier (variantes .webp/.jpeg + styles 1x/1.5x/2x), on garde la 2x.
#   capacity/bedrooms restent None (hôtel : les unités varient) ; les types de
#   chambre vont dans details["room_types"].
# -----------------------------------------------------------------------------
from __future__ import annotations

import re
import sys
from urllib.parse import unquote

from bs4 import BeautifulSoup

from ...normalize import strip_accents
from ..schema import StListing, normalize_region
from .base import StConnector

BASE = "https://originehotels.com"
INDEX = BASE + "/fr/hotels-auberges"

# liens de fiche dans l'annuaire : /fr/hotels-auberges/<région>/<slug>
_FICHE_RE = re.compile(r'href="(/fr/hotels-auberges/([\w-]+)/([\w-]+))"')

# segments de région d'URL que normalize_region ne résout pas seul
_URL_REGIONS = {
    "cote-nord-duplessis": "Côte-Nord",
    "cote-nord-manicouagan": "Côte-Nord",
    "cantons-de-l-est": "Cantons-de-l'Est",
    "chaudiere-appalaches": "Chaudière-Appalaches",
}

# répertoires Drupal des photos propres à l'hôtel (héro, galerie, chambres)
_IMG_RE = re.compile(
    r'(/sites/default/files/styles/([^/"]+)/public/'
    r'(?:hotel-gallerie|galerie-texte-image|hotel-chamgres-et-services)/'
    r'[^"\s,]+?\.(?:jpe?g|webp|png)(?:\?itok=[\w-]+)?)', re.I)

# forfaits à écarter du calcul de prix : échelles de rabais long séjour
_LADDER_RE = re.compile(r"\d+\s*e\s+nuit|nuits?\s+et\s+plus", re.I)
_NIGHTS_RE = re.compile(r"\|\s*(\d+)\s+nuits", re.I)
_MONEY_RE = re.compile(r"(\d[\d\s ]*?)(?:\s*[.,]\s*(\d{1,2}))?\s*\$")


def _txt(node) -> str:
    return re.sub(r"\s+", " ", node.get_text(" ", strip=True)) if node else ""


def _money(raw: str) -> float | None:
    m = _MONEY_RE.search(raw or "")
    if not m:
        return None
    val = float(re.sub(r"[\s ]", "", m.group(1)) + "." + (m.group(2) or "0"))
    return val if 0 < val < 100000 else None


class Origine(StConnector):
    source_id = "origine"

    # -- inventaire (annuaire) -------------------------------------------------
    def _fiches(self) -> list[tuple[str, str, str]]:
        """[(slug, url fiche, segment région d'URL)] dans l'ordre d'affichage."""
        html = self.get(INDEX).text
        fiches, vus = [], set()
        for path, region_seg, slug in _FICHE_RE.findall(html):
            if slug in vus or slug == "fiche-de-satisfaction":
                continue
            vus.add(slug)
            fiches.append((slug, BASE + path, region_seg))
        return fiches

    # -- page fiche → dict sérialisable (cache détail) --------------------------
    def _detail(self, url: str) -> dict:
        html = self.get(url).text
        soup = BeautifulSoup(html, "html.parser")
        d: dict = {}

        h1 = soup.find("h1")
        if h1 is not None:
            for hidden in h1.select(".visually-hidden"):
                hidden.decompose()
            d["title"] = _txt(h1)

        # « La Malbaie - Charlevoix » → ville + région touristique
        place = _txt(soup.select_one(".header-hotel-place"))
        if place:
            parts = re.split(r"\s+-\s+", place)
            if len(parts) >= 2:
                d["city"], d["region"] = parts[0], parts[-1]
            else:
                d["city"] = place

        d["address"] = _txt(soup.select_one(".hotel-map-address h4"))

        m = re.search(r"CITQ\D{0,12}(\d{6})",
                      _txt(soup.select_one(".hotel-map-citq")))
        if m:
            d["citq"] = m.group(1)

        view = soup.select_one(".hotel-map-view")
        if view is not None:
            try:
                d["lat"] = float(view.get("data-lat"))
                d["lng"] = float(view.get("data-lng"))
            except (TypeError, ValueError):
                pass

        infos = soup.select_one(".hotel-map-infos")
        if infos is not None:
            tel = infos.select_one("a.phone-link")
            site = infos.select_one("a.website-link")
            if tel is not None:
                d["phone"] = _txt(tel)
            if site is not None and site.get("href"):
                d["website"] = site["href"].strip()

        # présentation : accroche + texte du premier bloc text-cta
        morceaux = [_txt(soup.select_one(".text-cta-head"))]
        cont = soup.select_one(".text-cta-content")
        if cont is not None:
            morceaux.append("\n".join(
                t for p in cont.find_all(["p", "li", "h3", "h4"])
                if (t := re.sub(r"\s+", " ", p.get_text(" ", strip=True))))
                or _txt(cont))
        d["description"] = re.sub(r"\*{2,}", "",
                                  "\n".join(m for m in morceaux if m)).strip()

        # « Services offerts »
        amen: list[str] = []
        for li in soup.select(".activity-list-services-item"):
            t = _txt(li)
            if t and t not in amen:
                amen.append(t)
        d["amenities"] = amen

        # types de chambre (leur div prix est vide sur tout le réseau)
        rooms: list[str] = []
        for hd in soup.select(".utility-list-item .utility-list-item-heading"):
            t = _txt(hd)
            if t and t not in rooms:
                rooms.append(t)
        d["room_types"] = rooms

        # forfaits de l'hôtel → prix « à partir de » ramené à la nuit
        best = None
        for item in soup.select(".package-item-v2"):
            titre = _txt(item.select_one(".package-item-v2-heading"))
            if _LADDER_RE.search(titre):
                continue
            prix = _money(_txt(item.select_one(".package-item-v2-price-value")))
            if prix is None:
                continue
            m = _NIGHTS_RE.search(titre)
            if m and int(m.group(1)) > 0:
                prix = round(prix / int(m.group(1)), 2)
            if best is None or prix < best:
                best = prix
        if best is not None:
            d["price_night"] = best

        # photos : dédoublonnage nom de fichier, préférence au style 2x
        imgs: dict[str, tuple[int, str]] = {}
        for u, style in _IMG_RE.findall(html):
            nom = unquote(u.split("?")[0].rsplit("/", 1)[-1])
            nom = re.sub(r"\.\w+$", "", nom).lower()
            score = 3 if style.endswith("_2x") else \
                2 if style.endswith("_1_5x") else 1
            if ".webp" not in u.lower():
                score += 1          # à score de style égal, préférer le jpeg
            if nom not in imgs or score > imgs[nom][0]:
                imgs[nom] = (score, BASE + u)
        d["images"] = [u for _, u in imgs.values()][:40]
        return d

    # -- contrat ---------------------------------------------------------------
    def fetch(self) -> list[StListing]:
        listings: list[StListing] = []
        for slug, url, region_seg in self._fiches():
            try:
                d = self.detail(slug, "v1", lambda u=url: self._detail(u))
            except Exception as exc:   # une fiche cassée ≠ inventaire perdu
                print(f"[origine] {slug} : {exc}", file=sys.stderr)
                d = {}
            if not d.get("title"):
                continue

            titre = d["title"]
            ptype = ("Auberge" if re.search(r"\bauberge\b",
                                            strip_accents(titre).lower())
                     else "Hôtel")

            region = normalize_region(d.get("region", ""))
            if not region:
                region = _URL_REGIONS.get(
                    region_seg, normalize_region(region_seg.replace("-", " ")))

            prix = d.get("price_night")
            details = {"room_types": d.get("room_types") or []}
            for k in ("phone", "website"):
                if d.get(k):
                    details[k] = d[k]

            listings.append(StListing(
                source=self.source_id,
                external_id=slug,               # slug de la fiche, stable
                url=url,
                title=titre,
                property_type=ptype,
                address=d.get("address", ""),
                city=d.get("city", ""),
                region=region,
                price_night=prix,
                price_label=(f"À partir de {prix:g} $ / nuit" if prix else ""),
                citq=d.get("citq", ""),
                description=d.get("description", "")[:5000],
                amenities=d.get("amenities") or [],
                details=details,
                images=d.get("images") or [],
                lat=d.get("lat"),
                lng=d.get("lng"),
            ))
        return listings