# -----------------------------------------------------------------------------
# Sorti-Ka — Agrégateur de sorties & événements (province de Québec)
# Auteur : Simon-Pierre Boucher — contact@spboucher.ai
# seo.py : référencement — SSR léger des fiches événement, robots, sitemaps
#
# Principe (patron Lou-Ka seo.py) : pour chaque route publique, le serveur
# renvoie le MÊME index.html que le frontend, mais avec un <head> unique
# (title, description, canonical, og:, JSON-LD Event) et le contenu essentiel
# en HTML dans <div id="app">. Les moteurs voient une page complète sans
# exécuter JavaScript ; le frontend, en se montant, prend le relais.
# -----------------------------------------------------------------------------
from __future__ import annotations

import html as H
import json
from pathlib import Path

from fastapi import APIRouter, HTTPException
from fastapi.responses import HTMLResponse, PlainTextResponse, Response

from . import db

router = APIRouter()

ROOT = Path(__file__).resolve().parent.parent
FRONTEND_INDEX = ROOT / "frontend" / "index.html"

BASE_URL = "https://www.sorti-ka.com"
SITE_NAME = "Sorti-Ka"
OG_IMAGE = f"{BASE_URL}/og.png"
# balises image de partage par défaut (og.png 1200×630 « Sorti-Ka — par Groupe KA »)
OG_IMAGE_TAGS = (
    f'<meta property="og:image" content="{OG_IMAGE}">\n'
    '<meta property="og:image:width" content="1200">\n'
    '<meta property="og:image:height" content="630">\n'
    '<meta name="twitter:card" content="summary_large_image">\n'
    f'<meta name="twitter:image" content="{OG_IMAGE}">'
)
SITEMAP_CHUNK = 10000

_SRC_LABELS = {
    "sitq": "SIT Québec — Ministère du Tourisme", "montreal": "Ville de Montréal",
    "laval": "Ville de Laval", "lepointdevente": "Le point de vente",
    "evenko": "evenko", "atuvu": "Atuvu.ca", "lavitrine": "La Vitrine",
    "sherbrooke": "Ville de Sherbrooke", "brossard": "Ville de Brossard",
    "ticketmaster": "Ticketmaster", "bandsintown": "Bandsintown",
}


def _tz_offset(day: str) -> str:
    """Décalage ISO du Québec pour une date donnée ("-04:00" ou "-05:00")."""
    from datetime import datetime
    from zoneinfo import ZoneInfo
    try:
        dt = datetime.fromisoformat(day).replace(tzinfo=ZoneInfo("America/Montreal"))
        off = dt.utcoffset()
        sign = "-" if off.total_seconds() < 0 else "+"
        secs = abs(int(off.total_seconds()))
        return f"{sign}{secs // 3600:02d}:{(secs % 3600) // 60:02d}"
    except Exception:
        return "-05:00"


def _e(s) -> str:
    return H.escape(str(s or ""), quote=True)


def _render(head: str, ssr_body: str) -> HTMLResponse:
    """index.html avec <head> réécrit et contenu SSR injecté dans #ssr."""
    import re
    tpl = FRONTEND_INDEX.read_text(encoding="utf-8")
    # retirer title/description/canonical par défaut (remplacés par le SSR)
    tpl = re.sub(r"<title>.*?</title>\s*", "", tpl, count=1, flags=re.S)
    tpl = re.sub(r'<meta name="description"[^>]*>\s*', "", tpl, count=1)
    tpl = re.sub(r'<meta (?:property="og:image[^"]*"|name="twitter:[^"]*")[^>]*>\s*',
                 "", tpl)
    tpl = tpl.replace("<!--SSR_HEAD-->", head, 1)
    tpl = tpl.replace("<!--SSR_BODY-->", ssr_body, 1)
    return HTMLResponse(tpl)


def _event_or_404(uid: str) -> dict:
    con = db.connect()
    row = con.execute("SELECT * FROM events WHERE uid=?", (uid,)).fetchone()
    con.close()
    if row is None:
        raise HTTPException(404, "événement introuvable")
    d = dict(row)
    d["categories"] = json.loads(d.get("categories") or "[]")
    return d


# statut interne → eventStatus schema.org (soldout n'existe pas comme
# eventStatus : il se déclare via offers.availability SoldOut)
_LD_STATUS = {"cancelled": "EventCancelled", "postponed": "EventPostponed"}


def _jsonld(ev: dict) -> dict:
    ld: dict = {
        "@context": "https://schema.org",
        "@type": "Event",
        "name": ev["title"],
        "eventStatus": "https://schema.org/"
                       + _LD_STATUS.get(ev.get("status") or "", "EventScheduled"),
        "url": f"{BASE_URL}/evenement/{ev['uid']}",
    }
    if ev.get("start_date"):
        ld["startDate"] = ev["start_date"]
        if ev.get("start_time"):  # heure précise connue → ISO 8601 complet
            ld["startDate"] += f"T{ev['start_time']}:00{_tz_offset(ev['start_date'])}"
    if ev.get("end_date"):
        ld["endDate"] = ev["end_date"]
        if ev.get("end_time"):    # heure de fin connue → ISO 8601 complet
            ld["endDate"] += f"T{ev['end_time']}:00{_tz_offset(ev['end_date'])}"
    artists = json.loads(ev.get("artists") or "[]") \
        if isinstance(ev.get("artists"), str) else (ev.get("artists") or [])
    if artists:
        ld["performer"] = [{"@type": "PerformingGroup", "name": a}
                           for a in artists]
    if ev.get("description"):
        ld["description"] = ev["description"][:400]
    if ev.get("image"):
        ld["image"] = [ev["image"]]
    loc: dict = {"@type": "Place", "name": ev.get("venue") or ev.get("city") or "Québec"}
    addr = {"@type": "PostalAddress", "addressRegion": "QC", "addressCountry": "CA"}
    if ev.get("address"):
        addr["streetAddress"] = ev["address"]
    if ev.get("city"):
        addr["addressLocality"] = ev["city"]
    if ev.get("postal_code"):
        addr["postalCode"] = ev["postal_code"]
    loc["address"] = addr
    if ev.get("lat") and ev.get("lng"):
        loc["geo"] = {"@type": "GeoCoordinates",
                      "latitude": ev["lat"], "longitude": ev["lng"]}
    ld["location"] = loc
    if ev.get("is_free"):
        ld["isAccessibleForFree"] = True
    if ev.get("price_min") is not None:
        ld["offers"] = {"@type": "Offer", "price": f"{ev['price_min']:.2f}",
                        "priceCurrency": "CAD", "url": ev.get("url") or ""}
        if (ev.get("status") or "") == "soldout":
            ld["offers"]["availability"] = "https://schema.org/SoldOut"
    if ev.get("organizer"):
        ld["organizer"] = {"@type": "Organization", "name": ev["organizer"]}
    return ld


_STATUS_LABELS = {"cancelled": "Annulé", "postponed": "Reporté",
                  "soldout": "Complet"}


@router.get("/evenement/{uid}", include_in_schema=False)
def event_page(uid: str) -> HTMLResponse:
    ev = _event_or_404(uid)
    where = " · ".join(p for p in (ev.get("venue"), ev.get("city"),
                                   ev.get("region")) if p)
    when = ev.get("start_date") or ""
    if ev.get("end_date") and ev["end_date"] != ev.get("start_date"):
        when += f" au {ev['end_date']}"
    elif ev.get("start_time"):
        when += f" à {ev['start_time'].replace(':', ' h ')}"
        if ev.get("end_time"):
            when += f" – {ev['end_time'].replace(':', ' h ')}"
    status_label = _STATUS_LABELS.get(ev.get("status") or "", "")
    title = f"{ev['title']} — {ev.get('city') or 'Québec'} | {SITE_NAME}"
    desc = (ev.get("description") or
            f"{ev['title']}, {where}. Dates, lieu et lien vers la billetterie "
            f"officielle sur {SITE_NAME}.")[:300]
    canonical = f"{BASE_URL}/evenement/{_e(uid)}"
    head = (
        f"<title>{_e(title)}</title>\n"
        f'<meta name="description" content="{_e(desc)}">\n'
        f'<link rel="canonical" href="{canonical}">\n'
        f'<meta property="og:title" content="{_e(title)}">\n'
        f'<meta property="og:description" content="{_e(desc)}">\n'
        f'<meta property="og:type" content="event">\n'
        f'<meta property="og:url" content="{canonical}">\n'
        + (f'<meta property="og:image" content="{_e(ev["image"])}">\n'
           '<meta name="twitter:card" content="summary_large_image">\n'
           f'<meta name="twitter:image" content="{_e(ev["image"])}">\n'
           if ev.get("image") else OG_IMAGE_TAGS + "\n")
        + '<script type="application/ld+json">'
        + json.dumps(_jsonld(ev), ensure_ascii=False)
        + "</script>"
    )
    src = _SRC_LABELS.get(ev["source"], ev["source"])
    ssr = (
        f"<article><h1>{_e(ev['title'])}</h1>"
        + (f"<p><strong>{_e(status_label)}</strong></p>" if status_label else "")
        + f"<p>{_e(when)} — {_e(where)}</p>"
        + (f"<p>{_e(ev['description'][:500])}</p>" if ev.get("description") else "")
        + f'<p>Source : {_e(src)} — <a href="{_e(ev["url"])}" rel="noopener">'
          f"fiche originale et billets</a></p>"
        f'<p><a href="/">Toutes les sorties et tous les événements du Québec</a></p>'
        f"</article>"
    )
    return _render(head, ssr)


@router.get("/contact", include_in_schema=False)
def contact_page() -> HTMLResponse:
    """Page /contact (SPA) — head SEO + contenu SSR pour les robots.
    Contenu aligné sur ka-ui/ecosystem.json (contacts Groupe KA)."""
    title = f"Contact — {SITE_NAME} | Un service Groupe KA"
    desc = ("Écrire au Groupe KA : contact@groupe-ka.com (projets, partenariats "
            "et données), info@groupe-ka.com (médias et questions générales), "
            "admin@groupe-ka.com (légal, vie privée et Loi 25).")
    canonical = f"{BASE_URL}/contact"
    head = (
        f"<title>{_e(title)}</title>\n"
        f'<meta name="description" content="{_e(desc)}">\n'
        f'<link rel="canonical" href="{canonical}">\n'
        f'<meta property="og:title" content="{_e(title)}">\n'
        f'<meta property="og:description" content="{_e(desc)}">\n'
        f'<meta property="og:type" content="website">\n'
        f'<meta property="og:url" content="{canonical}">\n'
        + OG_IMAGE_TAGS
    )
    ssr = (
        "<article><h1>Contact — Groupe KA</h1>"
        "<p>Sorti-Ka est un service du Groupe KA.</p>"
        '<p><a href="mailto:contact@groupe-ka.com">contact@groupe-ka.com</a> — '
        "projets, partenariats et données.</p>"
        '<p><a href="mailto:info@groupe-ka.com">info@groupe-ka.com</a> — '
        "médias et questions générales.</p>"
        '<p><a href="mailto:admin@groupe-ka.com">admin@groupe-ka.com</a> — '
        "légal, vie privée et Loi 25.</p>"
        '<p><a href="https://www.groupe-ka.com" rel="noopener">Groupe KA — '
        "le portail de l'écosystème</a></p></article>"
    )
    return _render(head, ssr)


@router.get("/stats", include_in_schema=False)
def stats_page() -> HTMLResponse:
    """Page /stats (SPA) — head SEO + contenu SSR pour les robots."""
    con = db.connect()
    n = con.execute("SELECT COUNT(*) FROM events WHERE active=1").fetchone()[0]
    con.close()
    title = f"Statistiques — {SITE_NAME} | Un service Groupe KA"
    desc = (f"Tableau de bord analytique de {SITE_NAME} : {n:,} événements actifs"
            .replace(",", " ") +
            " — ajouts par jour, catégories, gratuits vs payants, régions, "
            "calendrier des jours les plus chargés et rapport PDF Groupe KA.")
    canonical = f"{BASE_URL}/stats"
    head = (
        f"<title>{_e(title)}</title>\n"
        f'<meta name="description" content="{_e(desc)}">\n'
        f'<link rel="canonical" href="{canonical}">\n'
        f'<meta property="og:title" content="{_e(title)}">\n'
        f'<meta property="og:description" content="{_e(desc)}">\n'
        f'<meta property="og:type" content="website">\n'
        f'<meta property="og:url" content="{canonical}">\n'
        + OG_IMAGE_TAGS
    )
    ssr = (
        "<article><h1>Statistiques Sorti-Ka</h1>"
        f"<p>{_e(desc)}</p>"
        '<p><a href="/">Toutes les sorties et tous les événements du Québec</a></p>'
        "</article>"
    )
    return _render(head, ssr)


@router.get("/robots.txt", include_in_schema=False)
def robots() -> PlainTextResponse:
    return PlainTextResponse(
        "User-agent: *\nAllow: /\n"
        "Disallow: /api/\n"
        f"Sitemap: {BASE_URL}/sitemap.xml\n")


def _urlset(rows: list[tuple[str, str | None]]) -> Response:
    items = "".join(
        f"<url><loc>{_e(u)}</loc>" + (f"<lastmod>{m}</lastmod>" if m else "")
        + "</url>" for u, m in rows)
    return Response(
        '<?xml version="1.0" encoding="UTF-8"?>'
        '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">'
        + items + "</urlset>", media_type="application/xml")


@router.get("/sitemap.xml", include_in_schema=False)
def sitemap_index() -> Response:
    con = db.connect()
    n = con.execute("SELECT COUNT(*) FROM events WHERE active=1 "
                    "AND quarantine IS NULL").fetchone()[0]
    con.close()
    chunks = max(1, -(-n // SITEMAP_CHUNK))
    items = "".join(
        f"<sitemap><loc>{BASE_URL}/sitemap-evenements-{i}.xml</loc></sitemap>"
        for i in range(chunks))
    return Response(
        '<?xml version="1.0" encoding="UTF-8"?>'
        '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">'
        f"<sitemap><loc>{BASE_URL}/sitemap-pages.xml</loc></sitemap>"
        + items + "</sitemapindex>", media_type="application/xml")


@router.get("/sitemap-pages.xml", include_in_schema=False)
def sitemap_pages() -> Response:
    return _urlset([(f"{BASE_URL}/", None), (f"{BASE_URL}/stats", None),
                    (f"{BASE_URL}/contact", None)])


@router.get("/sitemap-evenements-{num}.xml", include_in_schema=False)
def sitemap_events(num: int) -> Response:
    from datetime import datetime, timezone
    con = db.connect()
    rows = con.execute(
        "SELECT uid, updated_at FROM events WHERE active=1 "
        "AND quarantine IS NULL ORDER BY uid LIMIT ? OFFSET ?",
        (SITEMAP_CHUNK, num * SITEMAP_CHUNK)).fetchall()
    con.close()
    def iso(ts):
        try:
            return datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d")
        except Exception:
            return None
    return _urlset([(f"{BASE_URL}/evenement/{r['uid']}", iso(r["updated_at"]))
                    for r in rows])