#!/usr/bin/env python3
"""
Jean Router — Proxy dynamique pour Jean presets
Interroge Jean pour lister les presets disponibles et route les requêtes
vers le bon preset en faisant le switch automatique si nécessaire.
"""

import os
import time
import logging
import threading
import socket
import queue
import json as json_mod
from collections import deque
from typing import Optional

import requests
from flask import Flask, request, Response, jsonify, stream_with_context

JEAN_WEB_HOST = os.getenv("JEAN_WEB_HOST", "192.168.1.11")
JEAN_WEB_PORT = int(os.getenv("JEAN_WEB_PORT", "8090"))
JEAN_PROXY_HOST = os.getenv("JEAN_PROXY_HOST", "localhost")
JEAN_PROXY_PORT = int(os.getenv("JEAN_PROXY_PORT", "3012"))
OLLAMA_PROXY_HOST = os.getenv("OLLAMA_PROXY_HOST", "localhost")
OLLAMA_PROXY_PORT = int(os.getenv("OLLAMA_PROXY_PORT", "3011"))
OLLAMA_DIRECT_HOST = os.getenv("OLLAMA_DIRECT_HOST", JEAN_WEB_HOST)
OLLAMA_DIRECT_PORT = int(os.getenv("OLLAMA_DIRECT_PORT", "11434"))
ENABLE_OLLAMA = os.getenv("ENABLE_OLLAMA", "true").lower() == "true"
ENABLE_VRAM_MANAGEMENT = os.getenv("ENABLE_VRAM_MANAGEMENT", "true").lower() == "true"
OLLAMA_KEEP_ALIVE_MINUTES = int(os.getenv("OLLAMA_KEEP_ALIVE_MINUTES", "5"))
LISTEN_PORT = int(os.getenv("LISTEN_PORT", "3014"))
SWITCH_TIMEOUT = int(os.getenv("SWITCH_TIMEOUT", "90"))
CHECK_INTERVAL = int(os.getenv("CHECK_INTERVAL", "2"))
JEAN_STOP_TIMEOUT = int(os.getenv("JEAN_STOP_TIMEOUT", "30"))
OLLAMA_UNLOAD_TIMEOUT = int(os.getenv("OLLAMA_UNLOAD_TIMEOUT", "15"))
ENABLE_WOL = os.getenv("ENABLE_WOL", "false").lower() == "true"
TARGET_MAC = os.getenv("TARGET_MAC", os.getenv("PC_GAMING_MAC", ""))
BROADCAST_IP = os.getenv("BROADCAST_IP", "192.168.1.255")
WAKE_TIMEOUT = int(os.getenv("WAKE_TIMEOUT", "180"))
JEAN_CTX_OVERRIDES = json_mod.loads(os.getenv("JEAN_CTX_OVERRIDES", "{}"))
wol_in_progress = threading.Lock()
jean_alive_cache = {"alive": False, "timestamp": 0}

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
logging.getLogger("urllib3").setLevel(logging.WARNING)
logging.getLogger("requests").setLevel(logging.WARNING)
log = logging.getLogger(__name__)

app = Flask(__name__)

# --- Log buffer pour le dashboard SSE ---
log_queue = queue.Queue()
log_buffer = deque(maxlen=5000)

class QueueHandler(logging.Handler):
    def emit(self, record):
        msg = self.format(record)
        log_buffer.append(msg)
        try:
            log_queue.put_nowait(msg)
        except queue.Full:
            pass

queue_handler = QueueHandler()
queue_handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))
queue_handler.setLevel(logging.INFO)
logging.getLogger().addHandler(queue_handler)

# --- Compteur de requêtes ---
request_stats = {"total": 0, "jean": 0, "ollama": 0, "errors": 0, "last_requests": deque(maxlen=50)}
stats_lock = threading.Lock()

presets_cache = {"data": [], "timestamp": 0}
ollama_cache = {"data": [], "timestamp": 0}
ollama_detail_cache = {}
jean_ctx_cache = {}
jean_caps_cache = {}
CACHE_TTL = int(os.getenv("CACHE_TTL", "15"))
OLLAMA_DETAIL_CACHE_TTL = 300
switch_lock = threading.Lock()
vram_lock = threading.Lock()
vram_state = {"active_backend": "jean"}
last_active_preset = None
ollama_unload_timer = None


def get_presets(force_refresh=False):
    """Récupère la liste des presets depuis Jean"""
    now = time.time()
    if not force_refresh and presets_cache["data"] and (now - presets_cache["timestamp"]) < CACHE_TTL:
        return presets_cache["data"]

    try:
        url = f"http://{JEAN_WEB_HOST}:{JEAN_WEB_PORT}/api/presets"
        r = requests.get(url, timeout=3)
        if r.ok:
            presets_cache["data"] = r.json()
            presets_cache["timestamp"] = now
            return presets_cache["data"]
    except Exception as e:
        log.warning(f"[Presets] Erreur récupération: {e}")
        if ENABLE_WOL and (not presets_cache["data"] or force_refresh):
            wait_for_jean(trigger_wol=True)
            try:
                r = requests.get(f"http://{JEAN_WEB_HOST}:{JEAN_WEB_PORT}/api/presets", timeout=5)
                if r.ok:
                    presets_cache["data"] = r.json()
                    presets_cache["timestamp"] = now
                    return presets_cache["data"]
            except Exception:
                pass

    return presets_cache["data"]


def send_wol():
    """Envoie un magic packet WoL vers TARGET_MAC"""
    if not TARGET_MAC:
        log.warning("[WoL] TARGET_MAC non defini, WoL desactive")
        return

    mac = TARGET_MAC.replace(":", "").replace("-", "")
    if len(mac) != 12:
        log.error(f"[WoL] MAC invalide: {TARGET_MAC}")
        return

    data = bytes.fromhex("FF" * 6 + mac * 16)
    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
        s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
        for i in range(3):
            s.sendto(data, (BROADCAST_IP, 9))
            log.info(f"[WoL] Magic packet #{i+1} envoye vers {TARGET_MAC}")


def jean_alive() -> bool:
    """Verifie si le PC gaming est allume (TCP connect vers Jean ou Ollama)"""
    now = time.time()
    if now - jean_alive_cache["timestamp"] < 2:
        return jean_alive_cache["alive"]

    alive = False
    for port in [JEAN_WEB_PORT, OLLAMA_DIRECT_PORT]:
        try:
            sock = socket.create_connection((JEAN_WEB_HOST, port), timeout=2)
            sock.close()
            alive = True
            break
        except ConnectionRefusedError:
            alive = True
            break
        except (socket.timeout, OSError):
            continue

    jean_alive_cache["alive"] = alive
    jean_alive_cache["timestamp"] = now
    return alive


def jean_service_ok() -> bool:
    """Verifie que le service Jean repond (HTTP) — silencieux"""
    try:
        r = requests.get(f"http://{JEAN_WEB_HOST}:{JEAN_WEB_PORT}/api/presets", timeout=3)
        return r.ok
    except Exception:
        return False


def ollama_service_ok() -> bool:
    """Verifie que le service Ollama repond (HTTP) — silencieux"""
    try:
        r = requests.get(f"http://{OLLAMA_DIRECT_HOST}:{OLLAMA_DIRECT_PORT}/api/version", timeout=2)
        return r.ok
    except Exception:
        return False


def wait_for_jean(trigger_wol=True):
    """Attend que Jean soit accessible. Si ENABLE_WOL et trigger_wol, envoie WoL d'abord."""
    alive = jean_alive()
    if alive:
        return

    if not ENABLE_WOL or not trigger_wol:
        return

    with wol_in_progress:
        if jean_alive():
            return

        log.info("[WoL] Jean inaccessible, envoi WoL...")
        send_wol()

        deadline = time.time() + WAKE_TIMEOUT
        while time.time() < deadline:
            remaining = int(deadline - time.time())
            if jean_alive():
                jean_alive_cache["timestamp"] = 0
                log.info(f"[WoL] Jean UP apres {int(time.time() - deadline + WAKE_TIMEOUT)}s")
                return
            log.info(f"[WoL] En attente... ({remaining}s restantes)")
            time.sleep(max(CHECK_INTERVAL, 5))

        log.error(f"[WoL] Jean ne repond pas apres {WAKE_TIMEOUT}s")


def stream_wake_then_forward(upstream_url, data, headers):
    """Stream des messages d'attente pendant le reveil, puis forward la vraie reponse"""
    import uuid
    chat_id = f"chatcmpl-{uuid.uuid4().hex[:29]}"

    def wake_chunk(content):
        return (
            f'data: {{"id":"{chat_id}","object":"chat.completion.chunk",'
            f'"created":{int(time.time())},"model":"wake","choices":['
            f'{{"delta":{{"content":"{content} "}},"index":0}}]}}\n\n'
        ).encode()

    def generate():
        yield wake_chunk("🖥️ Le PC de jeu se réveille...")

        if not jean_alive() and ENABLE_WOL:
            with wol_in_progress:
                if not jean_alive():
                    log.info("[WoL-Stream] Envoi WoL + attente...")
                    send_wol()
                    yield wake_chunk("⚡ Magic packet envoyé, démarrage en cours...")

                    deadline = time.time() + WAKE_TIMEOUT
                    last_pct = 0
                    while time.time() < deadline:
                        if jean_alive():
                            jean_alive_cache["timestamp"] = 0
                            yield wake_chunk("✅ PC allumé, chargement du modèle...")
                            break
                        pct = int((1 - (deadline - time.time()) / WAKE_TIMEOUT) * 100)
                        if pct >= last_pct + 10:
                            yield wake_chunk(f"⏳ Démarrage... {min(pct, 95)}%")
                            last_pct = pct
                        time.sleep(CHECK_INTERVAL)
                    else:
                        yield wake_chunk("❌ Le PC n'a pas répondu, réessayez.")
                        yield b"data: [DONE]\n\n"
                        return

        # Attendre que Jean soit vraiment prêt (proxy + modele)
        deadline = time.time() + SWITCH_TIMEOUT
        while time.time() < deadline:
            try:
                r = requests.get(f"http://{JEAN_PROXY_HOST}:{JEAN_PROXY_PORT}/health", timeout=2)
                if r.ok and r.json().get("status") == "ok":
                    break
            except Exception:
                pass
            yield wake_chunk(".")
            time.sleep(2)

        yield wake_chunk("🚀 Modèle prêt, voici la réponse :\n\n")

        # Forward la vraie requête et streamer
        try:
            resp = requests.request(
                method="POST", url=upstream_url, headers=headers,
                json=data, stream=True, timeout=None,
            )
            for line in resp.iter_lines():
                if line:
                    yield line + b"\n"
            yield b"data: [DONE]\n\n"
        except Exception as e:
            yield wake_chunk(f"❌ Erreur: {str(e)[:100]}")
            yield b"data: [DONE]\n\n"

    return Response(
        stream_with_context(generate()),
        content_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "X-Accel-Buffering": "no",
        },
    )


def get_ollama_models(force_refresh=False):
    """Récupère la liste des modèles depuis Ollama"""
    if not ENABLE_OLLAMA:
        return []

    now = time.time()
    if not force_refresh and ollama_cache["data"] and (now - ollama_cache["timestamp"]) < CACHE_TTL:
        return ollama_cache["data"]

    try:
        url = f"http://{OLLAMA_PROXY_HOST}:{OLLAMA_PROXY_PORT}/api/tags"
        r = requests.get(url, timeout=3)
        if r.ok:
            data = r.json().get("models", [])
            ollama_cache["data"] = data
            ollama_cache["timestamp"] = now
            return data
    except Exception as e:
        log.warning(f"[Ollama] Erreur récupération: {e}")
        if ENABLE_WOL and (not ollama_cache["data"] or force_refresh):
            wait_for_jean(trigger_wol=True)
            try:
                r = requests.get(f"http://{OLLAMA_PROXY_HOST}:{OLLAMA_PROXY_PORT}/api/tags", timeout=5)
                if r.ok:
                    data = r.json().get("models", [])
                    ollama_cache["data"] = data
                    ollama_cache["timestamp"] = now
                    return data
            except Exception:
                pass

    return ollama_cache["data"]


def _get_ollama_model_detail(model_name: str) -> dict:
    """Récupère les détails d'un modèle Ollama via /api/show, avec cache long"""
    now = time.time()
    cached = ollama_detail_cache.get(model_name)
    if cached and (now - cached["timestamp"]) < OLLAMA_DETAIL_CACHE_TTL:
        return cached["data"]

    detail = {}
    try:
        clean_name = model_name.replace(":latest", "")
        url = f"http://{OLLAMA_DIRECT_HOST}:{OLLAMA_DIRECT_PORT}/api/show"
        r = requests.post(url, json={"model": clean_name}, timeout=10)
        if r.ok:
            d = r.json()
            model_info = d.get("model_info", {})
            details = d.get("details", {})

            for key, val in model_info.items():
                if "context_length" in key.lower() or "ctx" in key.lower():
                    detail["context_length"] = int(val)
                    break

            if not detail.get("context_length"):
                detail["context_length"] = details.get("context_length")

            detail["capabilities"] = d.get("capabilities", [])
            detail["family"] = details.get("family", "")

            ollama_detail_cache[model_name] = {"data": detail, "timestamp": now}
    except Exception as e:
        log.debug(f"[Ollama] /api/show echoue pour {model_name}: {e}")

    if model_name not in ollama_detail_cache:
        ollama_detail_cache[model_name] = {"data": {}, "timestamp": now}

    return ollama_detail_cache[model_name]["data"]


def _enrich_ollama_model(m: dict) -> dict:
    """Enrichit un modele Ollama avec les donnees /api/show si necessaire"""
    model_id = m.get("name", "").replace(":latest", "")
    details = m.get("details", {})
    has_ctx = bool(details.get("context_length"))
    caps = m.get("capabilities", [])

    if not has_ctx or len(caps) <= 1:
        extra = _get_ollama_model_detail(model_id)
        if extra.get("context_length"):
            details = dict(details)
            details["context_length"] = extra["context_length"]
            m = dict(m)
            m["details"] = details
        if extra.get("capabilities") and len(extra["capabilities"]) > len(caps):
            m = dict(m)
            m["capabilities"] = extra["capabilities"]
        if extra.get("family") and not details.get("family"):
            details = dict(details)
            details["family"] = extra["family"]
            m = dict(m)
            m["details"] = details

    return m

def _guess_context_length(preset_id: str) -> int:
    """Devine le context_length depuis le nom du preset"""
    pid = preset_id.lower()
    if "qwen3.6" in pid or "qwen3.5" in pid:
        return 262144
    if "qwen3" in pid:
        return 40960
    if "qwen2.5" in pid:
        return 32768
    if "mistral" in pid or "nemo" in pid:
        return 1024000
    if "llama" in pid:
        return 131072
    if "ornith" in pid:
        return 131072
    if "gemma" in pid:
        return 262144
    if "deepseek" in pid:
        return 131072
    if "phi" in pid:
        return 16384
    if "35b" in pid or "27b" in pid:
        return 131072
    return 32768


def _guess_capabilities(preset_id: str) -> list:
    """Devine les capabilities depuis le nom du preset + metadonnees Jean"""
    pid = preset_id.lower()
    caps = ["completion"]

    has_vision = any(kw in pid for kw in ["vision", "vl", "llava", "bakllava", "minicpm"])
    has_thinking = any(kw in pid for kw in ["reason", "thinking", "deepseek-r1"])
    has_tools = not any(kw in pid for kw in ["embed", "bge-", "nomic-"])

    if has_vision:
        caps.append("vision")
    if has_thinking:
        caps.append("thinking")
    if has_tools:
        caps.append("tools")

    return caps


def _match_preset_to_ollama(preset_id: str):
    """Tente de trouver un modele Ollama correspondant au preset Jean"""
    ollama_models = get_ollama_models()
    pid_lower = preset_id.lower()

    def norm(s):
        return s.lower().replace(":", "").replace("-", "").replace(" ", "").replace(".", "")

    pid_norm = norm(pid_lower)

    for m in ollama_models:
        name = m.get("name", "").replace(":latest", "")
        name_norm = norm(name)

        if pid_norm == name_norm:
            return m

    best = None
    best_score = 0
    for m in ollama_models:
        name = m.get("name", "").replace(":latest", "")
        name_norm = norm(name)
        score = 0

        if len(pid_norm) >= 4 and pid_norm[:4] == name_norm[:4]:
            score += 10
        if len(pid_norm) >= 8 and pid_norm[:8] == name_norm[:8]:
            score += 20
        if name_norm in pid_norm or pid_norm in name_norm:
            score += 15

        parts_pid = set(pid_norm.split("_"))
        parts_name = set(name_norm.split("_"))
        common = parts_pid & parts_name
        score += len(common) * 5

        if score > best_score:
            best_score = score
            best = m

    if best and best_score >= 5:
        return best
    return None


def get_jean_metadata():
    """Resout dynamiquement context_length et capabilities pour les presets Jean.
    1) JEAN_CTX_OVERRIDES → 2) llama-server /v1/models → 3) Ollama matching → 4) heuristique"""

    # 1 — Overrides utilisateur (priorite max)
    for pid, ctx in JEAN_CTX_OVERRIDES.items():
        jean_ctx_cache[pid] = ctx

    # 2 — llama-server direct (port 8080, modele actif)
    try:
        r = requests.get(f"http://{JEAN_WEB_HOST}:8080/v1/models", timeout=3)
        if r.ok:
            for m in r.json().get("data", []):
                meta = m.get("meta", {})
                ctx = meta.get("n_ctx") or m.get("max_model_len") or m.get("context_length")
                if ctx:
                    # Associer ce ctx au preset actif (meme nom ou alias)
                    active = get_active_preset()
                    if active:
                        jean_ctx_cache[active["id"]] = int(ctx)
                        log.info(f"[Jean] ctx reel via llama-server: {active['id']}={ctx}")
    except Exception:
        pass

    # 3 — Jean proxy /v1/models (via jean-proxy, pour le modele actif)
    try:
        url = f"http://{JEAN_PROXY_HOST}:{JEAN_PROXY_PORT}/v1/models"
        r = requests.get(url, timeout=2)
        if r.ok:
            for m in r.json().get("data", []):
                alias = m.get("id", "")
                meta = m.get("meta", {})
                n_ctx = meta.get("n_ctx") or m.get("max_model_len")
                if n_ctx and alias and alias not in jean_ctx_cache:
                    jean_ctx_cache[alias] = int(n_ctx)
    except Exception:
        pass

    ollama_models = get_ollama_models()
    ollama_lookup = {}
    for m in ollama_models:
        m = _enrich_ollama_model(m)
        name = m.get("name", "").replace(":latest", "")
        details = m.get("details", {})
        ctx = details.get("context_length")
        caps = m.get("capabilities", [])
        ollama_lookup[name] = {"context_length": ctx, "capabilities": caps}

    presets = get_presets()
    for p in presets:
        pid = p["id"]

        matched_ollama = _match_preset_to_ollama(pid)
        ollama_name = matched_ollama.get("name", "").replace(":latest", "") if matched_ollama else None

        if pid not in jean_ctx_cache:
            if pid in JEAN_CTX_OVERRIDES:
                jean_ctx_cache[pid] = JEAN_CTX_OVERRIDES[pid]
            elif ollama_name and ollama_lookup.get(ollama_name, {}).get("context_length"):
                jean_ctx_cache[pid] = ollama_lookup[ollama_name]["context_length"]
            else:
                jean_ctx_cache[pid] = _guess_context_length(pid)

        if pid not in jean_caps_cache:
            if p.get("reasoning") == "on":
                caps = ["completion", "tools", "thinking"]
            else:
                caps = ["completion", "tools"]

            if ollama_name and ollama_lookup.get(ollama_name, {}).get("capabilities"):
                ollama_caps = ollama_lookup[ollama_name]["capabilities"]
                caps = list(dict.fromkeys(caps + ollama_caps))

            jean_caps_cache[pid] = caps

    return jean_ctx_cache, jean_caps_cache


def get_active_preset():
    """Retourne le preset actuellement actif"""
    presets = get_presets()
    for p in presets:
        if p.get("active"):
            return p
    return None


def switch_preset(preset_id: str) -> bool:
    """Switch vers un preset spécifique par son ID"""
    global last_active_preset
    presets = get_presets(force_refresh=True)

    for i, p in enumerate(presets):
        if p["id"] == preset_id:
            if p.get("active"):
                log.info(f"[Switch] Preset {preset_id} déjà actif")
                return True

            log.info(f"[Switch] Activation preset {preset_id} (index {i+1})")
            success = False
            for attempt in range(2):
                try:
                    url = f"http://{JEAN_WEB_HOST}:{JEAN_WEB_PORT}/api/switch"
                    r = requests.post(url, json={"n": i + 1}, timeout=15)
                    if r.ok:
                        success = True
                        break
                    log.error(f"[Switch] Erreur API (tentative {attempt+1}): {r.text}")
                except Exception as e:
                    log.error(f"[Switch] Erreur requête (tentative {attempt+1}): {e}")
                if attempt == 0:
                    time.sleep(3)
            if not success:
                return False

            log.info(f"[Switch] Attente chargement modèle...")
            deadline = time.time() + SWITCH_TIMEOUT
            while time.time() < deadline:
                try:
                    health_url = f"http://{JEAN_PROXY_HOST}:{JEAN_PROXY_PORT}/health"
                    hr = requests.get(health_url, timeout=2)
                    if hr.ok:
                        models_url = f"http://{JEAN_PROXY_HOST}:{JEAN_PROXY_PORT}/v1/models"
                        mr = requests.get(models_url, timeout=2)
                        if mr.ok:
                            models = mr.json().get("data", [])
                            if models:
                                log.info(f"[Switch] Modèle chargé après {int(time.time() - deadline + SWITCH_TIMEOUT)}s")
                                last_active_preset = preset_id
                                presets_cache["timestamp"] = 0
                                return True
                except Exception:
                    pass
                time.sleep(CHECK_INTERVAL)

            log.error(f"[Switch] Timeout après {SWITCH_TIMEOUT}s")
            return False

    log.error(f"[Switch] Preset {preset_id} non trouvé")
    return False


def stop_jean() -> bool:
    """Arrête le service Jean pour libérer la VRAM"""
    log.info("[VRAM] Arrêt de Jean pour libérer la VRAM...")

    try:
        url = f"http://{JEAN_WEB_HOST}:{JEAN_WEB_PORT}/api/stop"
        r = requests.post(url, timeout=5)
        if r.ok:
            log.info("[VRAM] Jean arrêté via API web")
        else:
            log.warning(f"[VRAM] API stop a retourné {r.status_code}, tentative via health check")
    except Exception as e:
        log.warning(f"[VRAM] Erreur API stop: {e}")

    deadline = time.time() + JEAN_STOP_TIMEOUT
    while time.time() < deadline:
        try:
            health_url = f"http://{JEAN_WEB_HOST}:{JEAN_WEB_PORT}/health"
            r = requests.get(health_url, timeout=2)
            if not r.ok:
                log.info("[VRAM] Jean confirmé arrêté")
                return True
        except Exception:
            log.info("[VRAM] Jean confirmé arrêté (connexion refusée)")
            return True
        time.sleep(CHECK_INTERVAL)

    log.error(f"[VRAM] Timeout: Jean ne s'est pas arrêté après {JEAN_STOP_TIMEOUT}s")
    return False


def start_jean() -> bool:
    """Démarre le service Jean"""
    log.info("[VRAM] Démarrage de Jean...")

    try:
        url = f"http://{JEAN_WEB_HOST}:{JEAN_WEB_PORT}/api/start"
        r = requests.post(url, timeout=5)
        if r.ok:
            log.info("[VRAM] Jean démarré via API web")
        else:
            log.warning(f"[VRAM] API start a retourné {r.status_code}")
    except Exception as e:
        log.warning(f"[VRAM] Erreur API start: {e}")

    log.info("[VRAM] Attente du chargement du modèle Jean...")
    deadline = time.time() + SWITCH_TIMEOUT
    while time.time() < deadline:
        try:
            health_url = f"http://{JEAN_PROXY_HOST}:{JEAN_PROXY_PORT}/health"
            hr = requests.get(health_url, timeout=2)
            if hr.ok:
                models_url = f"http://{JEAN_PROXY_HOST}:{JEAN_PROXY_PORT}/v1/models"
                mr = requests.get(models_url, timeout=2)
                if mr.ok:
                    models = mr.json().get("data", [])
                    if models:
                        log.info(f"[VRAM] Jean prêt après {int(time.time() - deadline + SWITCH_TIMEOUT)}s")
                        return True
        except Exception:
            pass
        time.sleep(CHECK_INTERVAL)

    log.error(f"[VRAM] Timeout: Jean n'a pas démarré après {SWITCH_TIMEOUT}s")
    return False


def unload_ollama() -> bool:
    """Force le déchargement des modèles Ollama pour libérer la VRAM"""
    log.info("[VRAM] Déchargement des modèles Ollama...")

    try:
        url = f"http://{OLLAMA_DIRECT_HOST}:{OLLAMA_DIRECT_PORT}/api/generate"
        payload = {
            "model": "mistral",
            "keep_alive": 0,
            "prompt": ""
        }
        r = requests.post(url, json=payload, timeout=5)
        if r.ok:
            log.info("[VRAM] Ollama déchargé via API")
            return True
        else:
            log.warning(f"[VRAM] API unload a retourné {r.status_code}")
    except Exception as e:
        log.warning(f"[VRAM] Erreur API unload: {e}")

    try:
        url = f"http://{OLLAMA_DIRECT_HOST}:{OLLAMA_DIRECT_PORT}/api/ps"
        r = requests.get(url, timeout=3)
        if r.ok:
            models = r.json().get("models", [])
            if not models:
                log.info("[VRAM] Ollama confirmé déchargé (aucun modèle actif)")
                return True
            else:
                log.warning(f"[VRAM] Ollama a encore {len(models)} modèle(s) chargé(s)")
    except Exception as e:
        log.warning(f"[VRAM] Impossible de vérifier /api/ps: {e}")

    time.sleep(2)
    log.info("[VRAM] Ollama supposé déchargé (timeout)")
    return True


def schedule_ollama_unload():
    """Programme le déchargement d'Ollama après OLLAMA_KEEP_ALIVE_MINUTES"""
    global ollama_unload_timer

    def delayed_unload():
        log.info(f"[VRAM] Timer écoulé ({OLLAMA_KEEP_ALIVE_MINUTES}min), déchargement Ollama...")
        unload_ollama()

    if ollama_unload_timer:
        ollama_unload_timer.cancel()
        log.info("[VRAM] Timer précédent annulé")

    ollama_unload_timer = threading.Timer(
        OLLAMA_KEEP_ALIVE_MINUTES * 60,
        delayed_unload
    )
    ollama_unload_timer.daemon = True
    ollama_unload_timer.start()
    log.info(f"[VRAM] Déchargement Ollama programmé dans {OLLAMA_KEEP_ALIVE_MINUTES} minutes")


def cancel_ollama_unload():
    """Annule le déchargement programmé d'Ollama"""
    global ollama_unload_timer
    if ollama_unload_timer:
        ollama_unload_timer.cancel()
        ollama_unload_timer = None
        log.info("[VRAM] Timer de déchargement Ollama annulé")


def ensure_vram_for_backend(target_backend: str) -> bool:
    """
    S'assure que la VRAM est disponible pour le backend cible.
    - Si target=ollama et jean actif → arrête Jean, annule timer unload Ollama
    - Si target=jean et ollama actif → programme déchargement Ollama dans X min, démarre Jean
    """
    if not ENABLE_VRAM_MANAGEMENT:
        return True

    global last_active_preset

    with vram_lock:
        current = vram_state["active_backend"]

        if current == target_backend:
            return True

        if target_backend == "ollama" and current == "jean":
            log.info("[VRAM] Switch Jean → Ollama")
            cancel_ollama_unload()
            if not stop_jean():
                return False
            last_active_preset = None
            vram_state["active_backend"] = "ollama"
            return True

        elif target_backend == "jean" and current == "ollama":
            log.info("[VRAM] Switch Ollama → Jean")
            schedule_ollama_unload()
            if not start_jean():
                return False
            last_active_preset = None
            vram_state["active_backend"] = "jean"
            return True

        return True


@app.route("/v1/models", methods=["GET"])
def list_models():
    """Expose tous les presets Jean + modèles Ollama comme modèles OpenAI"""
    force_refresh = request.args.get("refresh", "").lower() in ("1", "true", "yes")
    if force_refresh:
        global presets_cache, ollama_cache
        presets_cache["timestamp"] = 0
        ollama_cache["timestamp"] = 0
        log.info("[Models] Refresh force demande")

    presets = get_presets()
    jean_ctx, jean_caps = get_jean_metadata()
    models = []

    for p in presets:
        model_id = p["id"]
        model_name = p.get("name", model_id)

        ctx_len = jean_ctx.get(model_id)
        caps = jean_caps.get(model_id, ["completion", "tools"])
        if p.get("reasoning") == "on" and "thinking" not in caps:
            caps = list(dict.fromkeys(caps + ["thinking"]))

        model_info = {
            "id": model_name,
            "object": "model",
            "created": int(time.time()),
            "owned_by": "jean",
            "permission": [],
            "root": model_name,
            "parent": None,
        }

        if ctx_len:
            model_info["context_length"] = ctx_len
            model_info["context_window"] = ctx_len
            model_info["max_model_len"] = ctx_len
            model_info["max_tokens"] = ctx_len
            model_info["max_input_tokens"] = ctx_len

        model_info["capabilities"] = caps

        meta = {}
        if p.get("name") and p["name"] != model_id:
            meta["display_name"] = p["name"]
        if p.get("quant"):
            meta["quantization"] = p["quant"]
        if p.get("reasoning"):
            meta["reasoning"] = p["reasoning"]
        if p.get("active"):
            meta["active"] = True
        if p.get("bench"):
            meta["bench"] = p["bench"]
        if ctx_len:
            meta["context_length"] = ctx_len
        meta["capabilities"] = caps

        if meta:
            model_info["meta"] = meta

        models.append(model_info)

    if ENABLE_OLLAMA:
        ollama_models = get_ollama_models()
        for m in ollama_models:
            m = _enrich_ollama_model(m)
            model_id = m.get("name", "").replace(":latest", "")
            if not model_id:
                continue

            caps = m.get("capabilities", ["completion"])
            details = m.get("details", {})
            ctx_len = details.get("context_length")

            model_info = {
                "id": model_id,
                "object": "model",
                "created": int(time.time()),
                "owned_by": "ollama",
                "permission": [],
                "root": model_id,
                "parent": None,
            }

            if ctx_len:
                model_info["context_length"] = ctx_len
                model_info["context_window"] = ctx_len
                model_info["max_model_len"] = ctx_len
                model_info["max_tokens"] = ctx_len
                model_info["max_input_tokens"] = ctx_len

            model_info["capabilities"] = caps

            meta = {}
            if details.get("parameter_size"):
                meta["parameter_size"] = details["parameter_size"]
            if details.get("quantization_level"):
                meta["quantization"] = details["quantization_level"]
            if details.get("family"):
                meta["family"] = details["family"]
            if ctx_len:
                meta["context_length"] = ctx_len
            meta["capabilities"] = caps

            if meta:
                model_info["meta"] = meta

            models.append(model_info)

    return jsonify({"object": "list", "data": models})


@app.route("/v1/chat/completions", methods=["POST"])
def chat_completions():
    """Route les requêtes chat vers Jean ou Ollama selon le modèle"""
    data = request.get_json()
    model_id = data.get("model")

    with stats_lock:
        request_stats["total"] += 1
        request_stats["last_requests"].append({
            "model": model_id,
            "time": time.strftime("%H:%M:%S"),
            "max_tokens": data.get("max_tokens", 0),
        })

    if not model_id:
        return jsonify({"error": "model parameter required"}), 400

    presets = get_presets()
    jean_preset_ids = {p["id"] for p in presets}
    jean_name_to_id = {p.get("name", p["id"]): p["id"] for p in presets}
    jean_names = set(jean_name_to_id.keys())

    if model_id in jean_preset_ids or model_id in jean_names:
        internal_id = jean_name_to_id.get(model_id, model_id)

        if not jean_alive() and ENABLE_WOL:
            log.info("[WoL-Stream] PC down, demarrage stream d'attente...")
            fwd_headers = dict(request.headers)
            fwd_headers.pop("Host", None)
            return stream_wake_then_forward(
                f"http://{JEAN_PROXY_HOST}:{JEAN_PROXY_PORT}/v1/chat/completions",
                data, fwd_headers
            )

        if not jean_service_ok():
            log.warning(f"[Router] PC ON mais Jean DOWN, requete vers {model_id} risque d'echouer")

        if not ensure_vram_for_backend("jean"):
            return jsonify({"error": "Failed to prepare VRAM for Jean"}), 503

        with switch_lock:
            active = get_active_preset()
            current_active = active["id"] if active else last_active_preset
            if current_active != internal_id:
                log.info(f"[Router] Switch Jean requis: {current_active or 'none'} → {internal_id} ({model_id})")
                if not switch_preset(internal_id):
                    return jsonify({"error": f"Failed to switch to preset {model_id}"}), 503
            else:
                log.info(f"[Router] Preset {model_id} déjà actif (tracké)")

        preset = next((p for p in presets if p["id"] == internal_id), {})
        if preset.get("reasoning") == "on":
            ctx, _ = get_jean_metadata()
            ctx_len = ctx.get(internal_id, 131072)
            req_max = data.get("max_tokens", 0)
            if req_max and req_max > 0:
                new_max = min(req_max * 2, ctx_len)
                if new_max != req_max:
                    log.info(f"[Reasoning] max_tokens doublé: {req_max} → {new_max}")
                    data = dict(data)
                    data["max_tokens"] = new_max

        upstream_url = f"http://{JEAN_PROXY_HOST}:{JEAN_PROXY_PORT}/v1/chat/completions"
        log.info(f"[Router] → Jean ({model_id})")
        with stats_lock:
            request_stats["jean"] += 1
    elif ENABLE_OLLAMA:
        wait_for_jean(trigger_wol=True)
        ollama_models = get_ollama_models()
        ollama_ids = [m.get("name", "").replace(":latest", "") for m in ollama_models]

        if model_id in ollama_ids:
            if not ensure_vram_for_backend("ollama"):
                return jsonify({"error": "Failed to prepare VRAM for Ollama"}), 503

            cancel_ollama_unload()

            upstream_url = f"http://{OLLAMA_PROXY_HOST}:{OLLAMA_PROXY_PORT}/v1/chat/completions"
            log.info(f"[Router] → Ollama ({model_id})")
            with stats_lock:
                request_stats["ollama"] += 1
        else:
            return jsonify({"error": f"Unknown model: {model_id}"}), 404
    else:
        return jsonify({"error": f"Unknown model: {model_id}"}), 404

    headers = dict(request.headers)
    headers.pop("Host", None)

    try:
        resp = requests.request(
            method=request.method,
            url=upstream_url,
            headers=headers,
            json=data,
            stream=True,
            timeout=None,
        )
    except Exception as e:
        log.error(f"[Router] Erreur upstream: {e}")
        with stats_lock:
            request_stats["errors"] += 1
        if ENABLE_WOL:
            log.info("[Router] Tentative WoL + retry apres echec upstream...")
            wait_for_jean(trigger_wol=True)
            try:
                resp = requests.request(
                    method=request.method, url=upstream_url,
                    headers=headers, json=data, stream=True, timeout=None,
                )
            except Exception as e2:
                log.error(f"[Router] Echec apres WoL: {e2}")
                return jsonify({"error": str(e2)}), 502
        else:
            return jsonify({"error": str(e)}), 502

    excluded = {"content-encoding", "content-length", "transfer-encoding", "connection"}
    response_headers = [
        (name, value) for name, value in resp.headers.items()
        if name.lower() not in excluded
    ]

    return Response(
        resp.raw,
        status=resp.status_code,
        headers=response_headers,
        direct_passthrough=True,
    )


# ═══════════════════════════════════════════════
#  DASHBOARD — Diagnostic & monitoring
# ═══════════════════════════════════════════════

@app.route("/dashboard")
def dashboard():
    """Page HTML de diagnostic"""
    return Response(DASHBOARD_HTML, content_type="text/html; charset=utf-8")


@app.route("/api/dashboard/status")
def dashboard_status():
    """Etat complet en JSON"""
    pc_alive = jean_alive()
    jean_ok = jean_service_ok() if pc_alive else False
    olla_ok = ollama_service_ok() if pc_alive else False

    # Presets depuis le cache (evite d'appeler get_presets qui log un warning si down)
    presets_raw = presets_cache.get("data", []) if jean_ok else []

    slot_info = None
    if jean_ok:
        try:
            r = requests.get(f"http://{JEAN_WEB_HOST}:{JEAN_WEB_PORT}/slots", timeout=1)
            if r.ok:
                slots = r.json()
                if slots:
                    s = slots[0]
                    slot_info = {
                        "processing": s.get("is_processing", False),
                        "id_task": s.get("id_task"),
                        "n_prompt_tokens": s.get("n_prompt_tokens", 0),
                        "n_decoded": s.get("next_token", [{}])[0].get("n_decoded", 0) if s.get("next_token") else 0,
                    }
        except Exception:
            pass

    active = get_active_preset()
    with stats_lock:
        stats = dict(request_stats)
        stats["last_requests"] = list(stats.get("last_requests", []))

    return jsonify({
        "pc": {
            "alive": pc_alive,
            "host": JEAN_WEB_HOST,
        },
        "jean": {
            "alive": jean_ok,
            "host": f"{JEAN_WEB_HOST}:{JEAN_WEB_PORT}",
            "proxy": f"{JEAN_PROXY_HOST}:{JEAN_PROXY_PORT}",
            "active_preset": active["id"] if active else (last_active_preset or "none"),
            "presets": [{"id": p["id"], "name": p.get("name", p["id"]), "reasoning": p.get("reasoning")} for p in presets_raw],
            "slot": slot_info,
            "vram_backend": vram_state["active_backend"],
        },
        "ollama": {
            "alive": olla_ok,
            "host": f"{OLLAMA_DIRECT_HOST}:{OLLAMA_DIRECT_PORT}",
            "proxy": f"{OLLAMA_PROXY_HOST}:{OLLAMA_PROXY_PORT}",
        },
        "wol": {
            "enabled": ENABLE_WOL,
            "mac": TARGET_MAC,
            "timeout": WAKE_TIMEOUT,
        },
        "cache": {
            "ttl": CACHE_TTL,
            "presets_age": int(time.time() - presets_cache["timestamp"]),
            "ollama_age": int(time.time() - ollama_cache["timestamp"]),
        },
        "stats": stats,
    })


@app.route("/api/dashboard/logs")
def dashboard_logs():
    """Derniers logs en JSON"""
    limit = request.args.get("limit", 200, type=int)
    return jsonify(list(log_buffer)[-limit:])


@app.route("/api/dashboard/logs/stream")
def dashboard_logs_stream():
    """Stream SSE des logs en temps reel"""
    def generate():
        yield "data: " + json_mod.dumps({"type": "init", "logs": list(log_buffer)[-100:]}) + "\n\n"
        while True:
            try:
                msg = log_queue.get(timeout=5)
                yield "data: " + json_mod.dumps({"type": "log", "message": msg}) + "\n\n"
            except queue.Empty:
                yield "data: " + json_mod.dumps({"type": "ping"}) + "\n\n"
    return Response(
        stream_with_context(generate()),
        content_type="text/event-stream",
        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
    )


@app.route("/api/dashboard/actions/refresh", methods=["POST"])
def dashboard_refresh():
    """Force le rafraichissement du cache des modeles"""
    global presets_cache, ollama_cache
    presets_cache["timestamp"] = 0
    ollama_cache["timestamp"] = 0
    jean_alive_cache["timestamp"] = 0
    log.info("[Dashboard] Rafraichissement force du cache")
    return jsonify({"ok": True})


@app.route("/api/dashboard/actions/restart-jean", methods=["POST"])
def dashboard_restart_jean():
    """Redemarre Jean"""
    if not ENABLE_WOL:
        return jsonify({"ok": False, "error": "WoL non active"}), 400
    try:
        stop_jean()
        start_jean()
        log.info("[Dashboard] Jean redemarre via stop/start")
        return jsonify({"ok": True})
    except Exception as e:
        return jsonify({"ok": False, "error": str(e)}), 500


DASHBOARD_HTML = r"""<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>Jean Router — Dashboard</title>
<style>
:root{--bg:#0d1117;--card:#161b22;--border:#30363d;--text:#c9d1d9;--green:#3fb950;--red:#f85149;--yellow:#d2991d;--blue:#58a6ff;--purple:#bc8cff;--muted:#8b949e}
*{box-sizing:border-box;margin:0;padding:0}
body{background:var(--bg);color:var(--text);font:14px/1.5 SFMono,Consolas,monospace;padding:16px}
h1{font-size:18px;color:var(--purple);margin-bottom:12px}
.grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:12px;margin-bottom:16px}
.card{background:var(--card);border:1px solid var(--border);border-radius:8px;padding:14px}
.card h2{font-size:14px;color:var(--blue);margin-bottom:8px;border-bottom:1px solid var(--border);padding-bottom:6px}
.status-dot{display:inline-block;width:10px;height:10px;border-radius:50%;margin-right:6px}
.on{background:var(--green);box-shadow:0 0 6px var(--green)}
.off{background:var(--red);box-shadow:0 0 6px var(--red)}
.warn{background:var(--yellow);box-shadow:0 0 6px var(--yellow)}
.row{display:flex;justify-content:space-between;padding:2px 0;font-size:13px}
.row .label{color:var(--muted)}
.row .value{font-weight:600}
.badge{padding:2px 8px;border-radius:4px;font-size:12px;display:inline-block;margin:2px}
.badge-green{background:#1a3a1a;color:var(--green);border:1px solid var(--green)}
.badge-red{background:#3a1a1a;color:var(--red);border:1px solid var(--red)}
.badge-blue{background:#1a2a3a;color:var(--blue);border:1px solid var(--blue)}
#logs{grid-column:1/-1;height:400px;overflow-y:auto;font-size:12px;line-height:1.6;border:1px solid var(--border);border-radius:6px;padding:10px;background:#0a0e13}
#logs .error{color:#ff7b72;background:#1a0a0a;padding:1px 4px;border-radius:3px;display:inline-block;max-width:100%;word-break:break-all}
#logs .warn{color:#ffa657;background:#1a1008;padding:1px 4px;border-radius:3px;display:inline-block;max-width:100%;word-break:break-all}
#logs .info{color:var(--muted)}
#logs .debug{color:#484f58}
#logs .highlight{color:var(--green);font-weight:700}
.btn{background:var(--card);color:var(--blue);border:1px solid var(--border);padding:6px 14px;border-radius:6px;cursor:pointer;font-size:12px;margin:3px}
.btn:hover{background:#1f2937;border-color:var(--blue)}
.btn-danger{color:var(--red);border-color:var(--red)}
.btn-danger:hover{background:#3a1a1a}
.slot-bar{height:8px;background:#21262d;border-radius:4px;overflow:hidden;margin:6px 0}
.slot-fill{height:100%;background:var(--blue);border-radius:4px;transition:width .3s}
.slot-fill.warn{background:var(--yellow)}
.slot-fill.danger{background:var(--red)}
.stats-grid{display:grid;grid-template-columns:1fr 1fr;gap:4px}
#toast{position:fixed;top:16px;right:16px;background:var(--green);color:#000;padding:10px 18px;border-radius:8px;font-weight:700;opacity:0;transition:opacity .3s;z-index:100}
#toast.show{opacity:1}
</style>
</head>
<body>
<h1>🧠 Jean Router — Dashboard</h1>
<div id="toast"></div>
<div class="grid">
  <div class="card">
    <h2>🔌 Statut</h2>
    <div class="row"><span class="label">PC Gaming</span><span id="pc-status">-</span></div>
    <div class="row"><span class="label">Jean (8090)</span><span id="jean-status">-</span></div>
    <div class="row"><span class="label">Ollama (11434)</span><span id="ollama-status">-</span></div>
    <div class="row"><span class="label">VRAM</span><span id="vram-status">-</span></div>
    <div class="row"><span class="label">Preset</span><span id="active-preset">-</span></div>
  </div>
  <div class="card">
    <h2>🎰 Slot Jean</h2>
    <div class="row"><span class="label">Status</span><span id="slot-status">-</span></div>
    <div class="row"><span class="label">Tokens prompt</span><span id="slot-prompt">-</span></div>
    <div class="row"><span class="label">Tokens decoded</span><span id="slot-decoded">-</span></div>
    <div class="slot-bar"><div class="slot-fill" id="slot-bar" style="width:0%"></div></div>
  </div>
  <div class="card">
    <h2>📊 Stats</h2>
    <div class="stats-grid">
      <div class="row"><span class="label">Total</span><span id="stat-total" class="value">0</span></div>
      <div class="row"><span class="label">Jean</span><span id="stat-jean" class="value">0</span></div>
      <div class="row"><span class="label">Ollama</span><span id="stat-ollama" class="value">0</span></div>
      <div class="row"><span class="label">Erreurs</span><span id="stat-errors" class="value">0</span></div>
    </div>
    <div style="margin-top:10px"><span class="label">Cache</span> <span id="cache-age" style="font-size:11px;color:var(--muted)">-</span></div>
  </div>
  <div class="card">
    <h2>⚡ Actions</h2>
    <button class="btn" onclick="action('refresh');setTimeout(fetchStatus,800)">🔄 Actualiser modèles Jean + Ollama</button>
    <button class="btn btn-danger" onclick="action('restart-jean')" title="Stop + Start Jean">🔁 Restart Jean</button>
    <div style="margin-top:8px">
      <span class="badge badge-blue" id="wol-badge">WoL: -</span>
      <span class="badge badge-green" id="cache-badge">Cache: -</span>
    </div>
  </div>
  <div class="card" style="grid-column:1/-1">
    <h2>🧩 Modèles Jean</h2>
    <div id="preset-list">-</div>
  </div>
</div>
<div class="card">
  <h2>📜 Logs <span style="color:var(--muted);font-weight:400;font-size:12px">(auto-scroll)</span></h2>
  <div id="logs"></div>
</div>

<script>
const $ = (s) => document.querySelector(s);
let autoScroll = true;

function fmt(n) { return n > 1000 ? Math.round(n/1000)+'k' : n; }

async function fetchStatus() {
  try {
    const r = await fetch('/api/dashboard/status');
    const d = await r.json();

    // Status dots
    $('#pc-status').innerHTML = (d.pc.alive
      ? '<span class="status-dot on"></span> ON'
      : '<span class="status-dot off"></span> OFF — WoL requis');
    $('#jean-status').innerHTML = (d.jean.alive
      ? '<span class="status-dot on"></span> UP'
      : (d.pc.alive ? '<span class="status-dot warn"></span> DOWN (PC ON)' : '<span class="status-dot off"></span> DOWN'));
    $('#ollama-status').innerHTML = (d.ollama.alive
      ? '<span class="status-dot on"></span> UP'
      : (d.pc.alive ? '<span class="status-dot warn"></span> DOWN (PC ON)' : '<span class="status-dot off"></span> DOWN'));
    $('#vram-status').innerHTML = (d.jean.vram_backend === 'jean'
      ? '<span class="badge badge-blue">JEAN</span>'
      : '<span class="badge badge-green">OLLAMA</span>');
    $('#active-preset').innerHTML = '<span class="badge badge-green">' + d.jean.active_preset + '</span>';

    // Slot
    if (d.jean.slot) {
      const s = d.jean.slot;
      $('#slot-status').innerHTML = s.processing ? '<span class="status-dot warn"></span> PROCESSING' : '<span class="status-dot on"></span> IDLE';
      $('#slot-prompt').innerText = fmt(s.n_prompt_tokens) + ' tokens';
      $('#slot-decoded').innerText = fmt(s.n_decoded) + ' tokens';
      const pct = Math.min(100, Math.round((s.n_decoded || 0) / 256000 * 100));
      const bar = $('#slot-bar');
      bar.style.width = pct + '%';
      bar.className = 'slot-fill' + (pct > 80 ? ' danger' : pct > 50 ? ' warn' : '');
    } else {
      $('#slot-status').innerHTML = '<span class="status-dot off"></span> N/A';
      $('#slot-prompt').innerText = '-';
      $('#slot-decoded').innerText = '-';
      $('#slot-bar').style.width = '0%';
    }

    // Stats
    $('#stat-total').innerText = d.stats.total;
    $('#stat-jean').innerText = d.stats.jean;
    $('#stat-ollama').innerText = d.stats.ollama;
    $('#stat-errors').innerText = d.stats.errors;
    $('#cache-age').innerText = 'Presets: ' + d.cache.presets_age + 's | Ollama: ' + d.cache.ollama_age + 's';
    $('#wol-badge').innerText = 'WoL: ' + (d.wol.enabled ? 'ON ' + d.wol.mac : 'OFF');
    $('#cache-badge').innerText = 'Cache TTL: ' + d.cache.ttl + 's';

    // Presets
    $('#preset-list').innerHTML = d.jean.presets.map(p =>
      '<span class="badge badge-blue">' + p.name +
      (p.reasoning === 'on' ? ' 🧠' : '') + '</span>'
    ).join(' ') || '<span style="color:var(--muted)">Aucun</span>';
  } catch(e) {
    console.error('Status fetch error:', e);
  }
}

function appendLog(msg) {
  const div = document.createElement('div');
  div.textContent = msg;
  if (msg.includes('[ERROR]') || msg.includes('[Erreur]')) div.className = 'error';
  else if (msg.includes('[WARNING]')) div.className = 'warn';
  else if (msg.includes('highlight')) div.className = 'highlight';
  else div.className = 'info';
  $('#logs').appendChild(div);
  if (autoScroll) {
    $('#logs').scrollTop = $('#logs').scrollHeight;
  }
}

$('#logs').addEventListener('scroll', () => {
  const el = $('#logs');
  autoScroll = el.scrollHeight - el.scrollTop - el.clientHeight < 40;
});

// SSE Log stream
const evtSource = new EventSource('/api/dashboard/logs/stream');
evtSource.onmessage = function(e) {
  const d = JSON.parse(e.data);
  if (d.type === 'init') {
    d.logs.forEach(msg => appendLog(msg));
  } else if (d.type === 'log') {
    appendLog(d.message);
  }
};
evtSource.onerror = function() { console.log('SSE reconnect...'); };

// Initial load
fetchStatus();

// Buttons
async function action(name) {
  try {
    const r = await fetch('/api/dashboard/actions/' + name, {method:'POST'});
    const j = await r.json();
    const toast = $('#toast');
    toast.textContent = j.ok ? '✓ ' + name + ' OK' : '✗ ' + (j.error || 'failed');
    toast.className = 'show';
    setTimeout(() => toast.className = '', 2000);
    if (name === 'refresh') fetchStatus();
  } catch(e) {
    alert('Action failed: ' + e);
  }
}

// Poll status every 10s
setInterval(fetchStatus, 10000);
</script>
</body>
</html>"""


@app.route("/", defaults={"path": ""}, methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"])
@app.route("/<path:path>", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"])
def proxy(path):
    """Proxy générique pour les autres endpoints"""
    if path.startswith("v1/chat/completions"):
        return chat_completions()

    upstream_url = f"http://{JEAN_PROXY_HOST}:{JEAN_PROXY_PORT}/{path}"
    headers = dict(request.headers)
    headers.pop("Host", None)

    try:
        resp = requests.request(
            method=request.method,
            url=upstream_url,
            headers=headers,
            data=request.get_data(),
            cookies=request.cookies,
            params=request.args,
            allow_redirects=False,
            stream=True,
            timeout=None,
        )
    except Exception as e:
        return Response(str(e), status=502)

    excluded = {"content-encoding", "content-length", "transfer-encoding", "connection"}
    response_headers = [
        (name, value) for name, value in resp.headers.items()
        if name.lower() not in excluded
    ]

    return Response(
        resp.raw,
        status=resp.status_code,
        headers=response_headers,
        direct_passthrough=True,
    )


if __name__ == "__main__":
    log.info(f"[Router] Démarrage sur port {LISTEN_PORT}")
    log.info(f"[Router] Jean Web: {JEAN_WEB_HOST}:{JEAN_WEB_PORT}")
    log.info(f"[Router] Jean Proxy: {JEAN_PROXY_HOST}:{JEAN_PROXY_PORT}")
    if ENABLE_OLLAMA:
        log.info(f"[Router] Ollama Proxy: {OLLAMA_PROXY_HOST}:{OLLAMA_PROXY_PORT}")
    else:
        log.info(f"[Router] Ollama: désactivé")
    app.run(host="0.0.0.0", port=LISTEN_PORT, threaded=True)