// live-chat.jsx — Chat IA connecté au backend + fallback PSC1 local.
// Surcharge ChatListening et ChatResponse définis dans screen-chat.jsx.

// Samsung Internet expose souvent webkitSpeechRecognition (donc la simple
// détection par feature passe) mais son support du Web Speech API est
// historiquement incohérent : la reconnaissance peut ne déclencher aucun
// événement une fois démarrée. Détectée ici pour adapter le message
// d'erreur (watchdogs plus bas) plutôt que de laisser un silence.
function isSamsungInternet() {
  return /SamsungBrowser/i.test(navigator.userAgent || '');
}
function speechUnsupportedMessage() {
  return isSamsungInternet()
    ? "Reconnaissance vocale indisponible sur Samsung Internet — utilisez Chrome pour cette fonctionnalité."
    : 'Reconnaissance vocale non disponible sur ce navigateur.';
}
function speechSilentFailureMessage() {
  return isSamsungInternet()
    ? "Le micro ne répond pas sur Samsung Internet — essayez avec Chrome, ou utilisez le mode texte."
    : 'Le micro ne répond pas — vérifiez les autorisations, ou utilisez le mode texte.';
}

// ── Protocoles PSC1 embarqués (fallback quand le backend est injoignable) ──
// Numéros ici volontairement codés en dur (185/180, jamais la police, qui
// n'a pas sa place dans un protocole de premiers secours) plutôt que tirés
// de useEmergencyNumbers()/GET /api/emergency-numbers : ce fallback existe
// PRÉCISÉMENT pour fonctionner quand le réseau est coupé (voir l'en-tête de
// ce fichier) — le seul déclencheur possible d'un appel réseau supplémentaire
// romprait cette garantie. Valeurs à tenir synchronisées manuellement avec
// src/data/emergency-numbers.js si elles changent un jour (peu probable :
// numéros d'urgence nationaux).
const _CALL_LABELS = {
  '185': { fr: 'Appeler SAMU 185', en: 'Call SAMU 185' },
  '180': { fr: 'Pompiers 180', en: 'Call Firefighters 180' },
};
function _callAction(number, lang) {
  return { type: 'call', label: _CALL_LABELS[number][lang === 'en' ? 'en' : 'fr'], number };
}

const _PSC1 = [
  {
    kw: ['saigne','sang','hémorragie','hémorragi','plaie','coupure','bless','blood','bleeding','cut','wound'],
    reply: {
      fr: 'Hémorragie. Restez calme.\n1. Appuyez fermement sur la plaie avec un linge propre.\n2. Maintenez la pression 10 min sans soulever.\n3. Surélevez le membre si possible.\nAppelez le SAMU 185.',
      en: 'Bleeding. Stay calm.\n1. Press firmly on the wound with a clean cloth.\n2. Maintain pressure for 10 min without lifting.\n3. Raise the limb if possible.\nCall SAMU 185.',
    },
    numbers: ['185', '180'],
  },
  {
    kw: ['étouffe','etouffe','avale de travers','gorge','heimlich','choke','choking'],
    reply: {
      fr: 'Étouffement. Agissez vite.\n1. Si la personne tousse : laissez-la tousser.\n2. Sinon : 5 claques fermes dans le dos.\n3. 5 compressions abdominales (Heimlich).\nAlternez et appelez le 185.',
      en: 'Choking. Act fast.\n1. If the person is coughing: let them cough.\n2. If not: 5 firm back blows.\n3. 5 abdominal thrusts (Heimlich maneuver).\nAlternate and call 185.',
    },
    numbers: ['185'],
  },
  {
    kw: ['inconscient','évanoui','evanouie','tombé','répond plus','ne répond','unconscious','passed out','fainted'],
    reply: {
      fr: 'Inconscience. Vite !\n1. Parlez fort, secouez les épaules.\n2. Vérifiez la respiration 10 secondes.\n3. Respire → Position Latérale de Sécurité.\n4. Ne respire pas → 185 + massage cardiaque.',
      en: 'Unconsciousness. Quick!\n1. Speak loudly, shake the shoulders.\n2. Check breathing for 10 seconds.\n3. Breathing → Recovery Position.\n4. Not breathing → 185 + chest compressions.',
    },
    numbers: ['185'],
  },
  {
    kw: ['brûlé','brule','brûlure','feu','eau chaude','huile chaude','burn','burned','scald'],
    reply: {
      fr: 'Brûlure. Agissez immédiatement.\n1. Eau tiède (15-25 °C) pendant 15 min. Pas de glace.\n2. Retirez bijoux et vêtements (sauf ce qui colle).\n3. Couvrez d\'un linge propre humide.\nSi grave (large, profonde, visage) : appelez le 185.',
      en: 'Burn. Act immediately.\n1. Cool running water (15-25°C) for 15 min. No ice.\n2. Remove jewelry and clothing (except anything stuck to the skin).\n3. Cover with a clean damp cloth.\nIf severe (large, deep, face): call 185.',
    },
    numbers: ['185', '180'],
  },
  {
    kw: ['avc','attaque cérébrale','visage tordu','paralysé','parle mal','stroke','face droop'],
    reply: {
      fr: 'AVC suspecté. Test V.I.T.E :\n• Visage : sourire asymétrique ?\n• Inertie : un bras retombe ?\n• Trouble de la parole : mots déformés ?\nSi oui → appelez le 185 IMMÉDIATEMENT. Notez l\'heure.',
      en: 'Suspected stroke. FAST test:\n• Face: asymmetric smile?\n• Arm: one arm drifting down?\n• Speech: slurred words?\nIf yes → call 185 IMMEDIATELY. Note the time.',
    },
    numbers: ['185'],
  },
  {
    kw: ['cardiaque','cœur','coeur','douleur poitrine','thorax','heart attack','chest pain'],
    reply: {
      fr: 'Crise cardiaque suspectée.\n1. Mettez au repos, demi-assis, jambes pliées. Desserrez les vêtements.\n2. Appelez le 185 maintenant. Ne raccrochez pas.\n3. Si perd connaissance : massage cardiaque 100-120/min.',
      en: 'Suspected heart attack.\n1. Rest in a half-sitting position, knees bent. Loosen clothing.\n2. Call 185 now. Do not hang up.\n3. If they lose consciousness: chest compressions 100-120/min.',
    },
    numbers: ['185'],
  },
];

function _localFallback(text, lang) {
  const isEn = lang === 'en';
  const t = (text || '').toLowerCase();
  for (const p of _PSC1) {
    if (p.kw.some((k) => t.includes(k))) {
      return {
        reply: isEn ? p.reply.en : p.reply.fr,
        suggestedActions: p.numbers.map(n => _callAction(n, lang)),
        source: 'local',
      };
    }
  }
  return {
    reply: isEn
      ? 'I\'m here to help. Briefly describe what\'s happening\n(e.g. "someone is bleeding", "they are choking", "they are not responding").\nFor a life-threatening emergency, call 185 (SAMU) right away.'
      : 'Je suis là pour vous aider. Décrivez brièvement ce qui se passe\n(ex. « quelqu\'un saigne », « il s\'étouffe », « elle ne répond plus »).\nEn cas d\'urgence vitale, appelez le 185 (SAMU) tout de suite.',
    suggestedActions: [_callAction('185', lang)],
    source: 'local',
  };
}

// ── Overlay mode vocal continu ──────────────────────────────────────────────
const VOICE_STATE_META = {
  listening: { emoji: '🎙️', label: 'Je vous écoute', color: 'var(--sm-red)', icon: 'mic' },
  thinking:  { emoji: '💭', label: 'Je réfléchis',    color: 'var(--sm-blue)', icon: 'brain' },
  speaking:  { emoji: '🔊', label: 'Je réponds',      color: 'var(--sm-green)', icon: 'volume-2' },
  paused:    { emoji: '⏸️', label: 'En pause',         color: 'var(--sm-ink-400)', icon: 'pause' },
  error:     { emoji: '⚠️', label: 'Problème micro',   color: 'var(--sm-red)', icon: 'mic-off' },
};

function VoiceModeOverlay({ voiceState, voiceError, voiceInterim, voicePaused, lastAssistantText, lang, onTogglePause, onExit }) {
  useLucide();
  const meta = VOICE_STATE_META[voiceState] || VOICE_STATE_META.listening;
  const speechUnavailable = useSpeechUnavailable('voice-live');

  return (
    <div style={{
      flex: 1, display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center',
      padding: '32px 24px', gap: 22, overflowY: 'auto',
      background: 'linear-gradient(180deg, #F7F9FC, #EEF3FA)',
    }}>
      <PulseCircle size={140} color={meta.color} haloColor={meta.color}>
        <Icon name={meta.icon} size={44} color="white" />
      </PulseCircle>

      <div style={{ textAlign: 'center', width: '100%' }}>
        <div style={{ fontSize: 17, fontWeight: 700, color: 'var(--sm-ink)' }}>
          {meta.emoji} {meta.label}
        </div>

        {voiceState === 'speaking' && speechUnavailable && (
          <div style={{ fontSize: 12, color: 'var(--sm-ink-400)', marginTop: 6 }}>
            La lecture vocale n'est pas disponible sur cet appareil
          </div>
        )}

        {voiceState === 'listening' && voiceInterim && (
          <div style={{ fontSize: 14, color: 'var(--sm-ink-500)', marginTop: 10, maxWidth: 280, lineHeight: 1.5, marginLeft: 'auto', marginRight: 'auto' }}>
            « {voiceInterim} »
          </div>
        )}

        {voiceState === 'error' && voiceError && (
          <div style={{ fontSize: 13, color: 'var(--sm-red)', marginTop: 10, maxWidth: 280, lineHeight: 1.5, marginLeft: 'auto', marginRight: 'auto' }}>
            {voiceError}
          </div>
        )}

        {/* Dernière réponse IA — même composant de bulle qu'en mode texte, avec
            son propre bouton "lire à voix haute" (id partagé 'voice-live' avec
            la lecture automatique : cliquer dessus coupe la lecture en cours). */}
        {lastAssistantText && voiceState !== 'error' && (voiceState === 'speaking' || voiceState === 'paused') && (
          <div style={{ textAlign: 'left', marginTop: 16, maxWidth: 320, marginLeft: 'auto', marginRight: 'auto' }}>
            <ChatAIBubble id="voice-live" lang={lang} text={lastAssistantText} actions={[]} />
          </div>
        )}
      </div>

      <div style={{ display: 'flex', gap: 14, marginTop: 10 }}>
        {voiceState !== 'error' && (
          <button
            onClick={onTogglePause}
            title={voicePaused ? 'Reprendre' : 'Mettre en pause'}
            style={{
              width: 52, height: 52, borderRadius: '50%',
              background: 'white',
              display: 'flex', alignItems: 'center', justifyContent: 'center', cursor: 'pointer',
              boxShadow: 'var(--sm-shadow)',
            }}
          >
            <Icon name={voicePaused ? 'play' : 'pause'} size={20} color="var(--sm-ink)" />
          </button>
        )}

        <button
          onClick={onExit}
          style={{
            padding: '0 22px', height: 52, borderRadius: 26,
            background: 'var(--sm-ink)', color: 'white', border: 'none',
            display: 'flex', alignItems: 'center', gap: 8, cursor: 'pointer',
            fontSize: 14, fontWeight: 600,
          }}
        >
          <Icon name="x" size={17} color="white" />
          Quitter le mode vocal
        </button>
      </div>

      {voiceState === 'error' && (
        <p style={{ fontSize: 12, color: 'var(--sm-ink-400)', textAlign: 'center', maxWidth: 260 }}>
          Utilisez le mode texte classique pour continuer la conversation.
        </p>
      )}
    </div>
  );
}

// ── Écran chat live ────────────────────────────────────────────────────────
function ChatListening({ nav, lang }) {
  useLucide();
  const t = useTranslation();
  const fileRef = useRef(null);
  const bottomRef = useRef(null);
  const inputRef = useRef(null);
  const nums = useEmergencyNumbers();

  const [messages, setMessages] = useState([{
    role: 'assistant',
    text: t('chat.initial_greeting'),
    actions: [],
  }]);
  const [input, setInput] = useState('');
  const [loading, setLoading] = useState(false);
  const [listening, setListening] = useState(false);
  const [convId, setConvId] = useState(null);
  const [offline, setOffline] = useState(false);

  // ── Mode vocal continu ────────────────────────────────────────────────────
  const [voiceMode, setVoiceMode] = useState(false);
  const [voiceState, setVoiceState] = useState('listening'); // listening | thinking | speaking | paused | error
  const [voiceError, setVoiceError] = useState('');
  const [voiceInterim, setVoiceInterim] = useState('');
  const [voicePaused, setVoicePaused] = useState(false);
  const [lastAssistantText, setLastAssistantText] = useState('');

  const voiceRecRef = useRef(null);
  const voiceModeRef = useRef(false);
  const voicePausedRef = useRef(false);
  const voiceFatalRef = useRef(false);
  const silenceTimerRef = useRef(null);
  const transcriptRef = useRef('');
  const speechWatchdogRef = useRef(null);
  const recognitionWatchdogRef = useRef(null);

  // Scroll automatique vers le dernier message
  useEffect(() => {
    bottomRef.current?.scrollIntoView({ behavior: 'smooth' });
  }, [messages, loading]);

  // Ouverture directe en mode vocal continu — posé par le bouton micro de
  // l'écran d'accueil (screen-home.jsx) avant nav.go('chat') : le mic de la
  // carte "Que se passe-t-il ?" doit être fonctionnel (déclencher la vraie
  // reconnaissance vocale), pas juste un raccourci visuel vers l'écran texte.
  useEffect(() => {
    if (window.SM?.autoVoiceMode) {
      window.SM.autoVoiceMode = false;
      enterVoiceMode();
    }
  }, []);

  // Coupe proprement le micro/la voix si l'écran est démonté en plein mode vocal.
  useEffect(() => () => {
    voiceModeRef.current = false;
    clearTimeout(silenceTimerRef.current);
    clearTimeout(speechWatchdogRef.current);
    clearTimeout(recognitionWatchdogRef.current);
    try { voiceRecRef.current && voiceRecRef.current.stop(); } catch {}
    stopSpeech();
  }, []);

  async function send(text, imageUrl) {
    const msg = (text !== undefined ? text : input).trim();
    if (!msg || loading) return null;
    setInput('');
    setMessages(prev => [...prev, { role: 'user', text: msg, image: imageUrl }]);
    setLoading(true);

    const chatLang = (lang || 'FR').toLowerCase();
    let result;
    try {
      result = await window.API.chat(msg, lang || 'FR', convId);
      if (result.conversationId) setConvId(result.conversationId);
      setOffline(false);
    } catch (err) {
      if (err && err.isNetworkError) {
        // Vraie panne réseau (hors-ligne) : protocoles PSC1 embarqués côté client.
        result = _localFallback(msg, chatLang);
        setOffline(true);
      } else if (err && err.status === 401) {
        // Session expirée/invalide (POST /chat exige désormais un compte) —
        // jamais présenté comme une panne réseau : le fallback PSC1 local
        // aurait l'air d'une vraie réponse de l'assistant alors qu'aucun
        // message n'est parti.
        result = chatLang === 'en'
          ? {
              reply: 'Your session has expired. Please sign in again to continue chatting.\nFor a life-threatening emergency, call 185 (SAMU) directly.',
              suggestedActions: [_callAction('185', chatLang)],
              source: 'error',
            }
          : {
              reply: 'Votre session a expiré. Reconnectez-vous pour continuer à discuter.\nEn cas d\'urgence vitale, appelez directement le 185 (SAMU).',
              suggestedActions: [_callAction('185', chatLang)],
              source: 'error',
            };
        setOffline(false);
      } else if (err && err.status === 429) {
        // Limite de messages atteinte (chatLimiter, routes/chat.js) — même
        // raison : ne jamais faire passer ça pour du hors-ligne.
        result = chatLang === 'en'
          ? {
              reply: 'Too many messages sent. Please try again in a few minutes.\nFor a life-threatening emergency, call 185 (SAMU) directly.',
              suggestedActions: [_callAction('185', chatLang)],
              source: 'error',
            }
          : {
              reply: 'Trop de messages envoyés. Réessayez dans quelques minutes.\nEn cas d\'urgence vitale, appelez directement le 185 (SAMU).',
              suggestedActions: [_callAction('185', chatLang)],
              source: 'error',
            };
        setOffline(false);
      } else {
        // Le serveur a répondu mais en erreur — ce n'est pas du hors-ligne,
        // ne pas prétendre le contraire avec le fallback local.
        result = chatLang === 'en'
          ? {
              reply: 'A server error occurred. Please try again in a moment.\nFor a life-threatening emergency, call 185 (SAMU) directly.',
              suggestedActions: [_callAction('185', chatLang)],
              source: 'error',
            }
          : {
              reply: 'Une erreur est survenue côté serveur. Réessayez dans un instant.\nEn cas d\'urgence vitale, appelez directement le 185 (SAMU).',
              suggestedActions: [_callAction('185', chatLang)],
              source: 'error',
            };
        setOffline(false);
      }
    }

    setMessages(prev => [...prev, {
      role: 'assistant',
      text: result.reply,
      actions: result.suggestedActions || [],
    }]);
    setLoading(false);
    setLastAssistantText(result.reply);
    return result;
  }

  function handleKey(e) {
    if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); send(); }
  }

  // Saisie vocale ponctuelle : ne fait que remplir le champ de texte — c'est
  // toujours le bouton d'envoi qui déclenche l'envoi, comme au clavier.
  function startVoice() {
    const SR = window.SpeechRecognition || window.webkitSpeechRecognition;
    if (!SR) {
      console.warn('[voice] SpeechRecognition non supportée par ce navigateur');
      setInput(speechUnsupportedMessage());
      return;
    }
    const rec = new SR();
    rec.lang = lang === 'EN' ? 'en-US' : 'fr-FR';
    rec.interimResults = false;

    let started = false;
    // Silence complet après start() : certains navigateurs (Samsung Internet
    // notamment) exposent l'API sans jamais déclencher onstart/onerror —
    // sans ce filet, l'UI reste bloquée sur "en écoute" indéfiniment.
    const watchdog = setTimeout(() => {
      if (started) return;
      console.warn('[voice] aucun événement après 3s (startVoice) — reconnaissance probablement indisponible');
      setListening(false);
      setInput(speechSilentFailureMessage());
    }, 3000);

    rec.onstart = () => { started = true; clearTimeout(watchdog); console.log('[voice] reconnaissance démarrée (saisie ponctuelle)'); setListening(true); };
    rec.onend = () => { clearTimeout(watchdog); console.log('[voice] reconnaissance terminée (saisie ponctuelle)'); setListening(false); };
    rec.onerror = (e) => { clearTimeout(watchdog); console.warn('[voice] erreur reconnaissance (saisie ponctuelle):', e.error); setListening(false); };
    rec.onresult = (e) => {
      const transcript = e.results[0][0].transcript;
      console.log('[voice] résultat reçu (saisie ponctuelle):', transcript);
      setInput(transcript);
    };
    try {
      console.log('[voice] démarrage reconnaissance (saisie ponctuelle)…');
      rec.start();
    } catch (e) {
      clearTimeout(watchdog);
      console.warn('[voice] échec démarrage (saisie ponctuelle):', e);
      setListening(false);
    }
  }

  // ── Mode vocal continu : écoute → envoi → lecture → écoute… ───────────────
  function startVoiceListening() {
    const SR = window.SpeechRecognition || window.webkitSpeechRecognition;
    if (!SR) {
      console.warn('[voice] SpeechRecognition non supportée par ce navigateur (mode vocal continu)');
      setVoiceState('error');
      setVoiceError(speechUnsupportedMessage());
      return;
    }
    voiceFatalRef.current = false;
    transcriptRef.current = '';
    setVoiceInterim('');

    const rec = new SR();
    voiceRecRef.current = rec;
    rec.lang = lang === 'EN' ? 'en-US' : 'fr-FR';
    rec.continuous = true;
    rec.interimResults = true;

    const resetSilenceTimer = (delay) => {
      clearTimeout(silenceTimerRef.current);
      silenceTimerRef.current = setTimeout(() => { try { rec.stop(); } catch {} }, delay || 1500);
    };

    let started = false;
    rec.onstart = () => {
      started = true;
      clearTimeout(recognitionWatchdogRef.current);
      console.log('[voice] reconnaissance démarrée (mode continu)');
      setVoiceState('listening');
      resetSilenceTimer();
    };
    rec.onresult = (e) => {
      let finalChunk = '', interimChunk = '';
      for (let i = e.resultIndex; i < e.results.length; i++) {
        if (e.results[i].isFinal) finalChunk += e.results[i][0].transcript;
        else interimChunk += e.results[i][0].transcript;
      }
      if (finalChunk) { transcriptRef.current += finalChunk; console.log('[voice] segment final reçu (mode continu):', finalChunk); }
      setVoiceInterim((transcriptRef.current + interimChunk).trim());
      resetSilenceTimer();
    };
    // Signal complémentaire de fin de phrase — laisse une courte marge pour
    // qu'un résultat final en cours d'arrivée soit bien pris en compte.
    rec.onspeechend = () => resetSilenceTimer(400);
    rec.onerror = (e) => {
      clearTimeout(silenceTimerRef.current);
      clearTimeout(recognitionWatchdogRef.current);
      console.warn('[voice] erreur reconnaissance (mode continu):', e.error);
      if (e.error === 'not-allowed' || e.error === 'service-not-allowed') {
        voiceFatalRef.current = true;
        setVoiceState('error');
        setVoiceError("Micro refusé — autorisez l'accès au micro dans les réglages du navigateur, ou utilisez le mode texte.");
      } else if (e.error === 'no-speech' || e.error === 'aborted') {
        // rien entendu, ou arrêt volontaire déclenché par le timer — silencieux, onend gère la suite
      } else {
        voiceFatalRef.current = true;
        setVoiceState('error');
        setVoiceError('Erreur du micro — utilisez le mode texte.');
      }
    };
    rec.onend = () => {
      clearTimeout(silenceTimerRef.current);
      clearTimeout(recognitionWatchdogRef.current);
      console.log('[voice] reconnaissance terminée (mode continu)');
      if (!voiceModeRef.current || voicePausedRef.current || voiceFatalRef.current) return;
      const finalText = transcriptRef.current.trim();
      transcriptRef.current = '';
      setVoiceInterim('');
      if (finalText) handleVoiceUtterance(finalText);
      else startVoiceListening();
    };

    try {
      console.log('[voice] démarrage reconnaissance (mode continu)…');
      rec.start();
      // Silence complet après start() : ni onstart ni onerror ne se
      // déclenche — observé sur certains navigateurs (Samsung Internet en
      // particulier) qui exposent l'API sans vraiment la faire fonctionner.
      // Sans ce filet, l'overlay restait bloqué sur "Je vous écoute" alors
      // que le micro n'écoutait en réalité jamais.
      recognitionWatchdogRef.current = setTimeout(() => {
        if (started) return;
        console.warn('[voice] aucun événement après 3s (mode continu) — reconnaissance probablement indisponible');
        voiceFatalRef.current = true;
        try { rec.stop(); } catch {}
        setVoiceState('error');
        setVoiceError(speechSilentFailureMessage());
      }, 3000);
    } catch (e) {
      console.warn('[voice] échec démarrage (mode continu):', e);
      setVoiceState('error');
      setVoiceError('Impossible de démarrer le micro.');
    }
  }

  async function handleVoiceUtterance(text) {
    console.log('[voice] énoncé final (mode continu):', text);
    setVoiceState('thinking');
    const result = await send(text);
    if (!voiceModeRef.current || voicePausedRef.current) return;
    if (!result) { startVoiceListening(); return; }
    setVoiceState('speaking');
    console.log('[speech] lecture de la réponse (mode continu)…');

    // onEnd doit être appelé exactement une fois — soit par la vraie fin de
    // lecture (speakText), soit par le filet de sécurité ci-dessous si le
    // navigateur ne rappelle jamais onend (bug Chrome documenté : une
    // utterance sans référence forte peut être garbage-collectée en cours
    // de lecture, ce qui bloquait silencieusement le cycle en "speaking").
    let resumed = false;
    const resumeListening = () => {
      if (resumed) return;
      resumed = true;
      clearTimeout(speechWatchdogRef.current);
      if (!voiceModeRef.current || voicePausedRef.current) return;
      startVoiceListening();
    };

    const estimatedMs = Math.min(Math.max(result.reply.length * 70, 4000), 25000);
    speechWatchdogRef.current = setTimeout(resumeListening, estimatedMs);

    speakText('voice-live', result.reply, lang, resumeListening);
  }

  function enterVoiceMode() {
    console.log('[voice] entrée en mode vocal continu');
    setVoiceError('');
    setVoiceInterim('');
    setVoicePaused(false);
    voicePausedRef.current = false;
    voiceModeRef.current = true;
    setVoiceMode(true);
    startVoiceListening();
  }

  function exitVoiceMode() {
    console.log('[voice] sortie du mode vocal continu');
    voiceModeRef.current = false;
    voiceFatalRef.current = false;
    clearTimeout(silenceTimerRef.current);
    clearTimeout(speechWatchdogRef.current);
    clearTimeout(recognitionWatchdogRef.current);
    try { voiceRecRef.current && voiceRecRef.current.stop(); } catch {}
    stopSpeech();
    setVoiceMode(false);
    setVoiceState('listening');
    setVoicePaused(false);
    setVoiceInterim('');
  }

  // Un seul clic suffit à interrompre le cycle en cours, quel que soit
  // l'état (écoute, réflexion, lecture) : coupe le micro, la voix, et le
  // filet de sécurité de reprise — voicePausedRef passe à true avant tout
  // le reste, donc même un onEnd qui arrive juste après ce clic ne relance
  // pas l'écoute (voir les gardes dans handleVoiceUtterance/startVoiceListening).
  function toggleVoicePause() {
    if (voicePaused) {
      voicePausedRef.current = false;
      setVoicePaused(false);
      startVoiceListening();
    } else {
      voicePausedRef.current = true;
      setVoicePaused(true);
      clearTimeout(silenceTimerRef.current);
      clearTimeout(speechWatchdogRef.current);
      clearTimeout(recognitionWatchdogRef.current);
      try { voiceRecRef.current && voiceRecRef.current.stop(); } catch {}
      stopSpeech();
      setVoiceState('paused');
    }
  }

  // Bouton "Modifier" d'une bulle utilisateur : préremplit le champ de
  // saisie avec l'ancien texte plutôt que de le retirer de l'historique —
  // le message corrigé s'ajoute simplement à la suite une fois renvoyé,
  // ce qui évite de désynchroniser convId/l'historique déjà envoyé au
  // backend pour un bénéfice cosmétique marginal.
  function handleEditMessage(text) {
    setInput(text);
    inputRef.current?.focus();
  }

  function handleImage(e) {
    const file = e.target.files && e.target.files[0];
    e.target.value = '';
    if (!file) return;
    // Pas d'analyse d'image côté app — la photo s'affiche dans la bulle pour
    // contexte visuel, mais c'est le message texte qui part vers l'IA. Le system
    // prompt lui demande de ne jamais prétendre diagnostiquer la photo et de
    // plutôt demander une description écrite.
    const previewUrl = URL.createObjectURL(file);
    send('Voici une photo de la situation.', previewUrl);
  }

  return (
    <div style={{ position: 'absolute', inset: 0, background: 'var(--sm-paper)', display: 'flex', flexDirection: 'column' }}>

      {/* Bannière hors-ligne */}
      {offline && (
        <div style={{ background: '#92400e', color: 'white', padding: '5px 14px', fontSize: 12, textAlign: 'center', display: 'flex', alignItems: 'center', justifyContent: 'center', gap: 6, flexShrink: 0 }}>
          <Icon name="wifi-off" size={12} color="white" />
          {t('chat.offline_banner')}
        </div>
      )}

      {/* En-tête */}
      <div style={{
        display: 'flex', alignItems: 'center', gap: 10,
        padding: '12px 14px 10px',
        background: 'white',
        borderBottom: '1px solid var(--sm-line)',
        flexShrink: 0,
      }}>
        <button
          onClick={() => nav.go('home')}
          style={{ width: 36, height: 36, borderRadius: '50%', display: 'flex', alignItems: 'center', justifyContent: 'center', background: 'var(--sm-paper-2)', border: 'none', flexShrink: 0, cursor: 'pointer' }}
        >
          <Icon name="arrow-left" size={18} />
        </button>

        <div style={{ width: 38, height: 38, borderRadius: 11, background: 'var(--sm-ink)', display: 'flex', alignItems: 'center', justifyContent: 'center', flexShrink: 0 }}>
          <Icon name="sparkles" size={17} color="white" />
        </div>

        <div style={{ flex: 1, minWidth: 0 }}>
          <div style={{ fontWeight: 700, fontSize: 15 }}>{t('chat.assistant_name')}</div>
          <div style={{ display: 'flex', alignItems: 'center', gap: 5, marginTop: 1 }}>
            <div style={{ width: 7, height: 7, borderRadius: '50%', background: offline ? '#ef4444' : '#22c55e', transition: 'background 0.4s' }} />
            <span style={{ fontSize: 12, color: 'var(--sm-ink-500)' }}>
              {offline ? t('chat.offline') : t('chat.online')}
            </span>
          </div>
        </div>

        <button
          onClick={enterVoiceMode}
          title={t('chat.voice_mode_title')}
          style={{ width: 36, height: 36, borderRadius: '50%', display: 'flex', alignItems: 'center', justifyContent: 'center', background: 'var(--sm-soft-blue)', border: 'none', flexShrink: 0, cursor: 'pointer' }}
        >
          <Icon name="headphones" size={17} color="var(--sm-blue)" />
        </button>

      </div>

      {voiceMode ? (
        <VoiceModeOverlay
          voiceState={voiceState}
          voiceError={voiceError}
          voiceInterim={voiceInterim}
          voicePaused={voicePaused}
          lastAssistantText={lastAssistantText}
          lang={lang}
          onTogglePause={toggleVoicePause}
          onExit={exitVoiceMode}
        />
      ) : (
        <>
          {/* Zone messages */}
          <div style={{ flex: 1, overflowY: 'auto', padding: '16px 14px', display: 'flex', flexDirection: 'column', gap: 14 }}>
            {messages.map((m, i) =>
              m.role === 'user'
                ? <ChatUserBubble key={i} text={m.text} image={m.image} onEdit={handleEditMessage} />
                : <ChatAIBubble key={i} id={i} lang={lang} text={m.text} actions={m.actions} />
            )}
            {loading && <ChatAIBubble loading />}
            <div ref={bottomRef} />
          </div>

          {/* Barre de saisie */}
          <div style={{ padding: '10px 12px 22px', borderTop: '1px solid var(--sm-line)', background: 'white', flexShrink: 0 }}>
            <input ref={fileRef} type="file" accept="image/*" style={{ display: 'none' }} onChange={handleImage} />

            <div style={{
              display: 'flex', alignItems: 'center', gap: 8,
              padding: '8px 10px',
              borderRadius: 24,
              border: '1.5px solid ' + (listening ? 'var(--sm-red)' : 'var(--sm-line)'),
              background: 'var(--sm-paper)',
              transition: 'border-color 0.2s',
            }}>
              <input
                ref={inputRef}
                value={input}
                onChange={(e) => setInput(e.target.value)}
                onKeyDown={handleKey}
                placeholder={t('chat.input_placeholder')}
                disabled={loading || listening}
                style={{
                  flex: 1, border: 'none', outline: 'none', background: 'transparent',
                  fontSize: 15, fontFamily: 'inherit', padding: '2px 0',
                  color: 'var(--sm-ink)',
                }}
              />

              {/* Bouton image */}
              <button
                onClick={() => fileRef.current?.click()}
                title={t('chat.image_button_title')}
                style={{ width: 32, height: 32, borderRadius: '50%', background: 'var(--sm-paper-2)', border: 'none', display: 'flex', alignItems: 'center', justifyContent: 'center', flexShrink: 0, cursor: 'pointer' }}
              >
                <Icon name="image" size={16} color="var(--sm-ink-400)" />
              </button>

              {/* Bouton micro — saisie vocale ponctuelle : remplit le champ, n'envoie pas */}
              <button
                onClick={startVoice}
                title={listening ? t('chat.mic_listening_title') : t('chat.mic_voice_input_title')}
                style={{
                  width: 32, height: 32, borderRadius: '50%',
                  background: listening ? 'var(--sm-red)' : 'var(--sm-soft-red)',
                  border: 'none', display: 'flex', alignItems: 'center', justifyContent: 'center',
                  flexShrink: 0, cursor: 'pointer', transition: 'background 0.2s',
                }}
              >
                <Icon name={listening ? 'mic-off' : 'mic'} size={16} color={listening ? 'white' : 'var(--sm-red)'} />
              </button>

              {/* Bouton envoyer */}
              <button
                onClick={() => send()}
                disabled={!input.trim() || loading || listening}
                style={{
                  width: 32, height: 32, borderRadius: '50%',
                  background: input.trim() && !loading && !listening ? 'var(--sm-blue)' : 'var(--sm-line)',
                  border: 'none', display: 'flex', alignItems: 'center', justifyContent: 'center',
                  flexShrink: 0, cursor: input.trim() && !loading ? 'pointer' : 'default',
                  transition: 'background 0.2s',
                }}
              >
                <Icon name="arrow-up" size={16} color="white" />
              </button>
            </div>

            <p style={{ fontSize: 11, color: 'var(--sm-ink-400)', textAlign: 'center', marginTop: 7 }}>
              {t('chat.emergency_footer').replace('{samu}', nums.samu).replace('{pompiers}', nums.pompiers).replace('{police}', nums.police)}
            </p>
          </div>
        </>
      )}
    </div>
  );
}

const ChatResponse = ChatListening;

Object.assign(window, { ChatListening, ChatResponse });
