app.py

"""
CEDD — Streamlit Application
Bilingual demo interface: chat + real-time monitoring dashboard.
Interface de démonstration bilingue : chat + dashboard de surveillance en temps réel.
"""

import os
import sys
import json
import time
from datetime import datetime
import streamlit as st
import plotly.graph_objects as go

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from cedd.classifier import CEDDClassifier, LEVEL_LABELS
from cedd.feature_extractor import extract_features
from cedd.response_modulator import (
    get_llm_response,
    get_level_description,
    get_system_prompt,
    get_handoff_description,
    get_handoff_offer_message,
    get_counselor_intro,
    get_llm_response_as_counselor,
)
from cedd.session_tracker import SessionTracker

# ─── Configuration ─────────────────────────────────────────────────────────────
MODEL_PATH = "models/cedd_model.joblib"

LEVEL_COLORS = {0: "#2ecc71", 1: "#f1c40f", 2: "#e67e22", 3: "#e74c3c"}

# ─── Themes ─────────────────────────────────────────────────────────────────────
THEMES = {
    "light": {
        "bg_main":    "#c8d6e5",
        "bg_card":    "#dbe6f0",
        "bg_input":   "#eaf1f8",
        "bg_chat":    "#dbe6f0",
        "text_main":  "#0d1b2a",
        "text_muted": "#000000",
        "border":     "#9bb5cc",
        "chat_user":  "#a8d5b5",
        "chat_bot":   "#ccdae6",
        "pill_bg":          "#b8d4e8",
        "pill_bord":        "#7aaec8",
        "pill_text":        "#0d3a5c",
        "btn_primary_bg":   "#2e86c1",
        "btn_primary_text": "#ffffff",
    },
    "dark": {
        "bg_main":    "#0e1117",
        "bg_card":    "#1a1d27",
        "bg_input":   "#262b38",
        "bg_chat":    "#161922",
        "text_main":  "#e2e8f0",
        "text_muted": "#ffffff",
        "border":     "#c0c8d8",
        "chat_user":  "#1a3d2b",
        "chat_bot":   "#1e2130",
        "pill_bg":          "#1e2340",
        "pill_bord":        "#3b4680",
        "pill_text":        "#818cf8",
        "btn_primary_bg":   "#3b82f6",
        "btn_primary_text": "#ffffff",
    },
}


def get_theme_css(theme: str) -> str:
    t = THEMES[theme]
    return f"""
<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap">
<style>
    .stApp {{
        font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif !important;
    }}
    .stApp, [data-testid="stAppViewContainer"],
    .main .block-container {{
        background-color: {t['bg_main']} !important;
    }}
    [data-testid="stMain"] h1,
    [data-testid="stMain"] h2,
    [data-testid="stMain"] h3,
    [data-testid="stMain"] h4 {{
        color: {t['text_main']} !important;
    }}
    [data-testid="stMain"] p,
    [data-testid="stMain"] li,
    [data-testid="stMain"] label {{
        color: {t['text_main']} !important;
    }}
    hr {{ border-color: {t['border']} !important; opacity: 0.6; }}
    [data-baseweb="input"] {{
        border: 1px solid {t['border']} !important;
        border-radius: 20px !important;
        background-color: {t['bg_input']} !important;
        outline: none !important;
        box-shadow: none !important;
    }}
    [data-baseweb="input"] input {{
        background-color: {t['bg_input']} !important;
        color: {t['text_main']} !important;
        border: none !important;
        outline: none !important;
        box-shadow: none !important;
        caret-color: {t['text_main']} !important;
    }}
    [data-testid="metric-container"] {{
        background-color: {t['bg_card']} !important;
        border: 1px solid {t['border']} !important;
        border-radius: 8px;
    }}
    [data-testid="stMetricValue"], [data-testid="stMetricLabel"] {{
        color: {t['text_main']} !important;
    }}
    [data-testid="stExpander"] {{
        background-color: {t['bg_card']} !important;
        border: 1px solid {t['border']} !important;
    }}
    [data-testid="stExpander"] details {{
        border: 1px solid {t['border']} !important;
    }}
    [data-testid="stExpander"] summary,
    [data-testid="stExpander"] details[open] > summary,
    [data-testid="stExpander"] summary:hover,
    [data-testid="stExpander"] details[open] > summary:hover {{
        border: none !important;
        background-color: {t['bg_card']} !important;
        color: {t['text_main']} !important;
    }}
    [data-testid="stExpanderDetails"] {{
        background-color: {t['bg_card']} !important;
        border-color: {t['border']} !important;
    }}
    [data-testid="stExpander"] [data-testid="stIconMaterial"] {{
        color: {t['text_main']} !important;
    }}
    .stButton > button[kind="secondary"],
    [data-testid="stBaseButton-secondary"] {{
        background-color: {t['bg_card']} !important;
        color: {t['text_main']} !important;
        border-color: {t['border']} !important;
        font-size: 0.75rem !important;
    }}
    .stButton > button[kind="secondary"]:hover,
    [data-testid="stBaseButton-secondary"]:hover {{
        border-color: {t['text_muted']} !important;
    }}
    [data-testid="stFormSubmitButton"] > button,
    .stButton > button[kind="primary"],
    [data-testid="stBaseButton-primary"] {{
        background-color: {t['btn_primary_bg']} !important;
        color: {t['btn_primary_text']} !important;
        border-color: {t['btn_primary_bg']} !important;
    }}
    [data-testid="stFormSubmitButton"] > button:hover,
    .stButton > button[kind="primary"]:hover,
    [data-testid="stBaseButton-primary"]:hover {{
        filter: brightness(1.1);
    }}
    [data-testid="stMain"] [data-testid="stCaptionContainer"] p {{
        color: {t['text_muted']} !important;
    }}
    [data-testid="stMain"] [data-testid="stAlert"] {{
        background-color: {t['bg_card']} !important;
        border-color: {t['border']} !important;
    }}
    [data-testid="stMain"] [data-testid="stAlert"] p {{
        color: {t['text_main']} !important;
    }}
    [data-testid="stForm"],
    .stForm,
    [data-testid="stForm"] > div {{
        border: 1px solid {t['border']} !important;
        outline: none !important;
        box-shadow: none !important;
        border-radius: 12px !important;
        background: {t['bg_card']} !important;
        padding: 8px !important;
    }}
    pre, code {{
        background-color: {t['bg_input']} !important;
        color: {t['text_main']} !important;
        border-color: {t['border']} !important;
    }}
    [data-testid="stProgressBar"] > div {{
        background-color: {t['border']} !important;
    }}
    .chat-bubble-user {{
        background-color: {t['chat_user']} !important;
        color: {t['text_main']} !important;
    }}
    .chat-bubble-assistant {{
        background-color: {t['chat_bot']} !important;
        color: {t['text_main']} !important;
    }}
    .chat-bubble-counselor {{
        background: linear-gradient(135deg, #1a5276, #2471a3) !important;
        color: #ffffff !important;
        border: 1px solid #2980b9 !important;
    }}
    .chat-bubble-counselor .llm-badge {{
        color: #aed6f1 !important;
    }}
    .chat-container {{
        background: {t['bg_chat']} !important;
        border: 1px solid {t['border']} !important;
    }}
    .feature-pill {{
        background: {t['pill_bg']} !important;
        border-color: {t['pill_bord']} !important;
        color: {t['pill_text']} !important;
    }}
    .metric-card {{
        background: {t['bg_card']} !important;
        border-color: {t['border']} !important;
    }}
    [data-baseweb="select"] > div {{
        background-color: {t['bg_card']} !important;
        border-color: {t['border']} !important;
        color: {t['text_main']} !important;
    }}
    [data-baseweb="select"] [data-testid="stMarkdownContainer"] p,
    [data-baseweb="select"] span {{
        color: {t['text_main']} !important;
    }}
    [data-baseweb="select"] svg {{
        fill: {t['text_main']} !important;
    }}
    [data-baseweb="popover"] {{
        background-color: {t['bg_card']} !important;
    }}
    [data-baseweb="popover"] li {{
        background-color: {t['bg_card']} !important;
        color: {t['text_main']} !important;
    }}
    [data-baseweb="popover"] li:hover {{
        background-color: {t['bg_input']} !important;
    }}
    .proba-bar-track {{
        background: {t['border']}44 !important;
    }}
    [data-testid="stMetricValue"] {{
        font-size: 1.6rem !important;
        font-weight: 700 !important;
    }}
    [data-testid="stMetricLabel"] {{
        text-transform: uppercase;
        letter-spacing: 0.05em;
        font-size: var(--fs-xs) !important;
    }}
    hr {{
        margin: 8px 0 !important;
    }}
    [data-testid="stFormSubmitButton"] > button {{
        border-radius: 20px !important;
    }}
</style>
<script>
(function() {{
    const TEXT_COLOR = "{t['text_main']}";
    const BG_COLOR = "{t['bg_card']}";
    function fixExpanders() {{
        document.querySelectorAll('[data-testid="stExpander"] summary').forEach(function(s) {{
            s.style.setProperty('color', TEXT_COLOR, 'important');
            s.style.setProperty('background-color', BG_COLOR, 'important');
            s.querySelectorAll('*').forEach(function(el) {{
                if (el.tagName === 'svg') {{
                    el.style.setProperty('fill', TEXT_COLOR, 'important');
                }}
                el.style.setProperty('color', TEXT_COLOR, 'important');
            }});
        }});
    }}
    fixExpanders();
    var obs = new MutationObserver(fixExpanders);
    obs.observe(document.body, {{ childList: true, subtree: true, attributes: true }});
}})();
</script>
"""

LLM_SOURCE_INDICATOR = {
    "cohere":            ("🔵", "#39594d"),
    "groq":              ("🟠", "#f97316"),
    "gemini-flash":      ("💎", "#4285f4"),
    "claude-haiku":      ("🟣", "#7c3aed"),
    "fallback-statique": ("⚠️", "#f59e0b"),
    "cedd-system":       ("🧠", "#2980b9"),
    "counselor":         ("🧑‍⚕️", "#1a5276"),
}
LLM_DISPLAY_NAMES = {
    "cohere": "Cohere",
    "groq": "Groq",
    "gemini-flash": "Gemini",
    "claude-haiku": "Claude",
    "cedd-system": "CEDD",
    "counselor": "Alex — KHP",
}
LEVEL_EMOJIS = {0: "🟢", 1: "🟡", 2: "🟠", 3: "🔴"}
DEMO_USERS = {
    "fr": [
        "Shuchita (stable vert)",
        "Priyanka (amélioration)",
        "Amanda (fluctuant)",
        "Dominic (escalade)",
        "Guest (nouveau)",
    ],
    "en": [
        "Shuchita (stable green)",
        "Priyanka (improving)",
        "Amanda (fluctuating)",
        "Dominic (escalating)",
        "Guest (new)",
    ],
}


def _user_id_from_display(display_name):
    """Extract user_id from display name: 'Shuchita (stable green)' → 'Shuchita'"""
    return display_name.split(" (")[0]

# ─── Demo autopilot scenarios / Scénarios de démo automatisés ─────────────────
DEMO_SCENARIOS = {
    "fr": [
        "Salut! Ça fait longtemps que j'ai pas parlé à quelqu'un de juste... neutre, tsé? L'école recommence pis là c'est déjà intense. T'as des trucs pour gérer le stress des examens? Parce que je stresse déjà pour la session pis on est même pas rendus aux mi-sessions.",
        "Ouais c'est ça, j'essaie de faire des listes. Ça aide un peu. Hier j'ai quand même réussi à finir mon travail de bio pis à voir mes chums le soir, faque c'était correct. Mon chum Mathieu m'a montré une technique de respiration, je sais pas si ça marche vraiment mais on a ri en la faisant haha. C'est quoi les techniques que tu recommandes en général?",
        "Ouais, les pauses ça marche bien quand j'y pense. Le truc c'est que des fois je pense même pas à en prendre. Je suis genre scotché à mon bureau pis le temps passe. Mais bon, cette semaine ça devrait mieux aller, j'ai moins de cours jeudi-vendredi. Mathieu pis moi on pense aller au cinéma si on a le temps.",
        "Mmh ouais. Cette semaine a été rough. J'ai pas dormi super bien, genre je me réveille à 3h du mat pis j'arrive pu à me rendormir. C'est probablement le stress. J'ai annulé le cinéma avec Mathieu, j'avais trop de trucs à faire.",
        "C'est correct, je gère. C'est juste que des fois j'ai l'impression que tout le monde avance pis moi je tourne en rond. Mathieu il a l'air de trouver ça facile lui. Je sais pas trop. Anyway.",
        "Honnêtement j'sais plus trop. Chez nous c'est tendu depuis quelques semaines, mes parents sont pas dans leur meilleure forme. J'essaie de pas ramener mes affaires là-dedans mais c'est difficile. J'ai l'impression d'avoir nulle part où décompresser vraiment.",
        "Ouais je sais. C'est juste que je me sens fatigué de tout, pas juste de l'école. Comme... fatigué de tenir. Je dis ça pis ça a l'air dramatique mais c'est vraiment comme ça que je me sens ces temps-ci.",
        "Je sais pas. Peut-être. J'ai même plus vraiment envie de sortir. Mes chums me textent pis j'réponds même pu vraiment. C'est trop.",
        "C'est correct. De toute façon.",
    ],
    "en": [
        "Hey, just wanted to talk to someone tonight. Starting university is kind of a lot, honestly? Like it's exciting but also way more intense than I expected. How do people usually handle the adjustment? I feel like everyone else already has their thing figured out.",
        "That's actually helpful. I've been trying to go to the study sessions in my building. Made a couple of friends already — Jordan's been showing me around campus which is great. I had a rough week with assignments piling up but I got through it. Any tips for staying on top of things without burning out?",
        "Yeah the breaks thing makes sense. I keep telling myself I'll do that but then I just end up at my desk for like five hours straight. It's fine, I'm managing. Jordan and I were supposed to hang out this weekend, looking forward to that at least.",
        "Weekend ended up being kind of whatever. Jordan cancelled last minute, it's fine. Been tired lately, not sleeping great. I keep waking up in the middle of the night thinking about stuff. I don't know, probably just adjusting still.",
        "I'm okay. Just feel kind of behind on everything. Like everyone else knows what they're doing and I'm still figuring out how to do laundry. It sounds dumb when I say it out loud. Whatever.",
        "Honestly, I've just been staying in my room more. Home is kind of far so I can't just go back for the weekend. My roommate has his own friends and I don't really fit in their group. It just feels like there's nowhere to recharge, you know?",
        "Yeah, I know. It's just exhausting. Not like tired-exhausted, more like... I don't know how to explain it. Tired of trying to seem okay I guess. I haven't really talked to anyone back home in a while either.",
        "I don't know, maybe. I used to like being around people but now it just takes too much energy. Jordan texted me twice this week. Didn't answer. It's easier that way.",
        "It's fine. I'll figure it out.",
    ],
}

# ─── About CEDD content / Contenu À propos de CEDD ───────────────────────────
ABOUT_CEDD = {
    "fr": """**CEDD** (Conversational Emotional Drift Detection) est une couche de sécurité en temps réel pour les chatbots de santé mentale jeunesse (16-22 ans).

**Comment ça fonctionne :**
- Analyse **67 caractéristiques** par conversation (lexicales, sémantiques, comportementales)
- Surveille la **trajectoire** émotionnelle — pas juste un message, mais l'évolution complète
- **7 portes de sécurité** : les mots-clés de crise surpassent toujours le ML + détection de délai de réponse
- **Transfert accompagné** en 5 étapes vers Jeunesse, J'écoute au niveau Rouge

**Ce que vous voyez à droite :**
- 🎯 **Jauge** : niveau d'alerte actuel (Vert → Rouge)
- 📊 **Probabilités** : confiance du modèle par classe
- ⚡ **Signaux** : caractéristiques dominantes qui influencent le niveau
- 📈 **Historique** : évolution du niveau au fil des messages

**Philosophie :** Les faux positifs (sur-alerter) sont toujours préférables aux faux négatifs (manquer une crise).""",
    "en": """**CEDD** (Conversational Emotional Drift Detection) is a real-time safety layer for youth mental health chatbots (ages 16-22).

**How it works:**
- Analyzes **67 features** per conversation (lexical, semantic, behavioral)
- Monitors the emotional **trajectory** — not just one message, but the full evolution
- **7 safety gates**: crisis keywords always override ML + response delay detection
- **5-step warm handoff** to Kids Help Phone at Red level

**What you see on the right:**
- 🎯 **Gauge**: current alert level (Green → Red)
- 📊 **Probabilities**: model confidence per class
- ⚡ **Signals**: dominant features driving the alert level
- 📈 **History**: alert level evolution across messages

**Philosophy:** False positives (over-alerting) are always preferable to false negatives (missing a crisis).""",
}

# ─── Bilingual UI strings / Chaînes d'interface bilingues ─────────────────────
STRINGS = {
    "fr": {
        "lang_btn":            "🇬🇧 English",
        "page_title":          "CEDD - Détection de dérive émotionnelle",
        "app_title":           "🧠 CEDD — Détection de dérive émotionnelle conversationnelle",
        "app_subtitle":        "Hackathon Mila · Sécurité IA en santé mentale des jeunes · Équipe 404HarmNotFound",
        "theme_btn":           "🌙 Sombre",
        "reset_btn":           "🔄 Réinitialiser",
        "chat_header":         "### 💬 Conversation",
        "chat_empty":          "Commence la conversation...",
        "welcome_title":       "Bienvenue sur CEDD",
        "welcome_text":        "Un système de sécurité en temps réel qui surveille la trajectoire émotionnelle de ta conversation — pas juste un message, mais l'évolution complète.",
        "welcome_cta":         "Écris ton premier message ci-dessous ⬇️",
        "welcome_profiles":    "Essaie un profil de démo ↗️",
        "welcome_profile_list": "🟢 Shuchita — stable · 🟡 Priyanka — amélioration · 🔀 Amanda — fluctuant · 🔴 Dominic — escalade · ✨ Guest — nouveau",
        "input_placeholder":   "Écris ton message ici et appuie sur Entrée",
        "send_btn":            "Envoyer ➤",
        "dashboard_header":    "### 📊 Dashboard CEDD",
        "confidence":          "**Confiance**",
        "proba_header":        "**Probabilités par classe**",
        "signals_header":      "**Signaux actifs**",
        "signals_waiting":     "En attente d'analyse...",
        "history_header":      "**Évolution du niveau**",
        "history_waiting":     "Historique disponible après 2 messages.",
        "streamgraph_header":  "**Flux émotionnel**",
        "streamgraph_waiting": "Flux disponible après 2 messages.",
        "longitudinal_header": "### 📊 Historique longitudinal",
        "longitudinal_empty":  "Aucun historique — complétez des sessions pour voir la tendance.",
        "trend_stable":        "→ Stable",
        "trend_worsening":     "↗ En hausse",
        "trend_improving":     "↘ En amélioration",
        "llm_header":          "**LLM conversationnel**",
        "llm_last_call":       "Dernier appel :",
        "mode_header":         "**Mode de réponse actif**",
        "prompt_expander":     "Voir le prompt système complet",
        "stats_header":        "**Statistiques de session**",
        "stat_messages":       "Messages",
        "stat_exchanges":      "Échanges",
        "stat_peak":           "Pic alerte",
        "sessions_caption":    "Sessions analysées : {n}  •  Score longitudinal : {score:.0%}",
        "model_not_found":     "Modèle introuvable : {path}. Lancez d'abord `python train.py`.",
        "gauge_title":         "Niveau d'alerte",
        "level_labels":        {0: "VERT", 1: "JAUNE", 2: "ORANGE", 3: "ROUGE"},
        "gauge_ticks":         ["Vert", "Jaune", "Orange", "Rouge"],
        "proba_names": {
            "green": "Verte", "yellow": "Jaune", "orange": "Orange", "red": "Rouge"
        },
        # Internal recommendation keys from session_tracker (always French)
        # → mapped here for display / Clés internes → affichage traduit
        "rec_normal":       "Suivi normal",
        "rec_attention":    "Attention soutenue recommandée",
        "rec_consultation": "Consultation professionnelle suggérée",
        "rec_intervention": "Intervention prioritaire recommandée",
        "llm_fallback":     "sans LLM",
        "handoff_title":      "Transfert accompagné",
        "handoff_step_label": "Étape {step}/5 : <b>{desc}</b>",
        "withdrawal_banner":  "Bon retour. Ça fait un moment — comment tu te sens ?",
        "withdrawal_badge":   "Retour après absence",
        "feature_chart_title": "🔍 Signaux détectés",
        "feature_chart_note":  "Score composite = importance du modèle × valeur normalisée. Les barres montrent ce qui influence le plus le niveau d'alerte actuel.",
        "radar_title":         "🕸️ Radar des features",
        "profile_label":       "Profil",
        "demo_btn":            "▶️ Démo",
        "demo_stop_btn":       "⏹️ Arrêter",
        "demo_character_fr":   "Félix, 18 ans, CÉGEP",
        "demo_character_en":   "Alex, 19, université",
        "demo_running":        "Démo en cours — message {n}/9",
        "about_btn":           "ℹ️ À propos",
        "about_title":         "À propos de CEDD",
        "export_btn":          "📥 Exporter",
        "alert_toast_up":      "⚠️ Niveau d'alerte augmenté : {emoji} {label}",
        "llm_fallback_toast":  "🔄 {failed} a échoué (timeout) → basculé sur {active}",
        "compare_btn":         "🔀 Comparer",
        "compare_btn_off":     "🔀 Mode normal",
        "compare_left_header": "### 💬 Sans CEDD",
        "compare_left_sub":    "LLM brut — aucune instruction de sécurité",
        "compare_right_header":"### 🧠 Avec CEDD",
        "compare_right_sub":   "LLM guidé par les instructions CEDD adaptatives",
        "handoff_offer_yes":   "Oui, connecte-moi",
        "handoff_offer_no":    "Non merci",
        "counselor_banner_name": "Alex — Jeunesse, J'écoute / Kids Help Phone",
        "counselor_banner_sub":  "Conseiller·ère humain·e • En ligne maintenant",
        "counselor_connecting":  "Connexion avec Alex en cours...",
        "delay_badge":           "⏱️ Délai de réponse élevé",
    },
    "en": {
        "lang_btn":            "🇫🇷 Français",
        "page_title":          "CEDD - Conversational Emotional Drift Detection",
        "app_title":           "🧠 CEDD — Conversational Emotional Drift Detection",
        "app_subtitle":        "Mila Hackathon · AI Safety in Youth Mental Health · Team 404HarmNotFound",
        "theme_btn":           "🌙 Dark",
        "reset_btn":           "🔄 Reset",
        "chat_header":         "### 💬 Conversation",
        "chat_empty":          "Start the conversation...",
        "welcome_title":       "Welcome to CEDD",
        "welcome_text":        "A real-time safety layer that monitors the emotional trajectory of your conversation — not just one message, but the full evolution.",
        "welcome_cta":         "Type your first message below ⬇️",
        "welcome_profiles":    "Try a demo profile ↗️",
        "welcome_profile_list": "🟢 Shuchita — stable · 🟡 Priyanka — improving · 🔀 Amanda — fluctuating · 🔴 Dominic — escalating · ✨ Guest — new",
        "input_placeholder":   "Type your message here and press Enter",
        "send_btn":            "Send ➤",
        "dashboard_header":    "### 📊 CEDD Dashboard",
        "confidence":          "**Confidence**",
        "proba_header":        "**Class probabilities**",
        "signals_header":      "**Active signals**",
        "signals_waiting":     "Waiting for analysis...",
        "history_header":      "**Alert level history**",
        "history_waiting":     "History available after 2 messages.",
        "streamgraph_header":  "**Emotional flow**",
        "streamgraph_waiting": "Flow available after 2 messages.",
        "longitudinal_header": "### 📊 Longitudinal history",
        "longitudinal_empty":  "No history yet — complete sessions to see the trend.",
        "trend_stable":        "→ Stable",
        "trend_worsening":     "↗ Worsening",
        "trend_improving":     "↘ Improving",
        "llm_header":          "**Conversational LLM**",
        "llm_last_call":       "Last call:",
        "mode_header":         "**Active response mode**",
        "prompt_expander":     "View full system prompt",
        "stats_header":        "**Session statistics**",
        "stat_messages":       "Messages",
        "stat_exchanges":      "Exchanges",
        "stat_peak":           "Alert peak",
        "sessions_caption":    "Sessions analyzed: {n}  •  Longitudinal score: {score:.0%}",
        "model_not_found":     "Model not found: {path}. Run `python train.py` first.",
        "gauge_title":         "Alert level",
        "level_labels":        {0: "GREEN", 1: "YELLOW", 2: "ORANGE", 3: "RED"},
        "gauge_ticks":         ["Green", "Yellow", "Orange", "Red"],
        "proba_names": {
            "green": "Green", "yellow": "Yellow", "orange": "Orange", "red": "Red"
        },
        "rec_normal":       "Normal monitoring",
        "rec_attention":    "Sustained attention recommended",
        "rec_consultation": "Professional consultation suggested",
        "rec_intervention": "Priority intervention recommended",
        "llm_fallback":     "no LLM",
        "handoff_title":      "Warm Handoff",
        "handoff_step_label": "Step {step}/5: <b>{desc}</b>",
        "withdrawal_banner":  "Welcome back. It's been a while — how are you feeling?",
        "withdrawal_badge":   "Returned after absence",
        "feature_chart_title": "🔍 Detected signals",
        "feature_chart_note":  "Composite score = model importance × scaled value. Bars show what drives the current alert level most.",
        "radar_title":         "🕸️ Feature radar",
        "profile_label":       "Profile",
        "demo_btn":            "▶️ Demo",
        "demo_stop_btn":       "⏹️ Stop",
        "demo_character_fr":   "Félix, 18, CÉGEP",
        "demo_character_en":   "Alex, 19, university",
        "demo_running":        "Demo running — message {n}/9",
        "about_btn":           "ℹ️ About",
        "about_title":         "About CEDD",
        "export_btn":          "📥 Export",
        "alert_toast_up":      "⚠️ Alert level increased: {emoji} {label}",
        "llm_fallback_toast":  "🔄 {failed} failed (timeout) → switched to {active}",
        "compare_btn":         "🔀 Compare",
        "compare_btn_off":     "🔀 Single mode",
        "compare_left_header": "### 💬 Without CEDD",
        "compare_left_sub":    "Raw LLM — no safety instructions",
        "compare_right_header":"### 🧠 With CEDD",
        "compare_right_sub":   "LLM guided by CEDD adaptive instructions",
        "handoff_offer_yes":   "Yes, connect me",
        "handoff_offer_no":    "No thank you",
        "counselor_banner_name": "Alex — Jeunesse, J'écoute / Kids Help Phone",
        "counselor_banner_sub":  "Human Counselor • Online now",
        "counselor_connecting":  "Connecting you with Alex...",
        "delay_badge":           "⏱️ High response delay",
    },
}

# Maps English recommendation strings (from session_tracker) to STRINGS keys
# Mappe les recommandations anglaises (session_tracker) vers les clés STRINGS
_REC_KEY_MAP = {
    "Normal monitoring":                   "rec_normal",
    "Sustained attention recommended":     "rec_attention",
    "Professional consultation suggested": "rec_consultation",
    "Priority intervention recommended":   "rec_intervention",
}

# ─── Page config ────────────────────────────────────────────────────────────────
st.set_page_config(
    page_title="CEDD",
    page_icon="🧠",
    layout="wide",
    initial_sidebar_state="collapsed",
)

# ─── Static CSS (layout only — colors handled by get_theme_css) ─────────────────
st.markdown("""
<style>
    :root {
        --fs-xs: 0.72rem;
        --fs-sm: 0.8rem;
        --fs-base: 0.92rem;
        --fs-md: 1.0rem;
        --fs-lg: 1.15rem;
        --fs-xl: 1.3rem;
        --spacing-xs: 4px;
        --spacing-sm: 8px;
        --spacing-md: 12px;
        --spacing-lg: 16px;
        --spacing-xl: 24px;
        --radius-sm: 6px;
        --radius-md: 10px;
        --radius-lg: 16px;
        --radius-bubble: 18px;
    }
    .main { padding-top: 1rem; }
    .chat-container {
        display: flex;
        flex-direction: column;
        overflow-y: auto;
        max-height: 480px;
        padding: var(--spacing-md);
        border-radius: var(--radius-lg);
        margin-bottom: var(--spacing-md);
    }
    .chat-bubble-user {
        border-radius: var(--radius-bubble) var(--radius-bubble) 4px var(--radius-bubble);
        padding: var(--spacing-md) 14px;
        margin: var(--spacing-xs) 0 var(--spacing-xs) 15%;
        max-width: 85%;
        align-self: flex-end;
        font-size: var(--fs-base);
        line-height: 1.5;
        word-wrap: break-word;
        box-shadow: 0 1px 3px rgba(0,0,0,0.06);
        transition: transform 0.15s ease, box-shadow 0.15s ease;
    }
    .chat-bubble-user:hover {
        transform: translateY(-1px);
        box-shadow: 0 3px 8px rgba(0,0,0,0.1);
    }
    .chat-bubble-assistant {
        border-radius: var(--radius-bubble) var(--radius-bubble) var(--radius-bubble) 4px;
        padding: var(--spacing-md) 14px;
        margin: var(--spacing-xs) 15% var(--spacing-xs) 0;
        max-width: 85%;
        align-self: flex-start;
        font-size: var(--fs-base);
        line-height: 1.5;
        word-wrap: break-word;
        box-shadow: 0 1px 3px rgba(0,0,0,0.06);
        transition: transform 0.15s ease, box-shadow 0.15s ease;
    }
    .chat-bubble-assistant:hover {
        transform: translateY(-1px);
        box-shadow: 0 3px 8px rgba(0,0,0,0.1);
    }
    .chat-bubble-counselor {
        box-shadow: 0 2px 8px rgba(0,0,0,0.15);
    }
    .chat-bubble-counselor:hover {
        box-shadow: 0 4px 12px rgba(0,0,0,0.2);
    }
    .chat-time-user {
        font-size: var(--fs-xs);
        opacity: 0.5;
        text-align: right;
        margin: -2px 0 var(--spacing-xs) 0;
        align-self: flex-end;
    }
    .chat-time-assistant {
        font-size: var(--fs-xs);
        opacity: 0.5;
        text-align: left;
        margin: -2px 0 var(--spacing-xs) 0;
        align-self: flex-start;
    }
    .llm-badge {
        font-size: var(--fs-xs);
        opacity: 0.7;
        display: block;
        margin-top: 2px;
    }
    .alert-dot {
        font-size: var(--fs-xs);
        display: inline-block;
        align-self: flex-start;
        margin: 2px 0 var(--spacing-sm) 0;
    }
    .alert-badge {
        padding: var(--spacing-sm) var(--spacing-lg);
        border-radius: 20px;
        font-weight: bold;
        font-size: var(--fs-lg);
        display: inline-block;
    }
    .metric-card {
        border: 1px solid;
        border-radius: var(--radius-md);
        padding: var(--spacing-md);
        margin: var(--spacing-sm) 0;
        transition: border-color 0.2s ease, box-shadow 0.2s ease;
    }
    .feature-pill {
        border: 1px solid;
        border-radius: var(--radius-md);
        padding: var(--spacing-xs) var(--spacing-md);
        font-size: var(--fs-sm);
        display: inline-block;
        margin: 2px;
        transition: transform 0.15s ease, box-shadow 0.15s ease;
    }
    .feature-pill:hover {
        transform: translateY(-1px);
        box-shadow: 0 2px 6px rgba(0,0,0,0.08);
    }
    .status-card {
        padding: var(--spacing-sm) var(--spacing-md);
        border-radius: var(--radius-sm);
        margin: var(--spacing-xs) 0;
        border-left: 4px solid;
    }
    .welcome-card {
        text-align: center;
        margin: 30px var(--spacing-lg);
    }
    .welcome-card-inner {
        border-radius: 14px;
        padding: var(--spacing-xl) 20px;
        display: inline-block;
        max-width: 380px;
        border: 1px solid;
    }
    .welcome-card-icon { font-size: 2rem; margin-bottom: var(--spacing-sm); }
    .welcome-card-title { font-size: var(--fs-lg); font-weight: 700; margin-bottom: var(--spacing-sm); }
    .welcome-card-text { font-size: 0.88rem; opacity: 0.85; margin-bottom: var(--spacing-md); }
    .welcome-card-cta { font-size: var(--fs-sm); opacity: 0.7; }
    .welcome-card-profiles-title { font-size: 0.78rem; font-weight: 600; opacity: 0.8; margin-bottom: var(--spacing-xs); }
    .welcome-card-profiles { font-size: var(--fs-xs); opacity: 0.7; line-height: 1.6; }
    .counselor-banner {
        background: linear-gradient(135deg, #1a5276, #2980b9);
        border-radius: var(--radius-md);
        padding: var(--spacing-md) var(--spacing-lg);
        display: flex;
        align-items: center;
        gap: var(--spacing-md);
        margin-bottom: var(--spacing-lg);
    }
    .counselor-banner-icon { font-size: 1.4rem; }
    .counselor-banner-name { color: #fff; font-weight: 700; font-size: 14px; }
    .counselor-banner-sub { color: #aed6f1; font-size: 12px; }
    @keyframes alert-flash {
        0%   { opacity: 0; transform: translateY(-10px); }
        15%  { opacity: 1; transform: translateY(0); }
        85%  { opacity: 1; transform: translateY(0); }
        100% { opacity: 0; transform: translateY(-10px); }
    }
    .alert-toast {
        animation: alert-flash 3s ease-in-out forwards;
        position: fixed;
        top: 60px;
        left: 50%;
        transform: translateX(-50%);
        z-index: 9999;
        padding: var(--spacing-md) var(--spacing-xl);
        border-radius: var(--spacing-xl);
        font-weight: 700;
        font-size: var(--fs-base);
        box-shadow: 0 4px 16px rgba(0,0,0,0.2);
        pointer-events: none;
    }
    @keyframes pulse-red {
        0%, 100% { box-shadow: 0 0 0 0 rgba(231, 76, 60, 0.4); }
        50% { box-shadow: 0 0 0 8px rgba(231, 76, 60, 0); }
    }
    .alert-badge-pulse {
        animation: pulse-red 2s ease-in-out infinite;
    }
    /* Custom scrollbar for chat / Barre de défilement personnalisée */
    .chat-container::-webkit-scrollbar { width: 6px; }
    .chat-container::-webkit-scrollbar-track { background: transparent; }
    .chat-container::-webkit-scrollbar-thumb {
        background: rgba(128, 128, 128, 0.3);
        border-radius: 3px;
    }
    .chat-container::-webkit-scrollbar-thumb:hover { background: rgba(128, 128, 128, 0.5); }
    h1 { font-size: var(--fs-xl) !important; letter-spacing: -0.02em; }
    h3 { font-size: 1.05rem !important; margin-bottom: 0.4rem !important; letter-spacing: -0.01em; }
</style>
""", unsafe_allow_html=True)


# ─── Model & tracker loading ────────────────────────────────────────────────────
@st.cache_resource
def load_model():
    if not os.path.exists(MODEL_PATH):
        st.error(f"Model not found / Modèle introuvable : {MODEL_PATH}. Run `python train.py`.")
        st.stop()
    return CEDDClassifier.load(MODEL_PATH)


@st.cache_resource
def load_tracker():
    return SessionTracker()


# ─── Session state initialisation ───────────────────────────────────────────────
def init_state():
    defaults = {
        "messages":      [],
        "alert_history": [],
        "current_alert": {
            "level": 0, "label": "green", "confidence": 0.0,
            "dominant_features": [], "probabilities": {},
        },
        "selected_llm":    "cohere",
        "last_llm_source": None,
        "input_key":       0,
        "user_id":         "Guest",
        "session_id":      None,
        "lang":            "en",   # default language / langue par défaut
        "theme":           "light",
        "handoff_step":    0,      # 0 = not in handoff, 1-5 = warm handoff steps
        "withdrawal_detected": False,  # True if user returned after extended absence
        "demo_running":   False,    # True while demo autopilot is active
        "demo_step":      0,        # Current demo message index (0-8)
        "compare_mode":   False,    # True = side-by-side compare mode
        "compare_messages": [],     # "Without CEDD" message list (left side)
        "chat_mode":      "normal", # "normal" | "handoff_offered" | "connecting" | "human_mode"
        "handoff_offered": False,   # prevents re-offering once offered
    }
    for k, v in defaults.items():
        if k not in st.session_state:
            st.session_state[k] = v


def reset_conversation():
    st.session_state.messages      = []
    st.session_state.alert_history = []
    st.session_state.current_alert = {
        "level": 0, "label": "green", "confidence": 0.0,
        "dominant_features": [], "probabilities": {},
    }
    st.session_state.input_key += 1
    st.session_state.handoff_step = 0
    st.session_state.withdrawal_detected = False
    st.session_state.demo_running = False
    st.session_state.demo_step = 0
    st.session_state.compare_mode = False
    st.session_state.compare_messages = []
    st.session_state.chat_mode = "normal"
    st.session_state.handoff_offered = False


# ─── UI components / Composants UI ──────────────────────────────────────────────

def render_chat(S: dict, theme: str = "light", messages: list | None = None):
    """Display chat bubbles. / Affiche les bulles de conversation."""
    t = THEMES[theme]
    if messages is None:
        messages = st.session_state.messages
    msgs_html = '<div class="chat-container">'
    if not messages:
        msgs_html += (
            f'<div class="welcome-card">'
            f'<div class="welcome-card-inner" style="background:{t["bg_card"]};border-color:{t["border"]};">'
            f'<div class="welcome-card-icon">🧠</div>'
            f'<div class="welcome-card-title" style="color:{t["text_main"]};">'
            f'{S["welcome_title"]}</div>'
            f'<div class="welcome-card-text" style="color:{t["text_main"]};">'
            f'{S["welcome_text"]}</div>'
            f'<div class="welcome-card-cta" style="color:{t["text_muted"]};">'
            f'{S["welcome_cta"]}</div>'
            f'<hr style="border:none;border-top:1px solid {t["border"]};margin:14px 0 10px;">'
            f'<div class="welcome-card-profiles-title" style="color:{t["text_main"]};">'
            f'{S["welcome_profiles"]}</div>'
            f'<div class="welcome-card-profiles" style="color:{t["text_muted"]};">'
            f'{S["welcome_profile_list"]}</div>'
            f'</div></div>'
        )
    else:
        for msg in messages:
            role = msg["role"]
            content = (
                msg["content"]
                .replace("<", "&lt;")
                .replace(">", "&gt;")
                .replace("\n", "<br>")
            )
            ts = msg.get("timestamp", "")
            if role == "user":
                msgs_html += f'<div class="chat-bubble-user">{content}</div>'
                if ts:
                    msgs_html += f'<div class="chat-time-user" style="color:{t["text_muted"]};">{ts}</div>'
            else:
                # Assistant bubble + optional LLM badge
                is_counselor = msg.get("is_counselor", False)
                bubble = content
                source = msg.get("source")
                if source and source in LLM_SOURCE_INDICATOR:
                    src_emoji, src_color = LLM_SOURCE_INDICATOR[source]
                    src_name = LLM_DISPLAY_NAMES.get(source, source)
                    bubble += f'<span class="llm-badge" style="color:{src_color};">{src_emoji} {src_name}</span>'
                if is_counselor:
                    # Blue counselor bubble with avatar / Bulle bleue d'intervenant avec avatar
                    msgs_html += (
                        f'<div class="chat-bubble-assistant chat-bubble-counselor">'
                        f'<span style="font-size:1.1rem;margin-right:6px;">🧑‍⚕️</span>{bubble}</div>'
                    )
                else:
                    msgs_html += f'<div class="chat-bubble-assistant">{bubble}</div>'
                # Timestamp + alert dot row
                meta_parts = []
                alert_lvl = msg.get("alert_level")
                if alert_lvl is not None:
                    a_color = LEVEL_COLORS[alert_lvl]
                    a_emoji = LEVEL_EMOJIS[alert_lvl]
                    a_label = LEVEL_LABELS[alert_lvl]
                    meta_parts.append(
                        f'<span class="alert-dot" style="color:{a_color};">{a_emoji} {a_label.capitalize()}</span>'
                    )
                if ts:
                    meta_parts.append(f'<span style="opacity:0.5;">{ts}</span>')
                if meta_parts:
                    msgs_html += (
                        f'<div class="chat-time-assistant" style="color:{t["text_muted"]};">'
                        f'{" &nbsp;·&nbsp; ".join(meta_parts)}</div>'
                    )
    msgs_html += '</div>'
    st.markdown(msgs_html, unsafe_allow_html=True)


def render_gauge(level: int, confidence: float, S: dict, theme: str = "light"):
    """Circular alert-level gauge using Plotly. / Jauge circulaire du niveau d'alerte."""
    color = LEVEL_COLORS[level]
    label = S["level_labels"][level]
    emoji = LEVEL_EMOJIS[level]
    font_color = "#000000" if theme == "light" else "#ffffff"

    fig = go.Figure(go.Indicator(
        mode="gauge+number+delta",
        value=level,
        number={"suffix": f" {emoji}", "font": {"size": 28, "color": font_color}},
        title={"text": f'{S["gauge_title"]}<br><b>{label}</b>', "font": {"size": 14, "color": font_color}},
        gauge={
            "axis": {
                "range": [0, 4],
                "tickvals": [0, 1, 2, 3],
                "ticktext": S["gauge_ticks"],
                "tickfont": {"size": 10, "color": font_color},
            },
            "bar": {"color": color, "thickness": 0.3},
            "bgcolor": "white",
            "borderwidth": 2,
            "bordercolor": "#ccc",
            "steps": [
                {"range": [0, 1], "color": "#7dcea0"},
                {"range": [1, 2], "color": "#f7dc6f"},
                {"range": [2, 3], "color": "#f0a959"},
                {"range": [3, 4], "color": "#e74c3c"},
            ],
            "threshold": {
                "line": {"color": color, "width": 4},
                "thickness": 0.75,
                "value": level,
            },
        },
    ))
    fig.update_layout(
        height=220,
        margin=dict(t=30, b=10, l=20, r=20),
        paper_bgcolor="rgba(0,0,0,0)",
        font={"color": font_color},
    )
    st.plotly_chart(fig, use_container_width=True, config={"displayModeBar": False})

    # Confidence bar / Barre de confiance
    st.markdown(f'{S["confidence"]} : {confidence:.0%}')
    st.progress(confidence)


def render_proba_bars(probabilities: dict, S: dict, level: int = 0):
    """Class probability bars. / Barres de probabilité par classe."""
    if not probabilities:
        color = LEVEL_COLORS[level]
        emoji = LEVEL_EMOJIS[level]
        label = S["level_labels"][level]
        st.markdown(S["proba_header"])
        st.markdown(
            f'<div class="status-card" style="background:{color}22;border-left-color:{color};">'
            f'{emoji} <b>{label}</b> — safety rule override</div>',
            unsafe_allow_html=True,
        )
        return
    st.markdown(S["proba_header"])
    for label_name, proba in probabilities.items():
        level_num = {"green": 0, "yellow": 1, "orange": 2, "red": 3}[label_name]
        color     = LEVEL_COLORS[level_num]
        emoji     = LEVEL_EMOJIS[level_num]
        bar_width = int(proba * 100)
        display_name = S["proba_names"].get(label_name, label_name.capitalize())
        st.markdown(
            f'<div style="margin:3px 0;">'
            f'{emoji} <b>{display_name}</b> '
            f'<span style="float:right">{proba:.0%}</span>'
            f'<div class="proba-bar-track" style="border-radius:4px;height:8px;margin-top:2px;">'
            f'<div style="background:{color};width:{bar_width}%;height:8px;border-radius:4px;"></div>'
            f'</div></div>',
            unsafe_allow_html=True,
        )


def render_longitudinal_section(tracker: SessionTracker, user_id: str, S: dict, theme: str = "light"):
    """
    Longitudinal history section: bar chart + trend + recommendation.
    Section historique longitudinal : barres + tendance + recommandation.
    """
    history = tracker.get_user_history(user_id, last_n_sessions=7)
    risk    = tracker.get_longitudinal_risk(user_id)
    n       = risk["sessions_analyzed"]

    if n == 0:
        st.caption(S["longitudinal_empty"])
        return

    # ── Bar chart: max alert level per session ────────────────────────────────
    dates      = [s["started_at"][:10] for s in history]
    levels     = [s["max_alert_level"] for s in history]
    bar_colors = [LEVEL_COLORS[lvl] for lvl in levels]

    font_color = "#000000" if theme == "light" else "#ffffff"
    grid_color = "#9bb5cc" if theme == "light" else "#2d3748"

    fig = go.Figure(go.Bar(
        x=dates, y=levels,
        marker_color=bar_colors,
        hovertemplate="Session: %{x}<br>" + S["gauge_title"] + ": %{y}<extra></extra>",
    ))
    fig.update_layout(
        height=160,
        margin=dict(t=10, b=30, l=30, r=10),
        yaxis=dict(
            range=[0, 3.5],
            tickvals=[0, 1, 2, 3],
            ticktext=["🟢", "🟡", "🟠", "🔴"],
            tickfont=dict(size=12, color=font_color),
        ),
        xaxis=dict(tickfont=dict(size=9, color=font_color)),
        paper_bgcolor="rgba(0,0,0,0)",
        plot_bgcolor="rgba(0,0,0,0)",
        font=dict(color=font_color),
    )
    fig.update_xaxes(showgrid=False)
    fig.update_yaxes(showgrid=True, gridcolor=grid_color)
    st.plotly_chart(fig, use_container_width=True, config={"displayModeBar": False})

    # ── Trend / Tendance ──────────────────────────────────────────────────────
    trend_map = {
        "stable":    (S["trend_stable"],    "#6b7280"),
        "worsening": (S["trend_worsening"], "#e74c3c"),
        "improving": (S["trend_improving"], "#2ecc71"),
    }
    trend_label, trend_color = trend_map[risk["trend"]]
    st.markdown(
        f'<span style="color:{trend_color};font-weight:bold;">{trend_label}</span>',
        unsafe_allow_html=True,
    )

    # ── Recommendation / Recommandation ───────────────────────────────────────
    rec_key    = _REC_KEY_MAP.get(risk["recommendation"], "rec_normal")
    rec_display = S[rec_key]
    rec_color_map = {
        "rec_normal":       "#2ecc71",
        "rec_attention":    "#f1c40f",
        "rec_consultation": "#e67e22",
        "rec_intervention": "#e74c3c",
    }
    rc = rec_color_map.get(rec_key, "#6b7280")
    text_color = "#000000" if theme == "light" else "#ffffff"
    st.markdown(
        f'<div class="status-card" style="background:{rc}22;border-left-color:{rc};color:{text_color};">'
        f'<b>{rec_display}</b></div>',
        unsafe_allow_html=True,
    )
    st.caption(S["sessions_caption"].format(n=n, score=risk["risk_score"]))


def render_history_chart(S: dict, theme: str = "light"):
    """In-session alert level history chart. / Graphique historique de la session."""
    history = st.session_state.alert_history
    if len(history) < 2:
        st.info(S["history_waiting"])
        return

    font_color = "#000000" if theme == "light" else "#ffffff"
    grid_color = "#9bb5cc" if theme == "light" else "#2d3748"
    x      = list(range(1, len(history) + 1))
    colors = [LEVEL_COLORS[h["level"]] for h in history]

    fig = go.Figure()
    fig.add_trace(go.Scatter(
        x=x, y=[h["level"] for h in history],
        mode="lines+markers",
        line=dict(color="#6366f1", width=2),
        marker=dict(color=colors, size=10, line=dict(width=2, color="white")),
        name=S["gauge_title"],
        hovertemplate=f'Msg %{{x}}<br>{S["gauge_title"]}: %{{y}}<extra></extra>',
    ))
    fig.update_layout(
        height=150,
        margin=dict(t=10, b=30, l=30, r=10),
        yaxis=dict(
            range=[-0.2, 3.2],
            tickvals=[0, 1, 2, 3],
            ticktext=["🟢", "🟡", "🟠", "🔴"],
            tickfont=dict(size=14, color=font_color),
        ),
        xaxis=dict(title="Msg", tickfont=dict(size=10, color=font_color), title_font=dict(color=font_color)),
        paper_bgcolor="rgba(0,0,0,0)",
        plot_bgcolor="rgba(0,0,0,0)",
        showlegend=False,
        font=dict(color=font_color),
    )
    fig.update_xaxes(showgrid=True, gridcolor=grid_color)
    fig.update_yaxes(showgrid=True, gridcolor=grid_color)
    st.plotly_chart(fig, use_container_width=True, config={"displayModeBar": False})


def render_streamgraph(S: dict, theme: str = "light"):
    """Stacked area chart of class probabilities over time. / Graphique de flux émotionnel."""
    history = st.session_state.alert_history
    if len(history) < 2:
        st.caption(S["streamgraph_waiting"])
        return

    font_color = "#000000" if theme == "light" else "#ffffff"
    grid_color = "#9bb5cc" if theme == "light" else "#2d3748"
    x = list(range(1, len(history) + 1))

    classes = ["green", "yellow", "orange", "red"]
    series = {c: [] for c in classes}
    for h in history:
        probas = h.get("probabilities", {})
        if probas:
            for c in classes:
                series[c].append(probas.get(c, 0.0))
        else:
            level = h["level"]
            for i, c in enumerate(classes):
                series[c].append(1.0 if i == level else 0.0)

    is_fr = S.get("lang_btn", "").startswith("\U0001f1ec\U0001f1e7")
    display = {"green": ("Green", "Vert"), "yellow": ("Yellow", "Jaune"),
               "orange": ("Orange", "Orange"), "red": ("Red", "Rouge")}

    def hex_to_rgba(hex_color, alpha=0.5):
        r, g, b = int(hex_color[1:3], 16), int(hex_color[3:5], 16), int(hex_color[5:7], 16)
        return f"rgba({r},{g},{b},{alpha})"

    fig = go.Figure()
    for c in classes:
        label = display[c][1 if is_fr else 0]
        color = LEVEL_COLORS[classes.index(c)]
        fig.add_trace(go.Scatter(
            x=x, y=series[c],
            mode="lines",
            line=dict(width=0.5, color=color),
            fillcolor=hex_to_rgba(color, 0.5),
            stackgroup="one",
            name=label,
            hovertemplate=f"{label}: %{{y:.0%}}<extra></extra>",
        ))
    fig.update_layout(
        height=160,
        margin=dict(t=10, b=30, l=30, r=10),
        yaxis=dict(range=[0, 1], tickformat=".0%",
                   tickfont=dict(size=10, color=font_color)),
        xaxis=dict(title="Msg", tickfont=dict(size=10, color=font_color),
                   title_font=dict(color=font_color)),
        paper_bgcolor="rgba(0,0,0,0)",
        plot_bgcolor="rgba(0,0,0,0)",
        showlegend=True,
        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="center",
                    x=0.5, font=dict(size=9, color=font_color)),
        font=dict(color=font_color),
    )
    fig.update_xaxes(showgrid=True, gridcolor=grid_color)
    fig.update_yaxes(showgrid=True, gridcolor=grid_color)
    st.plotly_chart(fig, use_container_width=True, config={"displayModeBar": False})


def render_dominant_features(features: list, S: dict):
    """Display dominant features as pills. / Affiche les features dominantes en pills."""
    if not features:
        st.caption(S["signals_waiting"])
        return
    pills_html = "".join(
        f'<span class="feature-pill">⚡ {f}</span>' for f in features
    )
    st.markdown(pills_html, unsafe_allow_html=True)


# ─── Feature importance chart / Graphique d'importance des signaux ────────────

# Maps raw feature name prefixes to category colors
# Mappe les préfixes de noms bruts aux couleurs de catégorie
def _feature_color(raw_name: str) -> str:
    if raw_name.startswith("finality_score") or raw_name == "crisis_similarity":
        return "#e74c3c"   # red — crisis/finality
    if raw_name.startswith("negative_score") or raw_name.startswith("negation_score"):
        return "#e67e22"   # orange — negative/negation
    if raw_name.startswith("hope_score"):
        return "#27ae60"   # green — hope
    if raw_name.startswith("identity_conflict") or raw_name.startswith("somatization"):
        return "#9b59b6"   # purple — identity/cultural
    if raw_name.startswith(("short_response", "min_topic", "question_response",
                            "embedding_drift", "embedding_slope", "embedding_variance")):
        return "#1abc9c"   # teal — behavioral/coherence
    return "#3498db"       # blue — structural (word_count, punctuation, length_delta)


def render_feature_chart(feature_scores: list, S: dict, theme: str = "light"):
    """Horizontal bar chart of top feature scores. / Barres horizontales des scores de signaux."""
    if not feature_scores:
        return

    names  = [fs["name"] for fs in reversed(feature_scores)]
    scores = [fs["score"] for fs in reversed(feature_scores)]
    colors = [_feature_color(fs["raw_name"]) for fs in reversed(feature_scores)]

    font_color = "#000000" if theme == "light" else "#ffffff"

    fig = go.Figure(go.Bar(
        x=scores,
        y=names,
        orientation="h",
        marker_color=colors,
        hovertemplate="%{y}: %{x:.3f}<extra></extra>",
    ))
    fig.update_layout(
        height=max(120, 40 * len(names)),
        margin=dict(t=5, b=5, l=5, r=5),
        xaxis=dict(
            showticklabels=False,
            showgrid=False,
            zeroline=False,
        ),
        yaxis=dict(
            tickfont=dict(size=11, color=font_color),
            automargin=True,
        ),
        paper_bgcolor="rgba(0,0,0,0)",
        plot_bgcolor="rgba(0,0,0,0)",
        font=dict(color=font_color),
    )
    st.plotly_chart(fig, use_container_width=True, config={"displayModeBar": False})
    st.caption(S["feature_chart_note"])


# ─── Radar chart for per-message features / Graphique radar des features par message ──

# Feature names for radar axes / Noms des features pour les axes du radar
_RADAR_NAMES = {
    "fr": [
        "Longueur", "Ponctuation", "Questions", "Négatif", "Finalité",
        "Espoir", "Δ Longueur", "Négation", "Conflit id.", "Somatisation",
    ],
    "en": [
        "Length", "Punctuation", "Questions", "Negative", "Finality",
        "Hope", "Δ Length", "Negation", "Identity", "Somatization",
    ],
}


def render_radar_chart(messages: list, S: dict, theme: str = "light", lang: str = "en"):
    """Radar chart of the 10 per-message features for the latest message."""
    if not messages or not any(m["role"] == "user" for m in messages):
        return

    features_matrix = extract_features(messages)  # (n_user_msgs, 10)
    if features_matrix.shape[0] < 1:
        return

    names = _RADAR_NAMES.get(lang, _RADAR_NAMES["en"])
    font_color = "#000000" if theme == "light" else "#ffffff"
    grid_color = "rgba(155,181,204,0.25)" if theme == "light" else "rgba(45,55,72,0.25)"

    # Normalize features to 0-1 range for display / Normaliser les features entre 0 et 1
    latest = features_matrix[-1].copy()

    # Per-feature normalization with sensible max values
    # Normalisation par feature avec des valeurs max raisonnables
    max_vals = [
        80.0,   # word_count — typical max ~80 words
        0.15,   # punctuation_ratio — typical max ~0.15
        1.0,    # question_presence — binary 0/1
        0.5,    # negative_score — ratio, rarely above 0.5
        0.3,    # finality_score — ratio, rarely above 0.3
        0.5,    # hope_score — ratio, rarely above 0.5
        1.0,    # length_delta — relative, clamp to [-1, 1]
        0.3,    # negation_score — ratio
        0.3,    # identity_conflict — ratio
        0.3,    # somatization — ratio
    ]
    normalized = []
    for i, val in enumerate(latest):
        if i == 6:  # length_delta can be negative — use absolute
            normalized.append(min(abs(val) / max_vals[i], 1.0))
        else:
            normalized.append(min(val / max_vals[i], 1.0) if max_vals[i] > 0 else 0.0)

    # Close the polygon / Fermer le polygone
    plot_vals = normalized + [normalized[0]]
    plot_names = names + [names[0]]

    fig = go.Figure()

    # Show first message as ghost overlay if we have 3+ messages
    # Afficher le premier message en overlay fantôme si 3+ messages
    if features_matrix.shape[0] >= 3:
        first = features_matrix[0].copy()
        first_norm = []
        for i, val in enumerate(first):
            if i == 6:
                first_norm.append(min(abs(val) / max_vals[i], 1.0))
            else:
                first_norm.append(min(val / max_vals[i], 1.0) if max_vals[i] > 0 else 0.0)
        first_plot = first_norm + [first_norm[0]]
        fig.add_trace(go.Scatterpolar(
            r=first_plot, theta=plot_names,
            fill="toself",
            fillcolor="rgba(46, 204, 113, 0.08)",
            line=dict(color="rgba(46, 204, 113, 0.3)", width=1),
            name="Msg 1",
        ))

    # Latest message — convert hex color to rgba for Plotly Scatterpolar
    level = st.session_state.current_alert.get("level", 0)
    color = LEVEL_COLORS[level]
    # Convert hex #rrggbb to rgba(r,g,b,a)
    r, g, b = int(color[1:3], 16), int(color[3:5], 16), int(color[5:7], 16)
    fig.add_trace(go.Scatterpolar(
        r=plot_vals, theta=plot_names,
        fill="toself",
        fillcolor=f"rgba({r},{g},{b},0.13)",
        line=dict(color=color, width=2),
        name=f"Msg {features_matrix.shape[0]}",
    ))

    fig.update_layout(
        polar=dict(
            radialaxis=dict(
                visible=True, range=[0, 1],
                showticklabels=False,
                gridcolor=grid_color,
                linecolor=grid_color,
            ),
            angularaxis=dict(
                tickfont=dict(size=9, color=font_color),
                gridcolor=grid_color,
                linecolor=grid_color,
            ),
            bgcolor="rgba(0,0,0,0)",
        ),
        showlegend=True,
        legend=dict(font=dict(size=9, color=font_color), orientation="h", y=-0.1),
        height=250,
        margin=dict(t=20, b=30, l=30, r=30),
        paper_bgcolor="rgba(0,0,0,0)",
        font=dict(color=font_color),
    )
    st.plotly_chart(fig, use_container_width=True, config={"displayModeBar": False})


# ─── Main application / Application principale ──────────────────────────────────
def main():
    init_state()

    # Propagate Streamlit secrets to environment for LLM providers
    # Propager les secrets Streamlit vers l'environnement pour les fournisseurs LLM
    for key in ("COHERE_API_KEY", "GROQ_API_KEY", "GEMINI_API_KEY", "ANTHROPIC_API_KEY"):
        if key not in os.environ:
            try:
                os.environ[key] = st.secrets[key]
            except (KeyError, FileNotFoundError):
                pass

    clf     = load_model()
    tracker = load_tracker()
    lang    = st.session_state.lang
    theme   = st.session_state.theme
    S       = STRINGS[lang]

    st.markdown(get_theme_css(theme), unsafe_allow_html=True)

    # Alert transition toast (rendered once, cleared after display)
    # Toast de transition d'alerte (affiché une fois, effacé après)
    toast_level = st.session_state.pop("_alert_toast", None)
    if toast_level is not None:
        t_color = LEVEL_COLORS[toast_level]
        t_emoji = LEVEL_EMOJIS[toast_level]
        t_label = S["level_labels"][toast_level]
        toast_msg = S["alert_toast_up"].format(emoji=t_emoji, label=t_label)
        pulse_cls = " alert-badge-pulse" if toast_level == 3 else ""
        st.markdown(
            f'<div class="alert-toast{pulse_cls}" style="background:{t_color};color:#fff;">'
            f'{toast_msg}</div>',
            unsafe_allow_html=True,
        )

    # LLM fallback toast (rendered once, cleared after display)
    # Toast de basculement LLM (affiché une fois, effacé après)
    fallback_info = st.session_state.pop("_llm_fallback_toast", None)
    if fallback_info:
        toast_msg = S["llm_fallback_toast"].format(
            failed=fallback_info["failed"],
            active=fallback_info["active"],
        )
        st.markdown(
            f'<div class="alert-toast" style="background:#e67e22;color:#fff;">'
            f'{toast_msg}</div>',
            unsafe_allow_html=True,
        )

    # Start a session if needed (first visit or after reset)
    # Démarrer une session si nécessaire (première visite ou après reset)
    if st.session_state.session_id is None:
        # Check for withdrawal risk before starting new session
        # Vérifier le risque d'abandon avant de démarrer une nouvelle session
        withdrawal = tracker.check_withdrawal_risk(st.session_state.user_id)
        if withdrawal["is_withdrawal"]:
            st.session_state.withdrawal_detected = True
        st.session_state.session_id = tracker.start_session(st.session_state.user_id)

    # ── Header ─────────────────────────────────────────────────────────────────
    col_title, col_profile, col_lang, col_theme, col_reset = st.columns([3, 1.5, 1, 1, 1])
    with col_title:
        st.markdown(f"# {S['app_title']}")
        # Team badge: shield with "404" = "harm not found" / Badge d'équipe : bouclier "404"
        team_badge = (
            '<span style="display:inline-flex;align-items:center;gap:4px;'
            'background:linear-gradient(135deg,#1a5276,#2ecc71);color:#fff;'
            'padding:2px 8px 2px 6px;border-radius:10px;font-size:0.7rem;font-weight:700;'
            'letter-spacing:0.3px;vertical-align:middle;margin-left:4px;">'
            '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" '
            'xmlns="http://www.w3.org/2000/svg" style="vertical-align:middle;">'
            '<path d="M12 2L3 7v5c0 5.55 3.84 10.74 9 12 5.16-1.26 9-6.45 9-12V7L12 2z" '
            'fill="#2ecc71" stroke="#fff" stroke-width="1.5"/>'
            '<text x="12" y="15" text-anchor="middle" fill="#fff" '
            'font-size="8" font-weight="bold" font-family="monospace">404</text>'
            '</svg>'
            '404HarmNotFound</span>'
        )
        st.markdown(
            f'<p style="font-size:0.85rem;color:rgba(128,128,128,0.8);margin-top:-10px;">'
            f'{S["app_subtitle"].rsplit("404HarmNotFound", 1)[0]}{team_badge}</p>',
            unsafe_allow_html=True,
        )

    with col_profile:
        st.markdown("<br>", unsafe_allow_html=True)
        display_list = DEMO_USERS[lang]
        bare_names = [_user_id_from_display(d) for d in display_list]
        current_idx = bare_names.index(st.session_state.user_id) if st.session_state.user_id in bare_names else len(display_list) - 1
        selected_display = st.selectbox(
            S["profile_label"],
            display_list,
            index=current_idx,
            key="profile_selector",
            label_visibility="collapsed",
        )
        selected_user = _user_id_from_display(selected_display)
        if selected_user != st.session_state.user_id:
            # End current session before switching / Clôturer la session avant de changer
            max_lvl = max((h["level"] for h in st.session_state.alert_history), default=0)
            n_user = sum(1 for m in st.session_state.messages if m["role"] == "user")
            tracker.end_session(
                st.session_state.user_id, st.session_state.session_id,
                max_lvl, n_user,
            )
            reset_conversation()
            st.session_state.user_id = selected_user
            st.session_state.session_id = None
            st.rerun()

    with col_lang:
        st.markdown("<br>", unsafe_allow_html=True)
        if st.button(S["lang_btn"], use_container_width=True):
            st.session_state.lang = "en" if lang == "fr" else "fr"
            st.rerun()

    with col_theme:
        st.markdown("<br>", unsafe_allow_html=True)
        theme_label = "☀️ Light" if theme == "dark" else "🌙 Dark"
        if st.button(theme_label, use_container_width=True):
            st.session_state.theme = "light" if theme == "dark" else "dark"
            st.rerun()

    with col_reset:
        st.markdown("<br>", unsafe_allow_html=True)
        if st.button(S["reset_btn"], use_container_width=True):
            # Close the current session before resetting
            # Clôturer la session courante avant de réinitialiser
            max_lvl  = max((h["level"] for h in st.session_state.alert_history), default=0)
            n_user   = sum(1 for m in st.session_state.messages if m["role"] == "user")
            tracker.end_session(
                st.session_state.user_id, st.session_state.session_id,
                max_lvl, n_user,
            )
            tracker.mark_session_closed(st.session_state.user_id)
            reset_conversation()
            st.session_state.session_id = None
            st.rerun()

    st.divider()

    # ── Main layout: Chat | Dashboard ──────────────────────────────────────────
    col_chat, col_dash = st.columns([3, 2], gap="medium")

    # ── LEFT: Chat interface / GAUCHE : Interface de chat ─────────────────────
    with col_chat:
        st.markdown(S["chat_header"])

        # Action buttons row: Demo, About, Export, Compare / Boutons d'action
        btn_cols = st.columns([1, 1, 1, 1, 2])
        with btn_cols[0]:
            if st.session_state.compare_mode:
                st.button(S["demo_btn"], use_container_width=True, disabled=True)
            elif st.session_state.demo_running:
                if st.button(S["demo_stop_btn"], use_container_width=True):
                    st.session_state.demo_running = False
                    st.session_state.demo_step = 0
                    st.rerun()
            else:
                if st.button(S["demo_btn"], use_container_width=True):
                    reset_conversation()
                    st.session_state.demo_running = True
                    st.session_state.demo_step = 0
                    st.rerun()
        with btn_cols[1]:
            if st.button(S["about_btn"], use_container_width=True):
                st.session_state["show_about"] = not st.session_state.get("show_about", False)
                st.rerun()
        with btn_cols[2]:
            if st.session_state.messages:
                export_data = {
                    "session_id": st.session_state.session_id,
                    "user_id": st.session_state.user_id,
                    "language": lang,
                    "exported_at": datetime.now().isoformat(),
                    "messages": st.session_state.messages,
                    "alert_history": [
                        {
                            "level": a["level"],
                            "label": a.get("label", ""),
                            "confidence": a.get("confidence", 0),
                            "dominant_features": a.get("dominant_features", []),
                        }
                        for a in st.session_state.alert_history
                    ],
                    "peak_alert": max((a["level"] for a in st.session_state.alert_history), default=0),
                }
                st.download_button(
                    S["export_btn"],
                    data=json.dumps(export_data, indent=2, ensure_ascii=False, default=str),
                    file_name=f"cedd_transcript_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
                    mime="application/json",
                    use_container_width=True,
                )

        with btn_cols[3]:
            compare_label = S["compare_btn_off"] if st.session_state.compare_mode else S["compare_btn"]
            if st.button(compare_label, use_container_width=True):
                new_mode = not st.session_state.compare_mode
                reset_conversation()
                st.session_state.compare_mode = new_mode
                st.rerun()

        # About CEDD panel / Panneau À propos de CEDD
        if st.session_state.get("show_about", False):
            with st.expander(S["about_title"], expanded=True):
                st.markdown(ABOUT_CEDD[lang])

        # Demo running banner / Bannière de démo en cours
        if st.session_state.demo_running:
            scenario = DEMO_SCENARIOS[lang]
            step = st.session_state.demo_step
            char_key = "demo_character_fr" if lang == "fr" else "demo_character_en"
            st.info(f"🎬 {S[char_key]} — {S['demo_running'].format(n=step + 1)}")

        # Withdrawal banner / Bannière de retour après absence
        if st.session_state.withdrawal_detected and not st.session_state.messages:
            st.info(S["withdrawal_banner"])

        # Counselor banner / Bannière d'intervenant Alex
        if st.session_state.chat_mode == "human_mode":
            st.markdown(
                f'<div class="counselor-banner">'
                f'<span class="counselor-banner-icon">🟢</span>'
                f'<div>'
                f'<div class="counselor-banner-name">{S["counselor_banner_name"]}</div>'
                f'<div class="counselor-banner-sub">{S["counselor_banner_sub"]}</div>'
                f'</div></div>',
                unsafe_allow_html=True,
            )

        # Compare mode: show two chat columns / Mode comparaison : deux colonnes de chat
        if st.session_state.compare_mode:
            cmp_left, cmp_right = st.columns(2, gap="small")
            with cmp_left:
                st.markdown(S["compare_left_header"])
                st.caption(S["compare_left_sub"])
                render_chat(S, theme, messages=st.session_state.compare_messages)
            with cmp_right:
                st.markdown(S["compare_right_header"])
                st.caption(S["compare_right_sub"])
                render_chat(S, theme)
        else:
            render_chat(S, theme)

        # ── Handoff offer buttons / Boutons de proposition de transfert ─────────
        if st.session_state.chat_mode == "handoff_offered":
            col_yes, col_no = st.columns(2)
            if col_yes.button(
                "💙 " + S["handoff_offer_yes"],
                key="handoff_yes",
                type="primary",
                use_container_width=True,
            ):
                st.session_state.chat_mode = "connecting"
                st.rerun()
            if col_no.button(
                S["handoff_offer_no"],
                key="handoff_no",
                use_container_width=True,
            ):
                st.session_state.chat_mode = "normal"
                # Generate normal Red-level response for declined handoff
                # Générer une réponse normale niveau Rouge si le transfert est refusé
                with st.spinner("..."):
                    result = get_llm_response(
                        st.session_state.messages,
                        3,
                        force_model=st.session_state.selected_llm,
                        lang=lang,
                        handoff_step=st.session_state.handoff_step,
                    )
                if result["content"]:
                    st.session_state.messages.append({
                        "role": "assistant",
                        "content": result["content"],
                        "timestamp": datetime.now().strftime("%H:%M"), "timestamp_dt": datetime.now(),
                        "source": result["source"],
                        "alert_level": 3,
                    })
                    st.session_state.last_llm_source = result["source"]
                    if result.get("failed_models"):
                        st.session_state["_llm_fallback_toast"] = {
                            "failed": ", ".join(result["failed_models"]),
                            "active": result["source"],
                        }
                st.rerun()

        # ── Connecting to counselor / Connexion à l'intervenant ───────────────
        elif st.session_state.chat_mode == "connecting":
            with st.spinner(S["counselor_connecting"]):
                time.sleep(2)
            intro = get_counselor_intro(lang)
            st.session_state.messages.append({
                "role": "assistant",
                "content": intro,
                "timestamp": datetime.now().strftime("%H:%M"), "timestamp_dt": datetime.now(),
                "source": "counselor",
                "alert_level": 3,
                "is_counselor": True,
            })
            st.session_state.chat_mode = "human_mode"
            st.rerun()

        # ── Normal / Human mode input / Saisie normale ou mode intervenant ────
        else:
            # Input form / Zone de saisie
            with st.form(key=f"chat_form_{st.session_state.input_key}", clear_on_submit=True):
                user_input = st.text_input(
                    S["input_placeholder"],
                    placeholder=S["input_placeholder"],
                    label_visibility="collapsed",
                )
                submitted = st.form_submit_button(S["send_btn"], use_container_width=True)

            # Demo autopilot: inject next message / Démo automatique : injecter le prochain message
            if st.session_state.demo_running:
                scenario = DEMO_SCENARIOS[lang]
                step = st.session_state.demo_step
                if step < len(scenario):
                    user_msg = scenario[step]
                    submitted = True
                    user_input = user_msg
                    st.session_state.demo_step += 1
                    if st.session_state.demo_step >= len(scenario):
                        st.session_state.demo_running = False

            if submitted and user_input.strip():
                user_msg = user_input.strip()

                # Add user message / Ajouter le message utilisateur
                now = datetime.now().strftime("%H:%M")
                st.session_state.messages.append({"role": "user", "content": user_msg, "timestamp": now, "timestamp_dt": datetime.now()})

                # ── Human counselor mode: bypass CEDD, use Alex persona ───────
                if st.session_state.chat_mode == "human_mode":
                    with st.spinner("..."):
                        result = get_llm_response_as_counselor(
                            st.session_state.messages,
                            lang=lang,
                            force_model=st.session_state.selected_llm,
                        )
                    st.session_state.last_llm_source = result["source"]
                    if result.get("failed_models"):
                        st.session_state["_llm_fallback_toast"] = {
                            "failed": ", ".join(result["failed_models"]),
                            "active": result["source"],
                        }
                    if result["content"]:
                        st.session_state.messages.append({
                            "role": "assistant",
                            "content": result["content"],
                            "timestamp": datetime.now().strftime("%H:%M"), "timestamp_dt": datetime.now(),
                            "source": "counselor",
                            "alert_level": 3,
                            "is_counselor": True,
                        })
                    st.rerun()

                # ── Normal CEDD mode ──────────────────────────────────────────
                else:
                    # Compare mode: also add user message to left side / Mode comparaison : ajouter aussi à gauche
                    if st.session_state.compare_mode:
                        st.session_state.compare_messages.append({"role": "user", "content": user_msg, "timestamp": now})

                    # Track previous alert level for transition animation
                    # Suivre le niveau précédent pour l'animation de transition
                    prev_level = st.session_state.alert_history[-1]["level"] if st.session_state.alert_history else 0

                    # Compute response delay (time since last assistant message)
                    # Calcul du délai de réponse (temps depuis le dernier message assistant)
                    response_delay_s = None
                    for m in reversed(st.session_state.messages):
                        if m["role"] == "assistant" and "timestamp_dt" in m:
                            response_delay_s = (datetime.now() - m["timestamp_dt"]).total_seconds()
                            break

                    # Analyse with CEDD before generating the LLM response
                    # Analyser avec CEDD avant de générer la réponse
                    alert = clf.get_alert_level(st.session_state.messages, lang=lang,
                                                response_delay_s=response_delay_s)
                    st.session_state.current_alert = alert
                    st.session_state.alert_history.append(alert)

                    # Alert transition toast / Toast de transition d'alerte
                    if alert["level"] > prev_level:
                        st.session_state["_alert_toast"] = alert["level"]

                    # Log alert to cross-session tracker / Enregistrer dans le tracker
                    tracker.log_alert(
                        st.session_state.user_id,
                        st.session_state.session_id,
                        alert["level"],
                        alert["confidence"],
                        user_msg,
                    )

                    # Update last activity for withdrawal detection / MAJ activité pour détection d'abandon
                    tracker.update_last_activity(st.session_state.user_id, st.session_state.session_id)

                    # Warm handoff step management / Gestion des étapes de transfert accompagné
                    if alert["level"] == 3:
                        if st.session_state.handoff_step == 0:
                            # First Red detection — start handoff at step 1
                            # Première détection Rouge — démarrer le transfert à l'étape 1
                            st.session_state.handoff_step = 1
                        elif st.session_state.handoff_step < 5:
                            # Advance to next step / Avancer à l'étape suivante
                            st.session_state.handoff_step += 1
                        # If already at step 5, stay at step 5 (continued presence)
                        # Si déjà à l'étape 5, rester à 5 (présence continue)

                        # Log handoff step / Enregistrer l'étape de transfert
                        tracker.log_handoff_step(
                            st.session_state.user_id,
                            st.session_state.session_id,
                            st.session_state.handoff_step,
                            alert["level"],
                        )
                    # If level drops below Red, keep handoff_step as-is (crisis may not be over)
                    # Si le niveau descend sous Rouge, garder handoff_step tel quel

                    # ── Counselor handoff offer at RED / Proposition de transfert au ROUGE ──
                    if alert["level"] == 3 and not st.session_state.handoff_offered:
                        st.session_state.chat_mode = "handoff_offered"
                        st.session_state.handoff_offered = True
                        offer_msg = get_handoff_offer_message(lang)
                        st.session_state.messages.append({
                            "role": "assistant",
                            "content": offer_msg,
                            "timestamp": datetime.now().strftime("%H:%M"), "timestamp_dt": datetime.now(),
                            "source": "cedd-system",
                            "alert_level": 3,
                        })
                        st.rerun()

                    # Generate assistant responses / Générer les réponses de l'assistant
                    with st.spinner("..."):
                        # Compare mode: generate "without CEDD" response first (always Green prompt)
                        # Mode comparaison : générer d'abord la réponse "sans CEDD" (toujours prompt Vert)
                        if st.session_state.compare_mode:
                            plain_result = get_llm_response(
                                st.session_state.compare_messages,
                                0,
                                force_model=st.session_state.selected_llm,
                                lang=lang,
                                handoff_step=0,
                                system_prompt_override="",  # No instructions — raw LLM response
                            )
                            if plain_result["content"]:
                                st.session_state.compare_messages.append({
                                    "role": "assistant",
                                    "content": plain_result["content"],
                                    "timestamp": datetime.now().strftime("%H:%M"), "timestamp_dt": datetime.now(),
                                })

                        # "With CEDD" response (adaptive prompt) / Réponse "avec CEDD" (prompt adaptatif)
                        result = get_llm_response(
                            st.session_state.messages,
                            alert["level"],
                            force_model=st.session_state.selected_llm,
                            lang=lang,
                            handoff_step=st.session_state.handoff_step,
                        )
                    st.session_state.last_llm_source = result["source"]
                    if result.get("failed_models"):
                        st.session_state["_llm_fallback_toast"] = {
                            "failed": ", ".join(result["failed_models"]),
                            "active": result["source"],
                        }

                    if result["content"]:
                        st.session_state.messages.append({
                            "role": "assistant",
                            "content": result["content"],
                            "timestamp": datetime.now().strftime("%H:%M"), "timestamp_dt": datetime.now(),
                            "source": result["source"],
                            "alert_level": alert["level"],
                        })

                    st.rerun()

    # ── RIGHT: CEDD Dashboard / DROITE : Dashboard CEDD ───────────────────────
    with col_dash:
        st.markdown(S["dashboard_header"])

        alert = st.session_state.current_alert
        level = alert["level"]

        # Circular gauge / Jauge circulaire
        render_gauge(level, alert.get("confidence", 0.0), S, theme)

        st.divider()

        # Class probabilities / Probabilités par classe
        render_proba_bars(alert.get("probabilities", {}), S, level)

        # Active signals / Signaux actifs
        st.markdown(S["signals_header"])
        if st.session_state.withdrawal_detected:
            st.markdown(
                f'<span class="feature-pill" style="background:#e74c3c22;border-color:#e74c3c;color:#e74c3c;">'
                f'⏰ {S["withdrawal_badge"]}</span>',
                unsafe_allow_html=True,
            )
        if alert.get("delay_bumped"):
            st.markdown(
                f'<span class="feature-pill" style="background:#e67e2233;border-color:#e67e22;color:#e67e22;">'
                f'{S["delay_badge"]}</span>',
                unsafe_allow_html=True,
            )
        render_dominant_features(alert.get("dominant_features", []), S)

        # Feature importance chart (Yellow+ only, not on safety override)
        # Graphique d'importance des signaux (Jaune+ seulement, pas sur override)
        feature_scores = alert.get("feature_scores", [])
        if level >= 1 and feature_scores:
            with st.expander(S["feature_chart_title"]):
                render_feature_chart(feature_scores, S, theme)

        # Radar chart / Graphique radar
        with st.expander(S["radar_title"]):
            if st.session_state.messages:
                render_radar_chart(st.session_state.messages, S, theme, lang)
            else:
                st.caption(S["history_waiting"])

        st.divider()

        # In-session history / Historique des niveaux
        st.markdown(S["history_header"])
        render_history_chart(S, theme)

        # Emotional flow streamgraph / Flux émotionnel
        with st.expander(S["streamgraph_header"]):
            render_streamgraph(S, theme)

        # Cross-session longitudinal history / Historique longitudinal inter-sessions
        st.markdown(S["longitudinal_header"])
        render_longitudinal_section(tracker, st.session_state.user_id, S, theme)

        st.divider()

        # LLM selector / Sélecteur LLM
        st.markdown(S["llm_header"])
        llm_cols = st.columns(5)
        for col, (src, (emoji, _)) in zip(llm_cols, LLM_SOURCE_INDICATOR.items()):
            is_selected = st.session_state.selected_llm == src
            btn_label = S["llm_fallback"] if src == "fallback-statique" else LLM_DISPLAY_NAMES.get(src, src)
            if col.button(
                f"{emoji} {btn_label}",
                key=f"llm_btn_{src}",
                type="primary" if is_selected else "secondary",
                use_container_width=True,
            ):
                st.session_state.selected_llm = src
                st.rerun()

        # Last call source / Source du dernier appel
        last = st.session_state.get("last_llm_source")
        if last and last != st.session_state.selected_llm:
            _, last_color = LLM_SOURCE_INDICATOR.get(last, ("", "#6b7280"))
            st.caption(
                f'{S["llm_last_call"]} '
                f'<span style="color:{last_color}"><code>{last}</code></span>',
                unsafe_allow_html=True,
            )

        st.divider()

        # Active response mode / Mode de réponse actif
        st.markdown(S["mode_header"])
        mode_desc = get_level_description(level, lang=lang)
        color = LEVEL_COLORS[level]
        emoji = LEVEL_EMOJIS[level]
        text_color = "#000000" if theme == "light" else "#ffffff"
        st.markdown(
            f'<div class="status-card" style="background:{color}22;border-left-color:{color};color:{text_color};">'
            f'{emoji} <b>{mode_desc}</b></div>',
            unsafe_allow_html=True,
        )

        # Warm handoff progress indicator / Indicateur de transfert accompagné
        if st.session_state.handoff_step > 0:
            step = st.session_state.handoff_step
            step_desc = get_handoff_description(step, lang=lang)
            progress = step / 5

            step_colors = {1: "#e74c3c", 2: "#e67e22", 3: "#f1c40f", 4: "#27ae60", 5: "#2ecc71"}
            step_color = step_colors.get(step, "#e74c3c")

            handoff_title = S["handoff_title"]
            handoff_label = S["handoff_step_label"].format(step=step, desc=step_desc)

            st.markdown(f"**{handoff_title}**")
            st.markdown(
                f'<div class="status-card" style="background:{step_color}22;border-left-color:{step_color};color:{text_color};">'
                f'{handoff_label}</div>',
                unsafe_allow_html=True,
            )
            st.progress(progress)
            st.divider()

        # System prompt expander / Affichage du prompt
        with st.expander(S["prompt_expander"]):
            prompt_text = get_system_prompt(level, lang=lang, handoff_step=st.session_state.handoff_step)
            st.markdown(
                f'<div style="white-space:pre-wrap;word-wrap:break-word;font-size:0.85rem;'
                f'line-height:1.5;padding:10px 12px;border-radius:6px;'
                f'background:{THEMES[theme]["bg_input"]};color:{THEMES[theme]["text_main"]};">'
                f'{prompt_text.replace("<", "&lt;").replace(">", "&gt;")}</div>',
                unsafe_allow_html=True,
            )

        # Session statistics / Statistiques de session
        st.markdown(S["stats_header"])
        n_user    = sum(1 for m in st.session_state.messages if m["role"] == "user")
        n_total   = len(st.session_state.messages)
        max_level = max((h["level"] for h in st.session_state.alert_history), default=0)
        c1, c2, c3 = st.columns(3)
        c1.metric(S["stat_messages"], n_user)
        c2.metric(S["stat_exchanges"], n_total // 2)
        c3.metric(S["stat_peak"], LEVEL_EMOJIS[max_level])


if __name__ == "__main__":
    main()