# -----------------------------------------------------------------------------
# Lou-Ka — Agrégateur de logements à louer (province de Québec)
# Auteur : Simon-Pierre Boucher — contact@spboucher.ai
# connectors/lafrance_mathieu.py : connecteur Lafrance & Mathieu
#   (lafrance-mathieu.com — Québec, Lévis, Val-Bélair, Beauport, etc.)
#   Page liste /louer-appartement-quebec (+ filtres ?boroughs=N), une annonce
#   par immeuble. La page détail /logement/<id> expose : adresse complète avec
#   code postal, lat/lng (script JSON building-coordinates), commodités et
#   caractéristiques (p.attribute-description : chat accepté, balcon, entrées
#   laveuse-sécheuse/lave-vaisselle…), unités individuelles (numéro, étage,
#   disponibilité, prix), année de construction, téléphone de l'immeuble.
#   Fiches visitées via self.detail() (cache BD, max max_details/sync).
# -----------------------------------------------------------------------------
from __future__ import annotations

import hashlib
import json
import re

from bs4 import BeautifulSoup

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

BASE = "https://lafrance-mathieu.com"
LIST_URL = f"{BASE}/louer-appartement-quebec"

_IMG_RE = re.compile(
    r'https://gilm-site-vitrine-production\.s3\.amazonaws\.com/'
    r'media/real_estate/[^"\s\)]+\.(?:jpg|jpeg|png|webp)')
_POSTAL_RE = re.compile(r"^[A-Z]\d[A-Z]\s?\d[A-Z]\d$")
_PHONE_RE = re.compile(r"\b\d{3}[-. ]\d{3}[-. ]\d{4}\b")


class _DetailBudget(Exception):
    """Budget de fiches détail atteint pour cette synchronisation."""


class LafranceMathieuConnector(BaseConnector):
    source_id = "lafrance_mathieu"
    max_details = 150         # nouvelles fiches détail max par synchronisation

    # -- fiche immeuble ---------------------------------------------------------
    def _fetch_detail(self, url: str) -> dict:
        """Page /logement/<id> -> payload JSON-sérialisable (cache BD)."""
        html = self.get(url).text
        soup = BeautifulSoup(html, "html.parser")
        payload: dict = {}

        # photos de l'immeuble (bucket S3)
        payload["images"] = list(dict.fromkeys(_IMG_RE.findall(html)))

        # lat/lng structurés : <script id="building-coordinates">[{"loc": …}]
        sc = soup.find("script", id="building-coordinates")
        if sc and sc.string:
            try:
                coords = json.loads(sc.string)
                loc = (coords[0] or {}).get("loc") if coords else None
                if loc and len(loc) == 2:
                    payload["lat"] = float(loc[0])
                    payload["lng"] = float(loc[1])
            except (ValueError, TypeError, AttributeError, IndexError):
                pass

        # adresse complète (bloc « À propos de l'immeuble » > Adresse)
        strong = soup.find("strong", string=re.compile(r"^\s*Adresse\s*$"))
        if strong:
            bloc = strong.find_parent("div")
            lignes = []
            for p in bloc.find_all("p") if bloc else []:
                t = " ".join(p.get_text(" ", strip=True).split())
                if not t or t == "Adresse":
                    continue
                t = re.sub(r"[()]", "", t)
                lignes.append(t)
            if lignes:
                payload["address"] = ", ".join(lignes)

        # « Plus d'informations » : étages / unités / année de construction
        for sub in soup.select("p.subtext"):
            label = sub.get_text(" ", strip=True).lower()
            val_el = sub.find_next_sibling("p")
            val = val_el.get_text(" ", strip=True) if val_el else ""
            if "année de construction" in label and val.isdigit():
                payload["construction_year"] = int(val)
            elif "nombre total" in label and val:
                payload["total_units"] = val
            elif "nombre d" in label and val:
                payload["building_floors"] = val

        # commodités + caractéristiques (immeuble, unité, accès et services)
        amenities: list[str] = []
        for p in soup.select("p.attribute-description"):
            label = " ".join(p.get_text(" ", strip=True).split())
            if label and label not in amenities:
                amenities.append(label)
        payload["amenities"] = amenities

        # unités individuelles : numéro (· étage), disponibilité, prix
        unites: list[dict] = []
        vus: set[tuple] = set()
        for hdr in soup.find_all("p", class_="small-header"):
            if hdr.get_text(strip=True).lower() != "unité":
                continue
            row = hdr.find_parent("div", class_="row")
            if row is None:
                continue
            textes = [" ".join(p.get_text(" ", strip=True).split())
                      for p in row.find_all("p")]
            unite = {}
            for i, t in enumerate(textes):
                low = t.lower()
                if low == "unité" and i + 1 < len(textes):
                    unite["numero"] = textes[i + 1]
                elif low == "disponibilité" and i + 1 < len(textes):
                    unite["dispo"] = textes[i + 1]
                elif low == "à partir de" and i + 1 < len(textes):
                    unite["prix"] = textes[i + 1]
            cle = tuple(sorted(unite.items()))
            if unite.get("numero") and cle not in vus:   # modal = doublon
                vus.add(cle)
                unites.append(unite)
        payload["unites"] = unites

        # téléphone spécifique à l'immeuble (panneau « S'informer »)
        panel = soup.select_one(".inquire-step-1")
        if panel:
            m = _PHONE_RE.search(panel.get_text(" ", strip=True))
            if m:
                payload["phone"] = m.group(0).replace(".", "-").replace(" ", "-")

        return payload

    def _enrich(self, lst: Listing) -> None:
        """Complète l'annonce avec la fiche immeuble (via cache self.detail)."""
        key = hashlib.sha1(
            f"{lst.price_label}|{lst.availability}|{'|'.join(lst.amenities)}"
            .encode("utf-8")).hexdigest()

        def fetch_fn():
            if self._detail_fetches >= self.max_details:
                raise _DetailBudget()
            self._detail_fetches += 1
            return self._fetch_detail(lst.url)

        try:
            payload = self.detail(lst.external_id, key, fetch_fn)
        except _DetailBudget:
            return
        if not payload:
            return

        if payload.get("images"):
            lst.images = payload["images"]
        if payload.get("address"):
            lst.address = payload["address"]
        if payload.get("lat") is not None and payload.get("lng") is not None:
            lst.lat, lst.lng = payload["lat"], payload["lng"]
        if payload.get("amenities"):
            # la carte liste n'a que 3-4 icônes ; la fiche est complète
            lst.amenities = payload["amenities"]
        if payload.get("construction_year"):
            lst.details["construction_year"] = payload["construction_year"]
        if payload.get("phone"):
            lst.details.setdefault("contact", {})["phone"] = payload["phone"]

        # animaux : items structurés « Chat accepté » / « Chien accepté »
        amen_txt = " | ".join(payload.get("amenities", [])).lower()
        chat = "chat accepté" in amen_txt or "chats acceptés" in amen_txt
        chien = "chien accepté" in amen_txt or "chiens acceptés" in amen_txt
        if "animaux acceptés" in amen_txt or (chat and chien):
            lst.pets = "oui"
        elif chat or chien:
            lst.pets = "conditions"     # une seule espèce acceptée

        # description : infos immeuble + liste des unités disponibles
        desc_parts: list[str] = []
        infos = []
        if payload.get("construction_year"):
            infos.append(f"construit en {payload['construction_year']}")
        if payload.get("total_units"):
            infos.append(payload["total_units"])
        if infos:
            desc_parts.append("Immeuble " + ", ".join(infos))
        for u in payload.get("unites", []):
            ligne = f"Unité {u.get('numero', '?')}"
            if u.get("dispo"):
                ligne += f" — disponibilité : {u['dispo']}"
            if u.get("prix"):
                ligne += f" — à partir de {u['prix']}"
            desc_parts.append(ligne)
        if desc_parts:
            lst.description = " | ".join(desc_parts)[:600]

        # disponibilité de secours : première unité listée
        if not lst.availability:
            for u in payload.get("unites", []):
                if u.get("dispo"):
                    lst.availability = u["dispo"]
                    break

    # -- contrat ---------------------------------------------------------------
    def fetch(self) -> list[Listing]:
        # 1) Découvrir tous les filtres d'arrondissement sur la page principale
        html = self.get(LIST_URL).text
        boroughs = sorted(set(re.findall(r"\?boroughs=(\d+)", html)))
        pages = [html] + [
            self.get(f"{LIST_URL}/?boroughs={b}").text for b in boroughs
        ]

        # 2) Extraire toutes les cartes (dédupliquées par id)
        listings: dict[str, Listing] = {}
        for page in pages:
            soup = BeautifulSoup(page, "html.parser")
            for card in soup.select('a[href^="/logement/"]'):
                m = re.match(r"/logement/(\d+)", card.get("href", ""))
                if not m:
                    continue
                ext_id = m.group(1)
                if ext_id in listings:
                    continue
                borough_el = card.select_one(".apartment-borough")
                sector = ""
                if borough_el:
                    # "Appartements · Beauport" -> "Beauport"
                    sector = borough_el.get_text(" ", strip=True).split("·")[-1].strip()
                addr_el = card.select_one(".apartment-address")
                infos_el = card.select_one(".apartment-infos")
                avail_el = card.select_one(".apartment-availability")
                infos = infos_el.get_text(" ", strip=True) if infos_el else ""
                amenities = [img.get("alt", "").strip()
                             for img in card.select("img[alt]")
                             if img.get("alt") and img.get("alt") not in
                             ("unit image", "")]
                address = addr_el.get_text(strip=True) if addr_el else ""
                listings[ext_id] = Listing(
                    source=self.source_id,
                    external_id=ext_id,
                    url=f"{BASE}/logement/{ext_id}",
                    title=address or f"Logement {ext_id}",
                    address=address,
                    sector=sector,
                    city=infer_city(sector),
                    unit_type=normalize_unit_type(infos),
                    price=parse_price(infos),
                    price_label=infos,
                    availability=avail_el.get_text(strip=True) if avail_el else "",
                    amenities=amenities,
                )

        # 3) Fiche immeuble : adresse complète, lat/lng, commodités, unités…
        #    via self.detail() (seules les fiches nouvelles/modifiées sont
        #    réellement visitées, max self.max_details par synchronisation)
        self._detail_fetches = 0
        for lst in listings.values():
            try:
                self._enrich(lst)
            except Exception:
                continue

        return list(listings.values())