# -----------------------------------------------------------------------------
# Auto-Ka — Agrégateur de voitures usagées à vendre (province de Québec)
# Auteur : Simon-Pierre Boucher — contact@spboucher.ai
# connectors/autousagee.py : PORTAIL — AutoUsagee.ca (AMVOQ)
#
#   AutoUsagee.ca est la place de marché officielle de l'AMVOQ (Association
#   des marchands de véhicules d'occasion du Québec) : ~12 000 annonces de
#   centaines de petits marchands indépendants dont la plupart n'ont AUCUN
#   site propre connectable — c'est ici que vit leur inventaire (la même
#   plateforme alimente les sites `theme_central` déjà connectés et les
#   images image.autousagee.ca, voir central_dealers.py / yannicklaberge.py).
#
#   Stratégie (HTML rendu serveur ; rate-limit IP agressif : 429 après
#   ~150 requêtes rapprochées — la chaîne de résilience commune escalade
#   alors vers Oxylabs résidentiel -cc-CA, vérifié 2026-08-23) :
#     Liste : GET /recherche?type_id=1&page=N — 15 cartes/page, ~800 pages.
#       Aucun jeton requis pour le GET (le _token CSRF ne sert qu'aux POST
#       AJAX). Chaque carte : URL canonique (/vehicule-usagee/<marchand>/
#       <id_marchand>/<slug>/<id_annonce>), photo 300px (→ 1024px), prix,
#       marque/modèle FR (h2), année (<time datetime>), sous-modèle (h3),
#       km, NOM DU MARCHAND et VILLE — l'annonce est complète sans détail.
#     Détail (plafonné + cache BD, clé statique v1 — prix/km frais viennent
#       de la liste) : specs label→valeur (Marque, Modèle, Sous-modèle,
#       Odomètre, Transmission, Traction, Moteur/Cylindre, Carrosserie,
#       Portières, Couleurs, Numéro d'unité, Numéro de série = VIN, PDSF,
#       Consommation, Energie), description libre, galerie 1024px complète,
#       site web du marchand. Fallback : bloc Contact@Once (data-cao-lpvars)
#       porte year/make/model/VIN/StockID en JSON.
#
#   type_id=1 = « voiture-camion-vus » seulement (2,3,4 = VR/loisirs/lourd,
#   volontairement exclus — motoneiges, roulottes, bateaux mêlés aux motos).
#
#   Recouvrement : quelques marchands AMVOQ déjà connectés en direct (Okaze,
#   theme_central…) republient ici — la dédup VIN inter-sources masque les
#   doublons, priorité au site du marchand.
#
#   Plafonds : AUTOKA_AUTOUSAGEE_MAX (annonces, défaut 0 = tout),
#   AUTOKA_MAX_PAGES (pages liste, tests), AUTOKA_MAX_DETAILS (vraies
#   requêtes détail/sync, défaut 500 — inventaire enrichi progressivement).
# -----------------------------------------------------------------------------
from __future__ import annotations

import json
import os
import re

from ..schema import Vehicle, parse_mileage, parse_price
from .base import BaseConnector

BASE = "https://www.autousagee.ca"
SEARCH = BASE + "/recherche"
IMG_HOST = "image.autousagee.ca"

PAGE_SIZE = 15
MAX_PAGES_HARD = 1000            # garde-fou dur (~800 pages réelles)

_URL_RE = re.compile(
    r"/vehicule-usagee/(?P<dealer_slug>[^/]+)/(?P<dealer_id>\d+)/"
    r"(?P<slug>[^/]+)/(?P<id>\d+)/?$")
_VIN_RE = re.compile(r"^[A-HJ-NPR-Z0-9]{17}$")
_TOTAL_RE = re.compile(r"([\d\s]{1,12})résultats")
_KM_RE = re.compile(r"^[\d\s,.]+\s*km$", re.I)
_CONSO_RE = re.compile(r"Ville\s*:\s*([\d.,]+).*?Autoroute\s*:\s*([\d.,]+)",
                       re.I | re.S)
_CAO_RE = re.compile(r'data-cao-lpvars="([^"]+)"')

# clé de cache détail (statique : specs/galerie quasi immuables ;
# le prix et le km frais viennent toujours de la liste)
_DETAIL_KEY = "v1"


def _clean(text: str | None) -> str:
    return re.sub(r"\s+", " ", str(text or "")).strip()


def _titlecase(text: str) -> str:
    """SALABERRY-DE-VALLEYFIELD -> Salaberry-De-Valleyfield (villes/marchands
    livrés en MAJUSCULES par la plateforme — les accents restent parfois en
    minuscules, ex. « ESTHéTIQUE », d'où le seuil plutôt que isupper())."""
    t = _clean(text)
    letters = [c for c in t if c.isalpha()]
    if letters and sum(c.isupper() for c in letters) / len(letters) >= 0.8:
        return t.title()
    return t


def _max_listings() -> int:
    try:
        return max(0, int(os.environ.get("AUTOKA_AUTOUSAGEE_MAX", "0")))
    except ValueError:
        return 0


class AutoUsageeQuebec(BaseConnector):
    """Portail AutoUsagee.ca — inventaire des marchands AMVOQ du Québec."""

    source_id = "autousagee"
    request_delay = 1.0              # politesse : portail associatif
    max_details = 500                # plafond de vraies requêtes détail / sync

    def __init__(self) -> None:
        super().__init__()
        self.session.headers.update({
            "Accept": "text/html,application/xhtml+xml",
            "Accept-Language": "fr-CA,fr;q=0.9",
        })

    # -- liste ------------------------------------------------------------------
    def _list_page(self, page: int) -> tuple[list[dict], int | None]:
        """Cartes d'une page de résultats + total annoncé par le portail."""
        from bs4 import BeautifulSoup
        html = self.get(SEARCH, params={"type_id": 1, "page": page}).text
        soup = BeautifulSoup(html, "html.parser")

        total = None
        m = _TOTAL_RE.search(soup.get_text(" "))
        if m:
            try:
                total = int(re.sub(r"\s", "", m.group(1)))
            except ValueError:
                pass

        rows: list[dict] = []
        for art in soup.select("article.content_item"):
            link = art.select_one("a.link_img[href]")
            if link is None:
                continue
            um = _URL_RE.search(link["href"].strip())
            if um is None:
                continue
            row: dict = {
                "url": link["href"].strip(),
                "id": um.group("id"),
                "dealer_slug": um.group("dealer_slug"),
                "dealer_id": um.group("dealer_id"),
            }
            img = art.select_one(".img_vehicule img[src]")
            if img and IMG_HOST in img["src"]:
                src = img["src"]
                if src.startswith("//"):
                    src = "https:" + src
                row["image"] = src.replace(f"{IMG_HOST}/300/",
                                           f"{IMG_HOST}/1024/")
            price_el = art.select_one(".prix_voiture span")
            row["price_label"] = _clean(price_el.get_text()) if price_el else ""
            h2 = art.select_one("h2.marque_modele")
            row["title"] = _clean(h2.get_text()) if h2 else ""
            h3 = art.select_one("h3.marque_modele")
            row["trim"] = _clean(h3.get_text()) if h3 else ""
            time_el = art.find("time")
            row["year"] = _clean(time_el.get("datetime")) if time_el else ""

            # specs de carte : 1er span « NNN KM », l'autre = nom du marchand
            for span in art.select(".infos_voiture .spec .info span"):
                text = _clean(span.get_text())
                if not text:
                    continue
                if _KM_RE.match(text):
                    row["km_label"] = text
                elif "dealer" not in row or not row.get("dealer"):
                    row["dealer"] = text
            loc = art.select_one(".infos_voiture_location .info span")
            row["city"] = _clean(loc.get_text()) if loc else ""
            rows.append(row)
        return rows, total

    # -- page détail --------------------------------------------------------------
    def _fetch_detail(self, url: str) -> dict:
        from bs4 import BeautifulSoup
        html = self.get(url).text
        soup = BeautifulSoup(html, "html.parser")
        payload: dict = {}

        # spécifications label -> valeur (Marque, Odomètre, Transmission,
        # Numéro de série…) — apostrophes typographiques normalisées
        specs: dict[str, str] = {}
        for info in soup.select("div.info"):
            lab, span = info.find("label"), info.find("span")
            if lab is None or span is None:
                continue
            key = _clean(lab.get_text()).rstrip(" |:").replace("’", "'")
            val = _clean(span.get_text(" "))
            if key and val and val != "--" and key not in specs:
                specs[key] = val
        payload["specs"] = specs

        # description libre
        desc = soup.select_one("div.desc_container")
        if desc:
            payload["description"] = _clean(desc.get_text(" "))[:4000]

        # galerie complète 1024px (propre à cette annonce)
        listing_id = _URL_RE.search(url)
        lid = listing_id.group("id") if listing_id else ""
        images: list[str] = []
        for m in re.finditer(
                rf"//{IMG_HOST}/1024/{lid}/[^\"'\s\\)]+", html):
            u = "https:" + m.group(0)
            if u not in images:
                images.append(u)
        payload["images"] = images[:30]

        # site web du marchand (logo cliquable de la colonne coordonnées)
        site = soup.select_one(".logo_marchand a[href]")
        if site and site["href"].startswith("http"):
            payload["dealer_site"] = site["href"].strip()

        # fallback Contact@Once : year/make/model/VIN/StockID en JSON
        cao = _CAO_RE.search(html)
        if cao:
            try:
                import html as htmllib
                pairs = json.loads(htmllib.unescape(cao.group(1)))
                payload["cao"] = {p["name"]: str(p.get("value") or "")
                                  for p in pairs if isinstance(p, dict)}
            except (ValueError, KeyError, TypeError):
                pass
        return payload

    # -- contrat --------------------------------------------------------------
    def fetch(self) -> list[Vehicle]:
        cap_listings = _max_listings()
        page_cap = int(os.environ.get("AUTOKA_MAX_PAGES", MAX_PAGES_HARD))
        detail_cap = int(os.environ.get("AUTOKA_MAX_DETAILS", self.max_details))

        rows: list[dict] = []
        seen: set[str] = set()
        page, total = 1, None
        while page <= min(page_cap, MAX_PAGES_HARD):
            batch, page_total = self._list_page(page)
            if not batch:
                break
            total = page_total or total
            for row in batch:
                if row["id"] not in seen:
                    seen.add(row["id"])
                    rows.append(row)
            if cap_listings and len(rows) >= cap_listings:
                rows = rows[:cap_listings]
                break
            if total is not None and page * PAGE_SIZE >= total:
                break
            page += 1

        vehicles: list[Vehicle] = []
        real_fetches = 0
        for row in rows:
            extra: dict = {}
            if real_fetches >= detail_cap:
                # budget épuisé : on sert quand même le cache BD existant
                from .. import db
                if self._detail_con is None:
                    self._detail_con = db.connect()
                extra = db.get_cached_detail(self._detail_con, self.source_id,
                                             row["id"], _DETAIL_KEY) or {}
            else:
                before = self._last_request
                try:
                    extra = self.detail(row["id"], _DETAIL_KEY,
                                        lambda u=row["url"]:
                                        self._fetch_detail(u))
                except Exception:
                    extra = {}   # détail indisponible : données liste suffisent
                if self._last_request != before:
                    real_fetches += 1
            veh = self._to_vehicle(row, extra)
            if veh is not None:
                vehicles.append(veh)
        return vehicles

    # -- carte + détail -> Vehicle ---------------------------------------------
    def _to_vehicle(self, row: dict, extra: dict) -> Vehicle | None:
        title = row.get("title") or ""
        if not title:
            return None
        specs: dict = extra.get("specs") or {}
        cao: dict = extra.get("cao") or {}

        year = None
        for raw in (row.get("year"), cao.get("year")):
            try:
                year = int(str(raw)[:4])
                break
            except (TypeError, ValueError):
                continue

        price = parse_price(row.get("price_label") or "")
        km = parse_mileage(row.get("km_label") or "") \
            or parse_mileage(specs.get("Odomètre") or "")

        make = _clean(specs.get("Marque") or cao.get("make") or "")
        model = _clean(specs.get("Modèle") or cao.get("model") or "")
        trim = _clean(specs.get("Sous-modèle") or row.get("trim") or "")

        vin = _clean(specs.get("Numéro de série") or cao.get("VIN") or "").upper()
        if not _VIN_RE.match(vin):
            vin = ""

        engine = ""
        litres = specs.get("Moteur") or ""
        if re.fullmatch(r"\d+(\.\d+)?", litres):
            cyl = specs.get("Cylindre") or ""
            engine = f"{litres}L" + (f" {cyl} cyl." if cyl.isdigit() else "")

        doors = None
        try:
            doors = int(specs["Nombre de portières"])
        except (KeyError, ValueError):
            pass

        images = [u for u in (extra.get("images") or []) if isinstance(u, str)]
        if not images and row.get("image"):
            images = [row["image"]]

        details: dict = {}
        msrp = parse_price(specs.get("Prix neuf (PDSF)") or "")
        if msrp and (not price or msrp > price):
            details["msrp"] = msrp
        conso = _CONSO_RE.search(specs.get("Consommation (Litre / 100 Km)")
                                 or "")
        if conso:
            details["fuel_city_l_100km"] = conso.group(1).replace(",", ".")
            details["fuel_hwy_l_100km"] = conso.group(2).replace(",", ".")
        if extra.get("dealer_site"):
            details["dealer_site"] = extra["dealer_site"]
        details["dealer_slug"] = row["dealer_slug"]
        details["dealer_amvoq_id"] = row["dealer_id"]

        return Vehicle(
            source=self.source_id,
            external_id=row["id"],
            url=row["url"],
            title=f"{title} {year or ''}".strip(),
            make=make,
            model=model,
            trim=trim,
            year=year,
            price=price,
            price_label=row.get("price_label") or "",
            mileage_km=km,
            mileage_label=row.get("km_label") or "",
            transmission=_clean(specs.get("Transmission") or ""),
            fuel=_clean(specs.get("Energie") or specs.get("Énergie") or ""),
            drivetrain=_clean(specs.get("Traction") or ""),
            body_type=_clean(specs.get("Carrosserie") or ""),
            exterior_color=_clean(specs.get("Couleur extérieur") or ""),
            interior_color=_clean(specs.get("Couleur intérieur") or ""),
            engine=engine,
            doors=doors,
            vin=vin,
            stock_number=_clean(specs.get("Numéro d'unité")
                                or cao.get("StockID") or ""),
            dealer_name=_titlecase(row.get("dealer") or ""),
            city=_titlecase(row.get("city") or ""),
            description=extra.get("description") or "",
            details=details,
            images=images[:30],
        )