server.js

try { process.loadEnvFile(); } catch (e) { }
require('dotenv').config();
const express = require('express');
const path = require('path');
const os = require('os');
const { spawn } = require('child_process');
const crypto = require('crypto');
const argon2 = require('argon2');
const stripeKey = process.env.STRIPE_SECRET_KEY;
const stripe = (stripeKey && stripeKey.trim() !== '') ? require('stripe')(stripeKey) : null;

const app = express();
const PORT = process.env.PORT || 3000;

// Configuration de la base de données SurrealDB
const DB_HOST = process.env.SURREAL_HOST || '127.0.0.1';
const DB_PORT = process.env.SURREAL_PORT || '8000';
const DB_URL = `http://${DB_HOST}:${DB_PORT}`;

// État en mémoire du prototype de serveur
const serverState = {
  uptimeStart: Date.now(),
  requestCount: 0,
  simulatedLatency: 0,
  maintenanceMode: false,
  logs: [],
  maxLogs: 50
};

// Lancement de SurrealDB en arrière-plan (si locale)
let surrealProcess = null;
if (process.env.SURREAL_EXTERNAL === 'true') {
  console.log(`Utilisation d'une instance SurrealDB externe sur ${DB_URL}`);
} else {
  console.log("Démarrage de SurrealDB...");
  surrealProcess = spawn('/home/richard/.surrealdb/surreal', [
    'start',
    '--user', 'root',
    '--pass', 'root',
    '--bind', `${DB_HOST}:${DB_PORT}`,
    'surrealkv://surreal.db'
  ]);

  surrealProcess.stdout.on('data', (data) => {
    // Optionnel : décommenter pour débogage
    // console.log(`[SurrealDB]: ${data}`);
  });

  surrealProcess.stderr.on('data', (data) => {
    // Optionnel : décommenter pour débogage
    // console.error(`[SurrealDB Err]: ${data}`);
  });
}

// Arrêter SurrealDB quand le processus Node se termine
const cleanup = () => {
  if (surrealProcess) {
    console.log("Arrêt de SurrealDB...");
    surrealProcess.kill();
  }
};
process.on('exit', cleanup);
process.on('SIGINT', () => {
  cleanup();
  process.exit();
});
process.on('SIGTERM', () => {
  cleanup();
  process.exit();
});

// Fonction pour ajouter un log dans l'historique
function addLog(level, message, source = 'system') {
  const logEntry = {
    timestamp: new Date().toISOString(),
    level, // 'info' | 'warn' | 'error'
    message,
    source // 'system' | 'api' | 'security'
  };
  serverState.logs.unshift(logEntry);
  if (serverState.logs.length > serverState.maxLogs) {
    serverState.logs.pop();
  }
  console.log(`[${logEntry.timestamp}] [${level.toUpperCase()}] ${message}`);
}

// Ajouter quelques logs initiaux
addLog('info', 'Démarrage du système de journalisation...', 'system');
addLog('info', `Serveur configuré pour écouter sur le port ${PORT}`, 'system');
addLog('info', 'Initialisation du prototype de serveur web terminée', 'system');

// Générer des logs système périodiques pour simuler de l'activité
setInterval(() => {
  const random = Math.random();
  if (random < 0.05) {
    addLog('error', 'Échec de connexion temporaire à la base de données simulée', 'system');
  } else if (random < 0.15) {
    addLog('warn', `Utilisation de la mémoire élevée : ${(process.memoryUsage().heapUsed / 1024 / 1024).toFixed(2)} MB`, 'system');
  } else if (random < 0.35) {
    const tasks = ['Nettoyage du cache terminé', 'Indexation des fichiers en cours', 'Vérification de l\'intégrité du système effectuée', 'Sauvegarde automatique réussie'];
    const task = tasks[Math.floor(Math.random() * tasks.length)];
    addLog('info', task, 'system');
  }
}, 12000);

// Analyseur de corps JSON
app.use(express.json());

// Helper pour exécuter des requêtes SurrealQL via l'API REST
async function querySurreal(sql, ns = 'test', db = 'test') {
  try {
    const response = await fetch(`${DB_URL}/sql`, {
      method: 'POST',
      headers: {
        'Authorization': 'Basic ' + Buffer.from('root:root').toString('base64'),
        'surreal-ns': ns,
        'surreal-db': db,
        'Accept': 'application/json',
        'Content-Type': 'text/plain'
      },
      body: sql
    });
    if (!response.ok) {
      throw new Error(`Erreur HTTP SurrealDB : ${response.statusText}`);
    }
    return await response.json();
  } catch (error) {
    console.error(`Erreur de requête SurrealDB : ${error.message}`);
    throw error;
  }
}

// Fonction de hachage SHA-256 héritée pour les mots de passe
function hashPasswordSHA256(password) {
  return crypto.createHash('sha256').update(password).digest('hex');
}

// Fonction de hachage moderne Argon2id avec sel/pepper issu du fichier .env
async function hashPasswordArgon2(password) {
  const pepper = process.env.SALT || '';
  return await argon2.hash(password + pepper);
}

// Fonction de vérification de mot de passe avec compatibilité descendante et mise à jour automatique
async function verifyPassword(user, password) {
  const storedHash = user.password;
  const pepper = process.env.SALT || '';

  if (storedHash && storedHash.startsWith('$argon2id$')) {
    // Hash moderne Argon2id
    return await argon2.verify(storedHash, password + pepper);
  } else {
    // Hash hérité SHA-256
    const legacyHash = hashPasswordSHA256(password);
    if (storedHash === legacyHash) {
      // Authentification correcte ! On met à niveau vers Argon2id de façon asynchrone
      try {
        const newHash = await hashPasswordArgon2(password);
        await querySurreal(`UPDATE ${user.id} SET password = '${newHash}';`);
        addLog('info', `Mot de passe de l'utilisateur ${user.username} mis à niveau vers Argon2id`, 'security');
      } catch (err) {
        addLog('error', `Échec de la mise à niveau vers Argon2id pour ${user.username} : ${err.message}`, 'security');
      }
      return true;
    }
    return false;
  }
}

// Initialisation de la base de données SurrealDB
async function initSurreal() {
  const maxRetries = 15;
  let attempt = 0;

  while (attempt < maxRetries) {
    try {
      // 1. Définir le namespace
      await fetch(`${DB_URL}/sql`, {
        method: 'POST',
        headers: {
          'Authorization': 'Basic ' + Buffer.from('root:root').toString('base64'),
          'Accept': 'application/json',
          'Content-Type': 'text/plain'
        },
        body: 'DEFINE NAMESPACE test;'
      });

      // 2. Définir la base de données
      await fetch(`${DB_URL}/sql`, {
        method: 'POST',
        headers: {
          'Authorization': 'Basic ' + Buffer.from('root:root').toString('base64'),
          'surreal-ns': 'test',
          'Accept': 'application/json',
          'Content-Type': 'text/plain'
        },
        body: 'DEFINE DATABASE test;'
      });

      // 3. Vérifier et créer l'admin par défaut
      const res = await querySurreal("SELECT * FROM user WHERE username = 'admin';");
      let createAdmin = false;
      if (res && res[0]) {
        if (res[0].status === 'ERR' && String(res[0].result).includes('does not exist')) {
          createAdmin = true;
        } else if (res[0].status === 'OK' && res[0].result.length === 0) {
          createAdmin = true;
        }
      }
      if (createAdmin) {
        const passHash = await hashPasswordArgon2('admin');
        await querySurreal(`CREATE user:admin SET username = 'admin', password = '${passHash}', name = 'Administrateur', role = 'admin', tier = 'paid', demo = false, premiumCount = 0, createdAt = time::now();`);
        addLog('info', 'Compte administrateur initialisé avec succès (admin:admin) avec Argon2id', 'security');
      }

      addLog('info', 'Connexion et initialisation de SurrealDB réussies', 'system');
      break;
    } catch (err) {
      attempt++;
      console.log(`En attente de démarrage de SurrealDB... (Tentative ${attempt}/${maxRetries})`);
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
  }

  if (attempt === maxRetries) {
    addLog('error', 'Impossible de se connecter à SurrealDB après plusieurs tentatives', 'system');
  }
}

// Lancer l'initialisation de SurrealDB
initSurreal();

// Middleware d'authentification
async function authenticate(req, res, next) {
  const token = getCookie(req, 'token');
  if (!token) {
    return res.status(401).json({ error: 'Non autorisé', message: 'Token manquant ou invalide.' });
  }
  try {
    const sessionRes = await querySurreal(`SELECT user AS userId, user.username AS username, user.name AS name, user.role AS role, user.demo AS demo, user.tier AS tier, user.premiumCount AS premiumCount FROM session:${token};`);
    if (!sessionRes[0] || sessionRes[0].status === 'ERR' || !sessionRes[0].result || sessionRes[0].result.length === 0) {
      return res.status(401).json({ error: 'Non autorisé', message: 'Session expirée ou invalide.' });
    }
    req.user = sessionRes[0].result[0];
    if (req.user) {
      if (!req.user.tier) req.user.tier = 'free';
      if (req.user.premiumCount === undefined || req.user.premiumCount === null) {
        req.user.premiumCount = 0;
      }
    }
    next();
  } catch (err) {
    console.error('Erreur d\'authentification base de données :', err);
    return res.status(401).json({ error: 'Non autorisé', message: 'Session expirée ou invalide.' });
  }
}

// Middleware pour vérifier le rôle admin
function requireAdmin(req, res, next) {
  if (!req.user || req.user.role !== 'admin') {
    return res.status(403).json({ error: 'Interdit', message: 'Droits administrateur requis.' });
  }
  next();
}

// Middleware pour simuler la latence et compter les requêtes
app.use((req, res, next) => {
  const isApi = req.url.startsWith('/api/');
  if (isApi) {
    serverState.requestCount++;
  }

  const applyLatencyAndNext = () => {
    if (isApi && serverState.simulatedLatency > 0) {
      setTimeout(next, serverState.simulatedLatency);
    } else {
      next();
    }
  };

  if (isApi) {
    addLog('info', `Requête reçue : ${req.method} ${req.url}`, 'api');
  }

  res.on('finish', () => {
    if (isApi) {
      const level = res.statusCode >= 400 ? 'error' : (res.statusCode >= 300 ? 'warn' : 'info');
      addLog(level, `Réponse envoyée : ${req.method} ${req.url} -> Statut ${res.statusCode}`, 'api');
    }
  });

  applyLatencyAndNext();
});

// Middleware pour gérer le mode maintenance
app.use((req, res, next) => {
  const isAdminApi = req.url.startsWith('/api/status') || req.url.startsWith('/api/settings') || req.url.startsWith('/api/logs') || req.url.startsWith('/api/admin/');
  const isAuthApi = req.url.startsWith('/api/auth/');
  const isStaticFile = !req.url.startsWith('/api/');

  if (serverState.maintenanceMode && !isAdminApi && !isAuthApi && !isStaticFile) {
    addLog('warn', `Accès bloqué par le mode maintenance : ${req.method} ${req.url}`, 'security');
    return res.status(503).json({
      error: 'Service Unavailable',
      message: 'Le serveur est actuellement en cours de maintenance. Veuillez réessayer plus tard.',
      timestamp: new Date().toISOString()
    });
  }
  next();
});

// Fonction utilitaire pour extraire les cookies
function getCookie(req, name) {
  const cookieHeader = req.headers.cookie;
  if (!cookieHeader) return null;
  const cookies = cookieHeader.split(';').reduce((acc, cookie) => {
    const parts = cookie.split('=');
    const k = parts[0] ? parts[0].trim() : '';
    const v = parts[1] ? parts[1].trim() : '';
    if (k && v) acc[k] = v;
    return acc;
  }, {});
  return cookies[name] || null;
}

// Route sécurisée pour /chat (inaccessible si non connecté)
app.get('/chat', async (req, res) => {
  const token = getCookie(req, 'token');
  if (!token) {
    addLog('warn', `Accès refusé à /chat (token cookie absent)`, 'security');
    return res.redirect('/?error=unauthorized');
  }
  try {
    const sessionRes = await querySurreal(`SELECT user.username AS username, user.name AS name, user.role AS role, user.demo AS demo, user.tier AS tier FROM session:${token};`);
    if (!sessionRes[0] || sessionRes[0].status === 'ERR' || !sessionRes[0].result || sessionRes[0].result.length === 0) {
      addLog('warn', `Accès refusé à /chat (session invalide ou expirée)`, 'security');
      return res.redirect('/?error=unauthorized');
    }
    res.sendFile(path.join(__dirname, 'private', 'chat.html'));
  } catch (err) {
    addLog('error', `Erreur lors de la vérification de session pour /chat : ${err.message}`, 'security');
    return res.redirect('/?error=unauthorized');
  }
});

// Redirection de /chat.html vers /chat pour éviter l'erreur "Cannot GET /chat.html"
app.get('/chat.html', (req, res) => {
  res.redirect('/chat');
});

// Servir les fichiers statiques du frontend
app.use(express.static(path.join(__dirname, 'public')));

// --- ROUTES API D'AUTHENTIFICATION ---

// 1. Inscription (Register)
app.post('/api/auth/register', async (req, res) => {
  try {
    const { username, password, name, tier, bypassCode } = req.body;
    if (!username || !password || !name) {
      return res.status(400).json({ error: 'Champs manquants', message: 'Veuillez remplir tous les champs.' });
    }

    const cleanUsername = username.trim().toLowerCase();

    // Vérifier si l'utilisateur existe déjà
    const checkRes = await querySurreal(`SELECT * FROM user WHERE username = '${cleanUsername}';`);
    if (checkRes[0] && checkRes[0].result && checkRes[0].result.length > 0) {
      return res.status(400).json({ error: 'Existe déjà', message: 'Cet identifiant est déjà utilisé.' });
    }

    const passHash = await hashPasswordArgon2(password);
    const escapedName = name.replace(/'/g, "\\'");

    // Attribution automatique : gratuit -> demo=true, payant -> demo=false
    const isPaid = (tier === 'pro' || tier === 'family' || tier === 'paid');
    const tierVal = isPaid ? tier : 'free';
    const demoVal = !isPaid;

    const bypassMatch = bypassCode && bypassCode === process.env.BYPASS_CODE;

    if (isPaid && !bypassMatch) {
      if (!stripe || !process.env.STRIPE_SECRET_KEY || process.env.STRIPE_SECRET_KEY.includes('placeholder')) {
        return res.status(400).json({
          error: 'Stripe non configuré',
          message: `pour l'instant, le saas est en developpement et ne supporte pas encore les paiements`
        });
      }

      // Demande de paiement via Stripe : créer une inscription temporaire
      const tempToken = crypto.randomBytes(16).toString('hex');

      // On sauvegarde les données temporairement dans SurrealDB
      await querySurreal(`CREATE pending_registration:${tempToken} SET username = '${cleanUsername}', password = '${passHash}', name = '${escapedName}', tier = '${tierVal}', createdAt = time::now();`);

      // Créer une session Stripe Checkout
      const protocol = req.headers['x-forwarded-proto'] || 'http';
      const host = req.headers.host;
      const baseUrl = `${protocol}://${host}`;

      let planName = 'Abonnement Alius.ai Pro';
      let planPriceCents = 1200; // 12.00 €
      if (tierVal === 'family') {
        planName = 'Abonnement Alius.ai Famille';
        planPriceCents = 1900; // 19.00 €
      }

      try {
        const stripeSession = await stripe.checkout.sessions.create({
          payment_method_types: ['card'],
          line_items: [{
            price_data: {
              currency: 'eur',
              product_data: {
                name: planName,
              },
              unit_amount: planPriceCents,
            },
            quantity: 1,
          }],
          mode: 'payment',
          metadata: {
            tempToken: tempToken
          },
          success_url: `${baseUrl}/api/payment/success?session_id={CHECKOUT_SESSION_ID}`,
          cancel_url: `${baseUrl}/`,
        });

        addLog('info', `Session Stripe Checkout créée pour : ${cleanUsername} (Session: ${stripeSession.id})`, 'security');

        return res.json({
          redirectUrl: stripeSession.url
        });
      } catch (stripeErr) {
        addLog('error', `Erreur de création de session Stripe : ${stripeErr.message}`, 'security');
        return res.status(500).json({
          error: 'Erreur Stripe',
          message: `Impossible d'initier la session Stripe Checkout : ${stripeErr.message}`
        });
      }
    }

    // Insérer dans SurrealDB directement (gratuit ou bypass correct)
    const insertRes = await querySurreal(`CREATE user SET username = '${cleanUsername}', password = '${passHash}', name = '${escapedName}', role = 'user', demo = ${demoVal}, tier = '${tierVal}', premiumCount = 0, createdAt = time::now();`);

    if (insertRes[0] && insertRes[0].status === 'ERR') {
      throw new Error(insertRes[0].result);
    }

    const createdUser = insertRes[0].result[0];
    const userId = createdUser.id;

    // Générer une session
    const token = crypto.randomBytes(32).toString('hex');
    const userData = { username: cleanUsername, name: name, role: 'user', demo: demoVal, tier: tierVal };

    // Stocker la session dans SurrealDB
    await querySurreal(`CREATE session:${token} SET user = ${userId}, createdAt = time::now();`);

    addLog('info', `Nouvel utilisateur inscrit : ${cleanUsername} (tier: ${tierVal}, demo: ${demoVal})`, 'security');

    // Définir le cookie sécurisé HttpOnly
    const isProduction = req.headers['x-forwarded-proto'] === 'https';
    const secureFlag = isProduction ? '; Secure' : '';
    res.setHeader('Set-Cookie', `token=${token}; Path=/; Max-Age=86400; HttpOnly; SameSite=Strict${secureFlag}`);

    res.json({
      message: 'Inscription réussie',
      user: userData
    });
  } catch (err) {
    addLog('error', `Erreur d'inscription : ${err.message}`, 'security');
    res.status(500).json({ error: 'Erreur serveur', message: err.message });
  }
});

// Endpoint de redirection après succès Stripe
app.get('/api/payment/success', async (req, res) => {
  const { session_id } = req.query;
  if (!session_id) {
    return res.redirect('/?error=invalid_session');
  }

  try {
    if (!stripe) {
      addLog('error', `Paiement Stripe échoué : Stripe n'est pas configuré`, 'security');
      return res.redirect('/?error=stripe_not_configured');
    }
    const session = await stripe.checkout.sessions.retrieve(session_id);
    const tempToken = session.metadata.tempToken;

    if (!tempToken) {
      return res.redirect('/?error=invalid_metadata');
    }

    // Récupérer la demande d'inscription en attente
    const pendingRes = await querySurreal(`SELECT * FROM pending_registration:${tempToken};`);
    if (!pendingRes[0] || pendingRes[0].status === 'ERR' || !pendingRes[0].result || pendingRes[0].result.length === 0) {
      // Si l'utilisateur a déjà été créé (par exemple par rechargement de page), on redirige vers le chat
      addLog('warn', `Demande d'inscription en attente non trouvée pour le token ${tempToken}. L'utilisateur a peut-être déjà été créé.`, 'security');
      return res.redirect('/chat');
    }

    const pending = pendingRes[0].result[0];

    // Créer l'utilisateur réel
    const insertRes = await querySurreal(`CREATE user SET username = '${pending.username}', password = '${pending.password}', name = '${pending.name}', role = 'user', demo = false, tier = '${pending.tier}', premiumCount = 0, createdAt = time::now();`);

    if (insertRes[0] && insertRes[0].status === 'ERR') {
      throw new Error(insertRes[0].result);
    }

    const createdUser = insertRes[0].result[0];
    const userId = createdUser.id;

    // Supprimer la demande d'inscription temporaire
    await querySurreal(`DELETE pending_registration:${tempToken};`);

    // Générer et stocker la session
    const sessionToken = crypto.randomBytes(32).toString('hex');
    await querySurreal(`CREATE session:${sessionToken} SET user = ${userId}, createdAt = time::now();`);

    addLog('info', `Paiement Stripe confirmé pour : ${pending.username} (session_id: ${session_id}). Inscription finalisée.`, 'security');

    // Définir le cookie sécurisé HttpOnly
    const isProduction = req.headers['x-forwarded-proto'] === 'https';
    const secureFlag = isProduction ? '; Secure' : '';
    res.setHeader('Set-Cookie', `token=${sessionToken}; Path=/; Max-Age=86400; HttpOnly; SameSite=Strict${secureFlag}`);

    // Rediriger vers la page de chat
    res.redirect('/chat');
  } catch (err) {
    addLog('error', `Erreur lors de la finalisation du paiement Stripe : ${err.message}`, 'security');
    res.redirect('/?error=payment_failed');
  }
});

// 2. Connexion (Login)
app.post('/api/auth/login', async (req, res) => {
  try {
    const { username, password } = req.body;
    if (!username || !password) {
      return res.status(400).json({ error: 'Champs manquants', message: 'Identifiant et mot de passe requis.' });
    }

    const cleanUsername = username.trim().toLowerCase();

    const searchRes = await querySurreal(`SELECT * FROM user WHERE username = '${cleanUsername}';`);
    if (searchRes[0] && searchRes[0].result && searchRes[0].result.length > 0) {
      const user = searchRes[0].result[0];
      const isValid = await verifyPassword(user, password);
      if (isValid) {
        const token = crypto.randomBytes(32).toString('hex');
        const userData = { username: user.username, name: user.name, role: user.role, demo: user.demo || false, tier: user.tier || 'free' };

        // Stocker la session dans SurrealDB
        await querySurreal(`CREATE session:${token} SET user = ${user.id}, createdAt = time::now();`);

        addLog('info', `Utilisateur connecté : ${cleanUsername} (${user.role}, tier: ${userData.tier})`, 'security');

        // Définir le cookie sécurisé HttpOnly
        const isProduction = req.headers['x-forwarded-proto'] === 'https';
        const secureFlag = isProduction ? '; Secure' : '';
        res.setHeader('Set-Cookie', `token=${token}; Path=/; Max-Age=86400; HttpOnly; SameSite=Strict${secureFlag}`);

        return res.json({
          message: 'Connexion réussie',
          user: userData
        });
      }
    }

    addLog('warn', `Tentative de connexion échouée pour : ${cleanUsername}`, 'security');
    res.status(400).json({ error: 'Identifiants incorrects', message: 'Identifiant ou mot de passe incorrect.' });
  } catch (err) {
    addLog('error', `Erreur de connexion : ${err.message}`, 'security');
    res.status(500).json({ error: 'Erreur serveur', message: err.message });
  }
});

// 3. Déconnexion (Logout)
app.post('/api/auth/logout', authenticate, async (req, res) => {
  const token = getCookie(req, 'token');
  if (token) {
    try {
      await querySurreal(`DELETE session:${token};`);
    } catch (err) {
      console.error('Erreur suppression session database:', err);
    }
  }
  addLog('info', `Utilisateur déconnecté : ${req.user.username}`, 'security');

  // Supprimer le cookie
  res.setHeader('Set-Cookie', 'token=; Path=/; Max-Age=0; HttpOnly; SameSite=Strict');
  res.json({ message: 'Déconnexion réussie' });
});

// 4. Récupérer le profil connecté (Me)
app.get('/api/auth/me', authenticate, (req, res) => {
  res.json({ user: req.user });
});


// --- ROUTES API SYSTÈME ET ADMINISTRATION (Protégées) ---

// 1. Statut et métriques du serveur (tous les utilisateurs connectés)
app.get('/api/status', authenticate, (req, res) => {
  const totalMem = os.totalmem();
  const freeMem = os.freemem();
  const usedMem = totalMem - freeMem;

  const baseCpu = serverState.maintenanceMode ? 2 : 12;
  const simulatedCpu = Math.min(100, Math.max(1, Math.round(baseCpu + (Math.sin(Date.now() / 5000) * 8) + (Math.random() * 5))));

  res.json({
    status: serverState.maintenanceMode ? 'maintenance' : 'online',
    uptime: Math.floor((Date.now() - serverState.uptimeStart) / 1000),
    requestCount: serverState.requestCount,
    simulatedLatency: serverState.simulatedLatency,
    maintenanceMode: serverState.maintenanceMode,
    system: {
      platform: os.platform(),
      arch: os.arch(),
      cpuCount: os.cpus().length,
      memory: {
        total: totalMem,
        used: usedMem,
        free: freeMem,
        processUsed: process.memoryUsage().heapUsed
      }
    },
    simulatedCpu
  });
});

// 2. Modifier la configuration (Admin seulement)
app.post('/api/settings', authenticate, requireAdmin, (req, res) => {
  const { latency, maintenance } = req.body;

  if (typeof latency === 'number' && latency >= 0 && latency <= 5000) {
    serverState.simulatedLatency = latency;
    addLog('info', `Configuration mise à jour : latence réglée à ${latency}ms`, 'system');
  }

  if (typeof maintenance === 'boolean') {
    serverState.maintenanceMode = maintenance;
    const actionStr = maintenance ? 'ACTIVÉ' : 'DÉSACTIVÉ';
    addLog('warn', `Configuration mise à jour : mode maintenance ${actionStr}`, 'system');
  }

  res.json({
    message: 'Configuration mise à jour avec succès',
    simulatedLatency: serverState.simulatedLatency,
    maintenanceMode: serverState.maintenanceMode
  });
});

// 3. Obtenir les logs (Admin seulement)
app.get('/api/logs', authenticate, requireAdmin, (req, res) => {
  res.json(serverState.logs);
});

// 4. Liste de tous les utilisateurs (Admin seulement)
app.get('/api/admin/users', authenticate, requireAdmin, async (req, res) => {
  try {
    const usersRes = await querySurreal("SELECT id, username, name, role, tier, demo, createdAt FROM user ORDER BY createdAt DESC;");
    if (usersRes[0] && usersRes[0].status === 'OK') {
      res.json(usersRes[0].result);
    } else {
      res.status(500).json({ error: 'Erreur base de données', message: usersRes[0].result });
    }
  } catch (err) {
    res.status(500).json({ error: 'Erreur serveur', message: err.message });
  }
});

// 5. Exécution SurrealQL en direct (Admin seulement)
app.post('/api/admin/query', authenticate, requireAdmin, async (req, res) => {
  try {
    const { query } = req.body;
    if (!query) {
      return res.status(400).json({ error: 'Requête manquante', message: 'Veuillez saisir une requête SurrealQL.' });
    }

    const queryRes = await querySurreal(query);
    addLog('info', `Console SurrealQL : Exécution de "${query.substring(0, 50)}${query.length > 50 ? '...' : ''}"`, 'system');
    res.json(queryRes);
  } catch (err) {
    res.status(500).json({ error: 'Erreur SurrealQL', message: err.message });
  }
});

// 6. Déclencher une erreur simulée (Admin seulement)
app.get('/api/trigger-error', authenticate, requireAdmin, (req, res) => {
  addLog('error', 'Erreur critique déclenchée manuellement par l\'utilisateur', 'system');
  res.status(500).json({
    error: 'Internal Server Error',
    message: 'Une erreur interne simulée s\'est produite sur le serveur.',
    timestamp: new Date().toISOString()
  });
});

// --- API DE CHAT POUR LE MODE DÉMO ---

// 1. Liste des modèles d'IA disponibles
// 1. Liste des modèles d'IA disponibles
app.get('/api/models', authenticate, (req, res) => {
  try {
    const configIA = require('./ia/config');
    const models = configIA.MODELS.map(m => ({
      name: m.name,
      displayName: m.displayName,
      provider: m.provider,
      description: m.description
    }));
    res.json(models);
  } catch (err) {
    console.error('Erreur chargement modèles IA:', err);
    res.status(500).json({ error: 'Impossible de charger les modèles d\'IA' });
  }
});

// --- GESTION DE L'HISTORIQUE ---

// Récupérer toutes les conversations de l'utilisateur
app.get('/api/chat/conversations', authenticate, async (req, res) => {
  try {
    const userId = req.user.userId;
    const convsRes = await querySurreal(`SELECT id, title, createdAt FROM conversation WHERE user = ${userId} ORDER BY createdAt DESC;`);
    if (convsRes[0] && convsRes[0].status === 'OK') {
      res.json(convsRes[0].result);
    } else {
      res.json([]);
    }
  } catch (err) {
    console.error('Erreur get conversations:', err);
    res.status(500).json({ error: 'Erreur serveur' });
  }
});

// Récupérer tous les messages d'une conversation
app.get('/api/chat/conversations/:id/messages', authenticate, async (req, res) => {
  try {
    const userId = req.user.userId;
    const convId = req.params.id;

    // Vérifier l'appartenance
    const verifyRes = await querySurreal(`SELECT user FROM conversation:${convId};`);
    if (!verifyRes[0] || !verifyRes[0].result || verifyRes[0].result.length === 0 || verifyRes[0].result[0].user !== userId) {
      return res.status(403).json({ error: 'Accès interdit', message: 'Cette conversation ne vous appartient pas.' });
    }

    const messagesRes = await querySurreal(`SELECT sender, text, thoughts, modelUsed, createdAt FROM message WHERE conversation = conversation:${convId} ORDER BY createdAt ASC;`);
    if (messagesRes[0] && messagesRes[0].status === 'OK') {
      res.json(messagesRes[0].result);
    } else {
      res.json([]);
    }
  } catch (err) {
    console.error('Erreur get messages:', err);
    res.status(500).json({ error: 'Erreur serveur' });
  }
});

// Supprimer une conversation
app.delete('/api/chat/conversations/:id', authenticate, async (req, res) => {
  try {
    const userId = req.user.userId;
    const convId = req.params.id;

    // Vérifier l'appartenance
    const verifyRes = await querySurreal(`SELECT user FROM conversation:${convId};`);
    if (!verifyRes[0] || !verifyRes[0].result || verifyRes[0].result.length === 0 || verifyRes[0].result[0].user !== userId) {
      return res.status(403).json({ error: 'Accès interdit' });
    }

    // Supprimer la conversation et ses messages
    await querySurreal(`DELETE message WHERE conversation = conversation:${convId};`);
    await querySurreal(`DELETE conversation:${convId};`);

    addLog('info', `Conversation supprimée par ${req.user.username} : conversation:${convId}`, 'security');
    res.json({ success: true, message: 'Conversation supprimée avec succès.' });
  } catch (err) {
    console.error('Erreur delete conversation:', err);
    res.status(500).json({ error: 'Erreur serveur' });
  }
});

// 2. Envoi de message (Demo ou Normal) et sauvegarde dans l'historique
app.post('/api/chat/send', authenticate, async (req, res) => {
  const { message, history, modelName, conversationId } = req.body;
  if (!message) {
    return res.status(400).json({ error: 'Message requis' });
  }

  const hasAccess = req.user.demo === true || req.user.tier === 'paid';

  if (hasAccess) {
    try {
      const configIA = require('./ia/config');
      const utilsIA = require('./ia/utils');

      // Choisir un modèle par défaut si aucun n'est spécifié ou disponible
      const selectedModelName = modelName || (configIA.MODELS[0] && configIA.MODELS[0].name) || 'gemini-3-flash-preview';

      // Vérifier la limite de requêtes Premium en Mode Démo
      const modelConfig = configIA.MODELS.find(m => m.name === selectedModelName);
      if (req.user.demo === true && modelConfig && modelConfig.premium === true && (req.user.premiumCount || 0) >= 5) {
        return res.status(403).json({
          error: 'Limite de requêtes Premium atteinte',
          message: 'Vous avez atteint la limite de 5 requêtes pour les modèles Premium en mode démo. Veuillez passer à un abonnement payant pour continuer à les utiliser.'
        });
      }

      // Gérer la conversation SurrealDB
      let activeConvId = conversationId;
      if (!activeConvId) {
        let title = message.trim().substring(0, 30);
        if (message.trim().length > 30) title += '...';
        const escapedTitle = title.replace(/'/g, "\\'");

        const createConvRes = await querySurreal(`CREATE conversation SET user = ${req.user.userId}, title = '${escapedTitle}', createdAt = time::now();`);
        if (createConvRes[0] && createConvRes[0].status === 'OK' && createConvRes[0].result.length > 0) {
          const convRecord = createConvRes[0].result[0];
          activeConvId = convRecord.id.includes(':') ? convRecord.id.split(':')[1] : convRecord.id;
        } else {
          throw new Error("Impossible de créer la conversation dans SurrealDB.");
        }
      }

      // Enregistrer le message de l'utilisateur
      const escapedMessage = message.replace(/'/g, "\\'");
      await querySurreal(`CREATE message SET conversation = conversation:${activeConvId}, sender = 'user', text = '${escapedMessage}', createdAt = time::now();`);

      // Configurer les en-têtes SSE pour le streaming
      res.setHeader('Content-Type', 'text/event-stream');
      res.setHeader('Cache-Control', 'no-cache');
      res.setHeader('Connection', 'keep-alive');
      res.flushHeaders();

      // Envoyer l'ID de la conversation au client
      res.write(`data: ${JSON.stringify({ conversationId: activeConvId })}\n\n`);

      // Exécuter la requête via notre routeur/modèle unifié avec callback onProgress
      const result = await utilsIA.executeModelQuery(selectedModelName, message, history, {
        demo: req.user.demo === true,
        premiumCount: req.user.premiumCount || 0
      }, (progress) => {
        res.write(`data: ${JSON.stringify({
          reply: progress.content,
          thoughts: progress.thinking,
          modelUsed: progress.modelUsed || selectedModelName
        })}\n\n`);
      });

      // Incrémenter si modèle Premium utilisé en Mode Démo
      const usedModelConfig = configIA.MODELS.find(m => m.name === result.modelUsed || (result.modelUsed && result.modelUsed.endsWith(m.name)));
      if (req.user.demo === true && usedModelConfig && usedModelConfig.premium === true) {
        try {
          if (req.user.userId) {
            await querySurreal(`UPDATE ${req.user.userId} SET premiumCount = premiumCount + 1;`);
            addLog('info', `Utilisateur démo ${req.user.username} a consommé une requête Premium.`, 'security');
          }
        } catch (dbErr) {
          console.error('Erreur incrémentation premiumCount:', dbErr);
        }
      }

      // Sauvegarder la réponse du bot dans SurrealDB
      const escapedReply = result.reply.replace(/'/g, "\\'");
      const escapedThoughts = (result.thoughts || '').replace(/'/g, "\\'");
      const escapedModel = (result.modelUsed || selectedModelName).replace(/'/g, "\\'");
      await querySurreal(`CREATE message SET conversation = conversation:${activeConvId}, sender = 'bot', text = '${escapedReply}', thoughts = '${escapedThoughts}', modelUsed = '${escapedModel}', createdAt = time::now();`);

      // Envoyer l'état final et fermer le flux
      res.write(`data: ${JSON.stringify({
        reply: result.reply,
        thoughts: result.thoughts,
        modelUsed: result.modelUsed
      })}\n\n`);
      res.write(`data: [DONE]\n\n`);
      res.end();
    } catch (err) {
      console.error('Erreur Mode Démo IA:', err);
      if (!res.headersSent) {
        res.status(500).json({ error: 'Erreur lors de l\'appel à l\'IA', message: err.message });
      } else {
        res.write(`data: ${JSON.stringify({
          error: true,
          message: err.message || 'Erreur lors de la génération de la réponse.'
        })}\n\n`);
        res.end();
      }
    }
  } else {
    // Mode normal : Simulation d'une réponse après 800ms
    setTimeout(() => {
      res.json({
        reply: "Ceci est une réponse de démonstration (placeholder). Créez un compte avec le Mode Démo activé pour parler à des modèles réels."
      });
    }, 800);
  }
});

// 7. Endpoint de test classique
app.get('/api/test-endpoint', (req, res) => {
  res.json({
    success: true,
    message: 'Hello World ! Le prototype de serveur web fonctionne parfaitement.',
    timestamp: new Date().toISOString()
  });
});

// Démarrer le serveur Express
app.listen(PORT, () => {
  console.log(`\n==================================================`);
  console.log(`🚀 SERVEUR PROTOTYPE DÉMARRÉ`);
  console.log(`🔗 Interface d'administration : http://localhost:${PORT}`);
  console.log(`==================================================\n`);
});