# -----------------------------------------------------------------------------
# Sorti-Ka — Agrégateur de sorties & événements (province de Québec)
# Auteur : Simon-Pierre Boucher — contact@spboucher.ai
# connectors/longueuil.py : connecteur Ville de Longueuil — nouveau portail
#   Source    : longueuil.quebec/fr/evenements (portail Nuxt.js, rendu serveur).
#   Extraction: cartes <article class="event__item"> de la page liste —
#               <time datetime="2026-08-29T10:00:00-04:00"> (date + heure
#               locales, parfois début ET fin), titre + lien, extrait.
#               Enrichissement par fiche (incrémental, cache disque
#               data/longueuil_cache.json, plafond LGL_FICHE_MAX/sync,
#               re-visite 30 j) : adresse civique, code postal, municipalité
#               extraits de l'état Nuxt (address_line1/postal_code/locality).
#               GPS absent de la source → géocodeur central (salle + ville).
#   Accès     : portail municipal public, rendu serveur — GET directs
#               throttlés, identification honnête. (L'ancien jeu « événements »
#               sur Données Québec est périmé depuis 2017 — vérifié 2026-08-17 ;
#               ce portail est la source vivante.)
#   Prix      : non publié dans la liste → jamais inventé.
# -----------------------------------------------------------------------------
from __future__ import annotations

import os
import re
import time

from ..normalize import clean_text, parse_date_iso, parse_time
from ..schema import Event
from .base import BaseConnector

BASE = "https://longueuil.quebec"
LIST_URL = BASE + "/fr/evenements"
LGL_FICHE_MAX = int(os.environ.get("LGL_FICHE_MAX", "30"))   # fiches/sync
REFRESH_AFTER = 30 * 86400        # l'adresse d'un événement bouge rarement

_ARTICLE_RE = re.compile(r"<article class=\"event__item\".*?</article>", re.S)
_TIME_RE = re.compile(r"datetime=\"([^\"]+)\"")
_LINK_RE = re.compile(r"href=\"(/fr/evenements/[^\"]+)\"")
_TITLE_RE = re.compile(r"link__txt[^>]*>\s*(.*?)\s*</span>", re.S)
_EXCERPT_RE = re.compile(r"event__excerpt[^>]*>\s*(.*?)\s*</p>", re.S)

# champs de l'état Nuxt des fiches (valeurs entre guillemets, échappées JS)
_ADDR_RE = re.compile(r"address_line1:\"([^\"]*)\"")
_POSTAL_RE = re.compile(r"postal_code:\"([^\"]*)\"")
_LOCALITY_RE = re.compile(r"locality:\"([^\"]*)\"")
# visuel de la fiche : URL mediaImages du CMS dans l'état Nuxt (styles
# front_medium_16_9 / front_large_21_9), échappée /
_IMG_RES = (
    re.compile(r"\"(https:\\u002F\\u002Fcms\.longueuil\.quebec\\u002Fsites"
               r"[^\"]*?front_medium_16_9[^\"]*?)\""),
    re.compile(r"\"(https:\\u002F\\u002Fcms\.longueuil\.quebec\\u002Fsites"
               r"[^\"]*?front_large_21_9[^\"]*?)\""),
)


def _js_str(raw: str) -> str:
    """Décode les échappements JS (\\u00e9 → é) d'une valeur d'état Nuxt."""
    if "\\u" in raw or "\\/" in raw:
        try:
            return raw.encode("utf-8").decode("unicode_escape")
        except Exception:
            return raw
    return raw


class LongueuilConnector(BaseConnector):
    source_id = "longueuil"
    request_delay = 0.8

    def _cards(self, html: str) -> list[dict]:
        rows = []
        for block in _ARTICLE_RE.findall(html):
            link = _LINK_RE.search(block)
            title = _TITLE_RE.search(block)
            times = _TIME_RE.findall(block)
            if not (link and title and times):
                continue
            excerpt = _EXCERPT_RE.search(block)
            path = link.group(1)
            rows.append({
                "url": BASE + path,
                "external_id": path.rstrip("/").rsplit("/", 1)[-1],
                "title": clean_text(re.sub(r"<[^>]+>", "", title.group(1))),
                "description": clean_text(re.sub(
                    r"<[^>]+>", "", excerpt.group(1))) if excerpt else "",
                "start": times[0],
                "end": times[-1],
            })
        return rows

    def _enrich_addresses(self, rows: list[dict]) -> None:
        """Adresse/ville depuis la fiche (état Nuxt) — incrémental, plafonné."""
        cache = self.load_cache()
        now = time.time()
        current = {r["url"] for r in rows}
        cache = {u: c for u, c in cache.items() if u in current}

        to_fetch = sorted(
            (u for u in current
             if u not in cache
             or "image" not in cache[u]      # entrées d'avant la Phase 2
             or now - cache[u].get("fetched_at", 0) > REFRESH_AFTER),
            key=lambda u: cache.get(u, {}).get("fetched_at", 0))[:LGL_FICHE_MAX]

        def worker(url, session):
            html = session.get(url, timeout=20).text
            addr = _ADDR_RE.search(html)
            postal = _POSTAL_RE.search(html)
            loc = _LOCALITY_RE.search(html)
            image = ""
            for img_re in _IMG_RES:
                m = img_re.search(html)
                if m:
                    image = _js_str(m.group(1))
                    break
            return {"address": _js_str(addr.group(1)) if addr else "",
                    "postal": _js_str(postal.group(1)) if postal else "",
                    "city": _js_str(loc.group(1)) if loc else "",
                    "image": image}

        for url, info in self.fetch_many(to_fetch, worker, max_workers=4).items():
            if info is not None:
                info["fetched_at"] = now
                cache[url] = info
        self.save_cache(cache)
        for r in rows:
            info = cache.get(r["url"]) or {}
            r["address"] = info.get("address", "")
            r["postal"] = info.get("postal", "")
            r["city"] = info.get("city") or "Longueuil"
            r["image"] = info.get("image", "")

    def fetch(self) -> list[Event]:
        rows = self._cards(self.get(LIST_URL).text)
        self._enrich_addresses(rows)
        events: list[Event] = []
        seen: set[str] = set()
        for r in rows:
            if r["external_id"] in seen:
                continue
            seen.add(r["external_id"])
            start_date = parse_date_iso(r["start"])
            end_date = parse_date_iso(r["end"])
            start_time = parse_time(r["start"])
            if start_time == "00:00":       # minuit = « toute la journée »
                start_time = None
            end_time = parse_time(r["end"]) if r["end"] != r["start"] else None
            if end_time == "00:00":
                end_time = None
            events.append(Event(
                source=self.source_id,
                external_id=r["external_id"],
                url=r["url"],
                title=r["title"],
                description=r["description"],
                raw_categories=[r["title"]],
                address=r.get("address", ""),
                postal_code=r.get("postal", ""),
                city=r.get("city", "Longueuil"),
                region="Montérégie",
                start_date=start_date,
                start_time=start_time,
                end_date=end_date or start_date,
                end_time=end_time,
                image=r.get("image", ""),
            ))
        return events