# -----------------------------------------------------------------------------
# Lou-Ka — Agrégateur de logements à louer (province de Québec)
# Auteur : Simon-Pierre Boucher — contact@spboucher.ai
# connectors/logisco.py : connecteur Logisco (logisco.com)
#   Site rendu serveur. Crawl : page liste principale (+ pages villes) pour
#   découvrir les pages projets, puis extraction des unités disponibles
#   (cartes .unitCard) sur chaque page projet. Une annonce par unité.
#   Chaque page unité (mise en cache via self.detail, plafond 150 vraies
#   requêtes/sync) apporte : JSON-LD (adresse avec no d'unité + code postal,
#   étage, téléphone, plan de l'unité), superficie/étage/dispo structurés
#   (sommaire .unitHeader) et les 4 sections de commodités (Inclusions,
#   Particularités, Services offerts, Espaces communs).
#   Villes retenues : Québec, Lévis, Saint-Augustin-de-Desmaures
#   (Donnacona et autres villes hors région exclues).
# -----------------------------------------------------------------------------
from __future__ import annotations

import hashlib
import html as htmllib
import json
import re
from urllib.parse import urljoin

from bs4 import BeautifulSoup

from ..schema import Listing, infer_city, normalize_unit_type, parse_price
from .base import BaseConnector

BASE = "https://logisco.com"
LIST_URL = f"{BASE}/fr/appartements-a-louer"

# villes de la région Québec/Lévis retenues (segment d'URL -> nom de ville)
CITY_MAP = {
    "quebec": "Québec",
    "levis": "Lévis",
    "saint-augustin-de-desmaures": "Saint-Augustin-de-Desmaures",
}

PROJECT_HREF_RE = re.compile(
    r'href="(https://logisco\.com/fr/appartements-a-louer/([a-z0-9\-]+(?:/[a-z0-9\-]+)*))"'
)
STATIC_IMG_RE = re.compile(
    r'(?:src|data-src|href)="(https://logisco\.com/static/[^"]+\.(?:webp|jpe?g|png))"'
)
EXCLUDE_UNIT_RE = re.compile(r"stationnement|parking|rangement|commercial|garage", re.I)


def _text(el, sep: str = " ") -> str:
    """Texte d'un élément, robuste aux <template> Vue du site.

    bs4 classe les chaînes situées sous une balise <template> comme
    TemplateString et les exclut de get_text() par défaut ; or les cartes
    d'unités de Logisco se retrouvent imbriquées sous de telles balises.
    `types=None` force la prise en compte de toutes les chaînes.
    """
    if el is None:
        return ""
    return el.get_text(sep, strip=True, types=None)


class _DetailBudget(Exception):
    """Plafond de vraies requêtes de pages unité atteint pour cette synchro."""


class LogiscoConnector(BaseConnector):
    source_id = "logisco"
    request_delay = 0.6
    max_projects = 40         # garde-fou : nb max de pages projets crawlées
    max_project_imgs = 15     # nb max de photos projet par annonce
    max_details = 150         # plafond de VRAIES requêtes de pages unité/sync

    def __init__(self) -> None:
        super().__init__()
        self._detail_fetches = 0

    # -- découverte des pages projets ----------------------------------------
    def _discover_projects(self) -> dict[str, tuple[str, str]]:
        """Retourne {url_projet: (segment_ville, segment_secteur)}."""
        pages = []
        try:
            pages.append(self.get(LIST_URL).text)
        except Exception:
            pass
        for city in CITY_MAP:
            try:
                pages.append(self.get(f"{LIST_URL}/{city}").text)
            except Exception:
                continue

        projects: dict[str, tuple[str, str]] = {}
        for html in pages:
            for url, path in PROJECT_HREF_RE.findall(html):
                parts = path.split("/")
                city = parts[0]
                if city not in CITY_MAP:
                    continue  # ex. Donnacona et autres villes hors région
                # quebec/levis : ville/secteur/projet (3 segments)
                # saint-augustin : ville/projet (2 segments)
                if city in ("quebec", "levis"):
                    if len(parts) != 3:
                        continue
                    sector = parts[1]
                elif len(parts) == 2:
                    sector = city
                else:
                    continue
                projects.setdefault(url, (city, sector))
        return projects

    # -- extraction d'une page projet -----------------------------------------
    def _project_images(self, html: str) -> list[str]:
        """Photos du projet (sans logos ni plans d'unités), dédupliquées."""
        imgs = []
        for u in STATIC_IMG_RE.findall(html):
            name = u.rsplit("/", 1)[-1].lower()
            if name.startswith(("logo-", "plan-")) or "logo" in name.split("-")[:1]:
                continue
            imgs.append(u)
        return list(dict.fromkeys(imgs))[: self.max_project_imgs]

    def fetch(self) -> list[Listing]:
        projects = self._discover_projects()
        listings: dict[str, Listing] = {}

        for i, (proj_url, (city_seg, sector_seg)) in enumerate(projects.items()):
            if i >= self.max_projects:
                break
            try:
                html = self.get(proj_url).text
            except Exception:
                continue
            soup = BeautifulSoup(html, "html.parser")

            project_name = ""
            h1 = soup.find("h1")
            if h1:
                # retirer le slogan SEO : « District GC • Appartements … »,
                # « L'AMALGAM - Grands appartements à louer … »
                project_name = re.split(r"\s+[•|–—]\s+|\s+-\s+", _text(h1))[0].strip()
            proj_imgs = self._project_images(html)
            cards = soup.select("li.unitCard, .unitCard")
            n_dispo = len(cards)

            for card in cards:
                try:
                    unit_gtm_type = (card.get("data-gtm-unit-type") or "").upper()
                    if unit_gtm_type and unit_gtm_type != "APARTMENT":
                        continue
                    link = card.select_one("a.unitCard-link")
                    if not link or not link.get("href"):
                        continue
                    url = urljoin(BASE, link["href"])

                    ext_id = card.get("data-gtm-unit-id") or ""
                    if not ext_id:
                        ext_id = url.rstrip("/").rsplit("/", 1)[-1]

                    title = _text(card.select_one(".unitCard-title"))
                    if EXCLUDE_UNIT_RE.search(title):
                        continue

                    address = _text(card.select_one(".unitCard-address"))

                    # secteur : « Desjardins, Lévis » -> « Desjardins »
                    sector = ""
                    map_el = card.select_one(".unitCard-address--map")
                    if map_el:
                        sector = _text(map_el).split(",")[0].strip()
                    if not sector:
                        sector = sector_seg.replace("-", " ").title()

                    sizes = [_text(s) for s in card.select(".unitCard-size")]
                    unit_type = ""
                    for s in sizes:
                        if re.match(r"^\d\s*(?:1/2|½)|^(studio|loft)", s, re.I):
                            unit_type = s
                            break

                    price_label = _text(card.select_one(".unitCard-price"))

                    availability = _text(card.select_one(".unitCard-dispo"))

                    amenities = list(dict.fromkeys(
                        t for t in (_text(sr) for sr in
                                    card.select(".unitCard-services .sr-only"))
                        if t
                    ))

                    images = []
                    img_el = card.select_one("img.unitCard-image")
                    if img_el and img_el.get("src"):
                        images.append(urljoin(BASE, img_el["src"]))
                    images += [u for u in proj_imgs if u not in images]

                    extra = ", ".join(s for s in sizes if s != unit_type)
                    desc_bits = []
                    if project_name:
                        desc_bits.append(f"Projet {project_name}")
                    if extra:
                        desc_bits.append(extra)
                    desc_bits.append(f"{n_dispo} unité(s) disponible(s) dans le projet")

                    default_city = CITY_MAP.get(city_seg, "Québec")
                    full_title = (f"{project_name} — {title}"
                                  if project_name and title else title or project_name)

                    lst = Listing(
                        source=self.source_id,
                        external_id=str(ext_id),
                        url=url,
                        title=full_title or f"Unité {ext_id}",
                        address=address,
                        sector=sector,
                        city=infer_city(sector, default=default_city),
                        unit_type=normalize_unit_type(unit_type),
                        price=parse_price(price_label),
                        price_label=price_label,
                        availability=availability,
                        description=" — ".join(desc_bits)[:600],
                        amenities=amenities,
                        images=images,
                    )

                    # page unité (avec cache BD) : adresse complète, superficie,
                    # étage, téléphone, plan, sections de commodités
                    # préfixe v2 = version de l'extraction (invalide le cache)
                    key = "v2:" + hashlib.sha1(" | ".join(
                        [title, address, price_label, availability]
                        + sizes + amenities).encode("utf-8")).hexdigest()
                    try:
                        payload = self.detail(
                            str(ext_id), key, lambda u=url: self._fetch_unit(u))
                    except _DetailBudget:
                        payload = {}      # plafond atteint : complété au prochain sync
                    except Exception:
                        payload = {}
                    self._apply_unit(lst, payload)

                    listings[ext_id] = lst
                except Exception:
                    continue  # ne jamais planter sur une carte malformée

        return list(listings.values())

    # -- page unité ------------------------------------------------------------
    def _fetch_unit(self, url: str) -> dict:
        if self._detail_fetches >= self.max_details:
            raise _DetailBudget(url)
        self._detail_fetches += 1
        soup = BeautifulSoup(self.get(url).text, "html.parser")
        out: dict = {}

        # JSON-LD « apartment » : adresse (no d'unité + code postal), étage,
        # téléphone du bureau de location, plan de l'unité
        for sc in soup.find_all("script", type="application/ld+json"):
            try:
                data = json.loads(sc.string or "")
            except Exception:
                continue
            if not (isinstance(data, dict)
                    and str(data.get("@type", "")).lower() == "apartment"):
                continue
            addr = data.get("address") or {}
            # certaines valeurs JSON-LD contiennent des entités HTML (&#039;)
            street = htmllib.unescape((addr.get("streetAddress") or "")).strip()
            if street:
                bits = [street,
                        htmllib.unescape((addr.get("addressLocality") or "")).strip(),
                        (addr.get("postalCode") or "").strip()]
                out["address"] = ", ".join(b for b in bits if b)
            tel = re.sub(r"\D", "", str(data.get("telephone") or ""))
            tel = tel[1:] if len(tel) == 11 and tel.startswith("1") else tel
            if len(tel) == 10:
                out["phone"] = f"{tel[:3]}-{tel[3:6]}-{tel[6:]}"
            fl = str(data.get("floorLevel") or "").strip()
            if fl.isdigit():
                out["floor"] = int(fl)
            img = data.get("image") or ""
            if isinstance(img, str) and img.startswith("http"):
                out["plan"] = img
            break

        # sommaire de l'unité : superficie, étage, disponibilité (structurés)
        for info in soup.select(".unitHeader-info"):
            label = _text(info.select_one(".unitHeader-infoLabel")).lower()
            value = _text(info.select_one(".unitHeader-infoValue"))
            if "superficie" in label:
                m = re.search(r"([\d\s ]+)\s*pi", value)
                if m:
                    try:
                        v = float(re.sub(r"[\s ]", "", m.group(1)))
                        if 80 <= v <= 20000:
                            out["area_sqft"] = v
                    except ValueError:
                        pass
            elif "tage" in label and re.fullmatch(r"\d{1,2}", value):
                out["floor"] = int(value)
            elif "disponibilit" in label and value:
                out["availability"] = value

        # sections : Inclusions / Particularités / Services offerts /
        # Espaces communs (items texte, fidèles — « Rangement supplémentaire ($) »)
        amen: list[str] = []
        for item in soup.select(".projectServices-listItem"):
            t = _text(item)
            if t:
                amen.append(t)
        out["amenities"] = list(dict.fromkeys(amen))[:40]
        return out

    def _apply_unit(self, lst: Listing, payload: dict) -> None:
        if not payload:
            return
        if payload.get("address"):
            lst.address = payload["address"]
        if payload.get("area_sqft"):
            lst.area_sqft = payload["area_sqft"]
        if payload.get("availability") and not lst.availability:
            lst.availability = payload["availability"]
        if payload.get("floor") is not None:
            lst.details["floor"] = payload["floor"]
        if payload.get("phone"):
            lst.details.setdefault("contact", {})["phone"] = payload["phone"]
        for a in payload.get("amenities", []):
            if a not in lst.amenities:
                lst.amenities.append(a)
        plan = payload.get("plan")
        if plan and plan not in lst.images:
            lst.images.append(plan)