// src/security/validator.ts
import path from 'path';
import { InputSchema } from '../mcp/protocol';

/**
 * Erreur de validation
 */
export class ValidationError extends Error {
  constructor(
    message: string,
    public field?: string,
    public expected?: string
  ) {
    super(message);
    this.name = 'ValidationError';
  }
}

/**
 * Validateur de paramètres basé sur JSON Schema
 */
export class ParameterValidator {
  
  /**
   * Valider les paramètres selon un schéma
   */
  static validate(params: any, schema: InputSchema): void {
    // Vérifier que params est un objet
    if (typeof params !== 'object' || params === null) {
      throw new ValidationError('Les paramètres doivent être un objet');
    }

    // Vérifier les champs requis
    for (const requiredField of schema.required) {
      if (!(requiredField in params)) {
        throw new ValidationError(
          `Le champ '${requiredField}' est requis`,
          requiredField
        );
      }
    }

    // Valider chaque propriété
    for (const [fieldName, fieldValue] of Object.entries(params)) {
      const fieldSchema = schema.properties[fieldName];
      
      if (!fieldSchema) {
        throw new ValidationError(
          `Le champ '${fieldName}' n'est pas autorisé`,
          fieldName
        );
      }

      this.validateField(fieldName, fieldValue, fieldSchema);
    }
  }

  /**
   * Valider un champ spécifique
   */
  private static validateField(
    fieldName: string,
    value: any,
    schema: any
  ): void {
    // Validation de type
    const actualType = typeof value;
    const expectedType = schema.type;

    if (expectedType === 'string' && actualType !== 'string') {
      throw new ValidationError(
        `Le champ '${fieldName}' doit être une chaîne de caractères`,
        fieldName,
        expectedType
      );
    }

    if (expectedType === 'number' && actualType !== 'number') {
      throw new ValidationError(
        `Le champ '${fieldName}' doit être un nombre`,
        fieldName,
        expectedType
      );
    }

    if (expectedType === 'boolean' && actualType !== 'boolean') {
      throw new ValidationError(
        `Le champ '${fieldName}' doit être un booléen`,
        fieldName,
        expectedType
      );
    }

    // Validation d'énumération
    if (schema.enum && !schema.enum.includes(value)) {
      throw new ValidationError(
        `Le champ '${fieldName}' doit être l'une des valeurs : ${schema.enum.join(', ')}`,
        fieldName
      );
    }

    // Validation de longueur pour les strings
    if (expectedType === 'string') {
      if (schema.minLength && value.length < schema.minLength) {
        throw new ValidationError(
          `Le champ '${fieldName}' doit contenir au moins ${schema.minLength} caractères`,
          fieldName
        );
      }

      if (schema.maxLength && value.length > schema.maxLength) {
        throw new ValidationError(
          `Le champ '${fieldName}' ne peut pas dépasser ${schema.maxLength} caractères`,
          fieldName
        );
      }
    }

    // Validation de plage pour les nombres
    if (expectedType === 'number') {
      if (schema.minimum !== undefined && value < schema.minimum) {
        throw new ValidationError(
          `Le champ '${fieldName}' doit être supérieur ou égal à ${schema.minimum}`,
          fieldName
        );
      }

      if (schema.maximum !== undefined && value > schema.maximum) {
        throw new ValidationError(
          `Le champ '${fieldName}' ne peut pas dépasser ${schema.maximum}`,
          fieldName
        );
      }
    }

    // Validation de pattern pour les strings
    if (expectedType === 'string' && schema.pattern) {
      const regex = new RegExp(schema.pattern);
      if (!regex.test(value)) {
        throw new ValidationError(
          `Le champ '${fieldName}' ne correspond pas au format attendu`,
          fieldName
        );
      }
    }
  }
}

/**
 * Validateur de chemins de fichiers
 */
export class PathValidator {
  private allowedDirectories: string[];
  private blockedPaths: string[];

  constructor(allowedDirectories: string[], blockedPaths: string[] = []) {
    // Résoudre tous les chemins en absolus
    this.allowedDirectories = allowedDirectories.map(dir => path.resolve(dir));
    this.blockedPaths = blockedPaths.map(p => path.resolve(p));
  }

  /**
   * Valider qu'un chemin est sûr
   */
  validatePath(filePath: string): string {
    // Résoudre le chemin absolu
    const absolutePath = path.resolve(filePath);

    // Vérifier les path traversal (../)
    if (absolutePath.includes('..')) {
      throw new ValidationError(
        'Les chemins avec ".." ne sont pas autorisés (path traversal)'
      );
    }

    // Vérifier que le chemin est dans un répertoire autorisé
    const isInAllowedDir = this.allowedDirectories.some(dir =>
      absolutePath.startsWith(dir)
    );

    if (!isInAllowedDir) {
      throw new ValidationError(
        `Accès refusé : le chemin doit être dans l'un des répertoires autorisés`
      );
    }

    // Vérifier que le chemin n'est pas bloqué
    const isBlocked = this.blockedPaths.some(blocked =>
      absolutePath.startsWith(blocked)
    );

    if (isBlocked) {
      throw new ValidationError(
        `Accès refusé : ce chemin est explicitement bloqué`
      );
    }

    return absolutePath;
  }

  /**
   * Ajouter un répertoire autorisé
   */
  addAllowedDirectory(directory: string): void {
    this.allowedDirectories.push(path.resolve(directory));
  }

  /**
   * Bloquer un chemin spécifique
   */
  blockPath(pathToBlock: string): void {
    this.blockedPaths.push(path.resolve(pathToBlock));
  }
}

/**
 * Validateur de taille de fichier
 */
export class SizeValidator {
  /**
   * Valider qu'une taille est acceptable
   */
  static validateSize(
    size: number,
    maxSize: number,
    fieldName: string = 'fichier'
  ): void {
    if (size > maxSize) {
      throw new ValidationError(
        `Le ${fieldName} est trop volumineux (max ${this.formatSize(maxSize)})`
      );
    }
  }

  /**
   * Formater une taille en octets en format lisible
   */
  static formatSize(bytes: number): string {
    const units = ['octets', 'Ko', 'Mo', 'Go'];
    let size = bytes;
    let unitIndex = 0;

    while (size >= 1024 && unitIndex < units.length - 1) {
      size /= 1024;
      unitIndex++;
    }

    return `${size.toFixed(2)} ${units[unitIndex]}`;
  }
}

// src/security/auth.ts
import crypto from 'crypto';

/**
 * Interface utilisateur
 */
export interface User {
  id: string;
  username: string;
  role: 'admin' | 'user' | 'readonly';
  permissions: string[];
}

/**
 * Token JWT simplifié (pour la démo - utilisez une vraie lib JWT en prod)
 */
interface Token {
  userId: string;
  username: string;
  role: string;
  permissions: string[];
  expiresAt: number;
}

/**
 * Gestionnaire d'authentification
 */
export class AuthManager {
  private users: Map<string, User> = new Map();
  private tokens: Map<string, Token> = new Map();
  private readonly SECRET_KEY: string;
  private readonly TOKEN_DURATION = 24 * 60 * 60 * 1000; // 24 heures

  constructor(secretKey: string) {
    this.SECRET_KEY = secretKey;
    
    // Créer quelques utilisateurs de test
    this.createUser({
      id: '1',
      username: 'admin',
      role: 'admin',
      permissions: ['*'] // Toutes les permissions
    });

    this.createUser({
      id: '2',
      username: 'user',
      role: 'user',
      permissions: ['readFile', 'listFiles', 'searchFiles']
    });

    this.createUser({
      id: '3',
      username: 'readonly',
      role: 'readonly',
      permissions: ['readFile', 'listFiles']
    });
  }

  /**
   * Créer un utilisateur
   */
  createUser(user: User): void {
    this.users.set(user.username, user);
  }

  /**
   * Authentifier un utilisateur et générer un token
   */
  authenticate(username: string, password: string): string | null {
    // En production, vérifier le mot de passe hashé !
    // Ici c'est simplifié pour la démo
    const user = this.users.get(username);
    
    if (!user) {
      return null;
    }

    // Générer un token
    const tokenId = crypto.randomBytes(32).toString('hex');
    const token: Token = {
      userId: user.id,
      username: user.username,
      role: user.role,
      permissions: user.permissions,
      expiresAt: Date.now() + this.TOKEN_DURATION
    };

    this.tokens.set(tokenId, token);
    return tokenId;
  }

  /**
   * Valider un token
   */
  validateToken(tokenId: string): Token | null {
    const token = this.tokens.get(tokenId);
    
    if (!token) {
      return null;
    }

    // Vérifier l'expiration
    if (Date.now() > token.expiresAt) {
      this.tokens.delete(tokenId);
      return null;
    }

    return token;
  }

  /**
   * Révoquer un token
   */
  revokeToken(tokenId: string): void {
    this.tokens.delete(tokenId);
  }

  /**
   * Obtenir un utilisateur
   */
  getUser(username: string): User | undefined {
    return this.users.get(username);
  }

  /**
   * Nettoyer les tokens expirés
   */
  cleanExpiredTokens(): void {
    const now = Date.now();
    for (const [tokenId, token] of this.tokens.entries()) {
      if (now > token.expiresAt) {
        this.tokens.delete(tokenId);
      }
    }
  }
}

/**
 * Middleware d'authentification pour Express
 */
export function authMiddleware(authManager: AuthManager) {
  return (req: any, res: any, next: any) => {
    // Récupérer le token de l'en-tête Authorization
    const authHeader = req.headers.authorization;
    
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      return res.status(401).json({
        success: false,
        error: 'Token d\'authentification manquant'
      });
    }

    const tokenId = authHeader.substring(7); // Enlever "Bearer "
    const token = authManager.validateToken(tokenId);

    if (!token) {
      return res.status(401).json({
        success: false,
        error: 'Token invalide ou expiré'
      });
    }

    // Ajouter les infos utilisateur à la requête
    req.user = token;
    next();
  };
}

// src/security/permissions.ts
import { User } from './auth';

/**
 * Erreur de permission
 */
export class PermissionError extends Error {
  constructor(message: string) {
    super(message);
    this.name = 'PermissionError';
  }
}

/**
 * Gestionnaire de permissions
 */
export class PermissionManager {
  /**
   * Vérifier si un utilisateur a la permission d'utiliser un outil
   */
  static hasPermission(
    user: User,
    toolName: string,
    params?: any
  ): boolean {
    // Les admins ont accès à tout
    if (user.permissions.includes('*')) {
      return true;
    }

    // Vérifier la permission spécifique
    if (!user.permissions.includes(toolName)) {
      return false;
    }

    // Permissions contextuelles supplémentaires
    // Par exemple, vérifier les chemins autorisés pour readFile
    if (toolName === 'readFile' && params?.chemin_du_fichier) {
      return this.canAccessPath(user, params.chemin_du_fichier);
    }

    return true;
  }

  /**
   * Vérifier l'accès à un chemin spécifique
   */
  private static canAccessPath(user: User, filePath: string): boolean {
    // En readonly, uniquement lecture dans certains dossiers
    if (user.role === 'readonly') {
      const allowedPaths = ['/public', '/docs'];
      return allowedPaths.some(allowed => 
        filePath.startsWith(allowed)
      );
    }

    return true;
  }

  /**
   * Obtenir les permissions d'un utilisateur
   */
  static getPermissions(user: User): string[] {
    return user.permissions;
  }

  /**
   * Vérifier et lancer une erreur si pas de permission
   */
  static requirePermission(
    user: User,
    toolName: string,
    params?: any
  ): void {
    if (!this.hasPermission(user, toolName, params)) {
      throw new PermissionError(
        `Permission refusée : vous n'avez pas accès à l'outil '${toolName}'`
      );
    }
  }
}

/**
 * Politique de permissions pour un outil
 */
export interface ToolPolicy {
  allowedRoles: string[];
  requiredPermissions: string[];
  rateLimit?: {
    maxRequests: number;
    windowMs: number;
  };
}

/**
 * Gestionnaire de politiques d'outils
 */
export class PolicyManager {
  private policies: Map<string, ToolPolicy> = new Map();

  /**
   * Définir une politique pour un outil
   */
  setPolicy(toolName: string, policy: ToolPolicy): void {
    this.policies.set(toolName, policy);
  }

  /**
   * Obtenir la politique d'un outil
   */
  getPolicy(toolName: string): ToolPolicy | undefined {
    return this.policies.get(toolName);
  }

  /**
   * Vérifier qu'un utilisateur respecte la politique
   */
  checkPolicy(user: User, toolName: string): boolean {
    const policy = this.policies.get(toolName);
    
    if (!policy) {
      return true; // Pas de politique = autorisé par défaut
    }

    // Vérifier le rôle
    if (!policy.allowedRoles.includes(user.role) && 
        !policy.allowedRoles.includes('*')) {
      return false;
    }

    // Vérifier les permissions
    const hasAllPermissions = policy.requiredPermissions.every(perm =>
      user.permissions.includes(perm) || user.permissions.includes('*')
    );

    return hasAllPermissions;
  }
}

// src/security/rateLimit.ts

/**
 * Enregistrement d'utilisation
 */
interface UsageRecord {
  count: number;
  resetAt: number;
}

/**
 * Gestionnaire de rate limiting
 */
export class RateLimiter {
  private usage: Map<string, UsageRecord> = new Map();

  constructor(
    private maxRequests: number,
    private windowMs: number
  ) {}

  /**
   * Vérifier et incrémenter le compteur pour un utilisateur
   */
  checkLimit(userId: string): boolean {
    const now = Date.now();
    const record = this.usage.get(userId);

    // Pas d'enregistrement ou fenêtre expirée
    if (!record || now > record.resetAt) {
      this.usage.set(userId, {
        count: 1,
        resetAt: now + this.windowMs
      });
      return true;
    }

    // Limite atteinte
    if (record.count >= this.maxRequests) {
      return false;
    }

    // Incrémenter le compteur
    record.count++;
    return true;
  }

  /**
   * Obtenir les infos de limite pour un utilisateur
   */
  getLimitInfo(userId: string): {
    current: number;
    max: number;
    resetsAt: Date;
  } {
    const record = this.usage.get(userId);
    
    if (!record) {
      return {
        current: 0,
        max: this.maxRequests,
        resetsAt: new Date(Date.now() + this.windowMs)
      };
    }

    return {
      current: record.count,
      max: this.maxRequests,
      resetsAt: new Date(record.resetAt)
    };
  }

  /**
   * Réinitialiser le compteur pour un utilisateur
   */
  reset(userId: string): void {
    this.usage.delete(userId);
  }

  /**
   * Nettoyer les enregistrements expirés
   */
  cleanup(): void {
    const now = Date.now();
    for (const [userId, record] of this.usage.entries()) {
      if (now > record.resetAt) {
        this.usage.delete(userId);
      }
    }
  }
}

/**
 * Middleware de rate limiting pour Express
 */
export function rateLimitMiddleware(rateLimiter: RateLimiter) {
  return (req: any, res: any, next: any) => {
    const userId = req.user?.userId || req.ip;

    if (!rateLimiter.checkLimit(userId)) {
      const info = rateLimiter.getLimitInfo(userId);
      return res.status(429).json({
        success: false,
        error: 'Limite de requêtes atteinte',
        limit: {
          max: info.max,
          current: info.current,
          resetsAt: info.resetsAt
        }
      });
    }

    next();
  };
}

/**
 * Gestionnaire de quotas par outil
 */
export class QuotaManager {
  private quotas: Map<string, Map<string, number>> = new Map();

  /**
   * Définir un quota pour un utilisateur et un outil
   */
  setQuota(userId: string, toolName: string, maxUsage: number): void {
    if (!this.quotas.has(userId)) {
      this.quotas.set(userId, new Map());
    }
    this.quotas.get(userId)!.set(toolName, maxUsage);
  }

  /**
   * Vérifier et décrémenter le quota
   */
  checkQuota(userId: string, toolName: string): boolean {
    const userQuotas = this.quotas.get(userId);
    
    if (!userQuotas) {
      return true; // Pas de quota = illimité
    }

    const remaining = userQuotas.get(toolName);
    
    if (remaining === undefined) {
      return true; // Pas de quota pour cet outil
    }

    if (remaining <= 0) {
      return false; // Quota épuisé
    }

    userQuotas.set(toolName, remaining - 1);
    return true;
  }

  /**
   * Obtenir le quota restant
   */
  getRemainingQuota(userId: string, toolName: string): number | null {
    const userQuotas = this.quotas.get(userId);
    
    if (!userQuotas) {
      return null; // Illimité
    }

    return userQuotas.get(toolName) || null;
  }

  /**
   * Réinitialiser le quota d'un utilisateur
   */
  resetQuota(userId: string, toolName: string, maxUsage: number): void {
    this.setQuota(userId, toolName, maxUsage);
  }
}

// src/index.ts
import express, { Request, Response, NextFunction } from 'express';
import { MCP_PROTOCOL_VERSION, SERVER_INFO, DiscoveryResponse } from './mcp/protocol';
import { toolRegistry } from './mcp/registry';
import { AuthManager, authMiddleware } from './security/auth';
import { PermissionManager, PermissionError } from './security/permissions';
import { RateLimiter, rateLimitMiddleware, QuotaManager } from './security/rateLimit';
import { ParameterValidator, ValidationError, PathValidator } from './security/validator';

const app = express();
const PORT = 3000;

// ============================================
// INITIALISATION SÉCURITÉ
// ============================================

const authManager = new AuthManager(process.env.SECRET_KEY || 'your-secret-key-change-me');
const rateLimiter = new RateLimiter(100, 60 * 1000); // 100 req/minute
const quotaManager = new QuotaManager();
const pathValidator = new PathValidator([
  process.cwd(), // Répertoire courant
  '/tmp',        // Dossier temporaire
]);

// Quotas par défaut
quotaManager.setQuota('2', 'readFile', 1000); // user : 1000 lectures/jour
quotaManager.setQuota('3', 'readFile', 100);  // readonly : 100 lectures/jour

// ============================================
// MIDDLEWARES
// ============================================

app.use(express.json());

// Logging
app.use((req, res, next) => {
  console.log(`[${new Date().toISOString()}] ${req.method} ${req.path}`);
  next();
});

// ============================================
// ROUTES PUBLIQUES (sans auth)
// ============================================

/**
 * Page d'accueil
 */
app.get('/', (req, res) => {
  res.json({
    message: 'MCP File Server - Secured',
    version: SERVER_INFO.version,
    protocol_version: MCP_PROTOCOL_VERSION,
    status: 'operational',
    security: {
      authentication: 'required',
      rateLimit: '100 requests/minute',
      endpoints: {
        auth: '/auth/login',
        discovery: '/mcp/tools',
        execute: '/mcp/execute'
      }
    }
  });
});

/**
 * Endpoint d'authentification
 */
app.post('/auth/login', (req, res) => {
  const { username, password } = req.body;

  if (!username || !password) {
    return res.status(400).json({
      success: false,
      error: 'Username et password requis'
    });
  }

  const token = authManager.authenticate(username, password);

  if (!token) {
    return res.status(401).json({
      success: false,
      error: 'Identifiants invalides'
    });
  }

  res.json({
    success: true,
    token: token,
    message: 'Authentification réussie'
  });
});

/**
 * Health check (public)
 */
app.get('/health', (req, res) => {
  res.json({
    status: 'healthy',
    uptime: process.uptime(),
    tools_count: toolRegistry.count(),
    timestamp: new Date().toISOString()
  });
});

// ============================================
// ROUTES PROTÉGÉES (avec auth + rate limit)
// ============================================

// Appliquer l'authentification à toutes les routes /mcp/*
app.use('/mcp', authMiddleware(authManager));
app.use('/mcp', rateLimitMiddleware(rateLimiter));

/**
 * Endpoint de découverte (protégé)
 */
app.get('/mcp/tools', (req: any, res) => {
  const user = req.user;
  
  // Filtrer les outils selon les permissions
  const allTools = toolRegistry.getAllDescriptions();
  const allowedTools = allTools.filter(tool =>
    PermissionManager.hasPermission(
      { 
        id: user.userId,
        username: user.username,
        role: user.role,
        permissions: user.permissions
      },
      tool.name
    )
  );

  const response: DiscoveryResponse = {
    protocol_version: MCP_PROTOCOL_VERSION,
    server_info: SERVER_INFO,
    tools: allowedTools
  };

  console.log(`📋 Découverte - ${allowedTools.length}/${allTools.length} outils visibles pour ${user.username}`);
  res.json(response);
});

/**
 * Endpoint d'exécution sécurisé
 */
app.post('/mcp/execute', async (req: any, res) => {
  const { tool, params } = req.body;
  const user = req.user;

  try {
    // Validation basique
    if (!tool) {
      return res.status(400).json({
        success: false,
        error: "Le paramètre 'tool' est requis"
      });
    }

    // Vérifier les permissions
    PermissionManager.requirePermission(
      {
        id: user.userId,
        username: user.username,
        role: user.role,
        permissions: user.permissions
      },
      tool,
      params
    );

    // Vérifier les quotas
    if (!quotaManager.checkQuota(user.userId, tool)) {
      return res.status(403).json({
        success: false,
        error: 'Quota épuisé pour cet outil',
        remaining: quotaManager.getRemainingQuota(user.userId, tool)
      });
    }

    // Obtenir la description de l'outil pour validation
    const toolDescription = toolRegistry.getDescription(tool);
    if (!toolDescription) {
      return res.status(404).json({
        success: false,
        error: `Outil '${tool}' introuvable`
      });
    }

    // Valider les paramètres selon le schéma
    ParameterValidator.validate(params || {}, toolDescription.input_schema);

    // Validation spécifique des chemins pour les outils de fichiers
    if (tool === 'readFile' || tool === 'listFiles') {
      const pathParam = params.chemin_du_fichier || params.chemin_du_dossier;
      if (pathParam) {
        params.validated_path = pathValidator.validatePath(pathParam);
      }
    }

    console.log(`⚙️  Exécution sécurisée : ${tool} par ${user.username}`);

    // Exécution via le registre
    const result = await toolRegistry.execute(tool, params);

    // Log du résultat
    if (result.success) {
      console.log(`✅ Succès : ${tool} par ${user.username}`);
    } else {
      console.log(`❌ Échec : ${tool} par ${user.username} - ${result.error}`);
    }

    res.json(result);

  } catch (error: any) {
    // Gestion des erreurs de sécurité
    if (error instanceof ValidationError) {
      return res.status(400).json({
        success: false,
        error: error.message,
        field: error.field
      });
    }

    if (error instanceof PermissionError) {
      return res.status(403).json({
        success: false,
        error: error.message
      });
    }

    // Erreur générique
    console.error('Erreur serveur:', error);
    res.status(500).json({
      success: false,
      error: 'Erreur interne du serveur'
    });
  }
});

/**
 * Endpoint pour voir ses permissions
 */
app.get('/mcp/me', (req: any, res) => {
  const user = req.user;
  
  res.json({
    userId: user.userId,
    username: user.username,
    role: user.role,
    permissions: user.permissions,
    rateLimit: rateLimiter.getLimitInfo(user.userId)
  });
});

/**
 * Endpoint pour voir ses quotas
 */
app.get('/mcp/quotas', (req: any, res) => {
  const user = req.user;
  const tools = toolRegistry.getAllDescriptions();
  
  const quotas = tools.map(tool => ({
    tool: tool.name,
    remaining: quotaManager.getRemainingQuota(user.userId, tool.name)
  }));

  res.json({
    userId: user.userId,
    quotas: quotas
  });
});

// ============================================
// GESTION DES ERREURS
// ============================================

app.use((err: any, req: Request, res: Response, next: NextFunction) => {
  console.error('Erreur non gérée:', err);
  res.status(500).json({
    success: false,
    error: 'Erreur interne du serveur'
  });
});

// ============================================
// TÂCHES DE MAINTENANCE
// ============================================

// Nettoyer les tokens expirés toutes les heures
setInterval(() => {
  authManager.cleanExpiredTokens();
  rateLimiter.cleanup();
  console.log('🧹 Nettoyage des tokens et rate limits expirés');
}, 60 * 60 * 1000);

// ============================================
// DÉMARRAGE DU SERVEUR
// ============================================

app.listen(PORT, () => {
  console.log('═══════════════════════════════════════');
  console.log('🔒 MCP File Server - Secured Edition');
  console.log('═══════════════════════════════════════');
  console.log(`📍 URL: http://localhost:${PORT}`);
  console.log(`🔐 Auth: POST http://localhost:${PORT}/auth/login`);
  console.log(`📋 Découverte: GET http://localhost:${PORT}/mcp/tools`);
  console.log(`⚙️  Exécution: POST http://localhost:${PORT}/mcp/execute`);
  console.log(`🔧 Outils: ${toolRegistry.count()}`);
  console.log('═══════════════════════════════════════');
  console.log('👤 Utilisateurs de test:');
  console.log('   - admin (toutes permissions)');
  console.log('   - user (lecture + liste + recherche)');
  console.log('   - readonly (lecture + liste seulement)');
  console.log('═══════════════════════════════════════');
});

// src/secure-client.ts

const SERVER_URL = 'http://localhost:3000';

class SecureClient {
  private token: string | null = null;

  /**
   * S'authentifier
   */
  async login(username: string, password: string): Promise<boolean> {
    const response = await fetch(`${SERVER_URL}/auth/login`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ username, password })
    });

    const data = await response.json();

    if (data.success) {
      this.token = data.token;
      console.log(`✅ Authentifié en tant que ${username}`);
      return true;
    }

    console.log(`❌ Échec d'authentification`);
    return false;
  }

  /**
   * Découvrir les outils disponibles
   */
  async discoverTools() {
    if (!this.token) {
      throw new Error('Non authentifié');
    }

    const response = await fetch(`${SERVER_URL}/mcp/tools`, {
      headers: {
        'Authorization': `Bearer ${this.token}`
      }
    });

    return await response.json();
  }

  /**
   * Exécuter un outil
   */
  async executeTool(toolName: string, params: any) {
    if (!this.token) {
      throw new Error('Non authentifié');
    }

    const response = await fetch(`${SERVER_URL}/mcp/execute`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.token}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        tool: toolName,
        params: params
      })
    });

    return await response.json();
  }

  /**
   * Voir ses informations
   */
  async getMe() {
    if (!this.token) {
      throw new Error('Non authentifié');
    }

    const response = await fetch(`${SERVER_URL}/mcp/me`, {
      headers: {
        'Authorization': `Bearer ${this.token}`
      }
    });

    return await response.json();
  }

  /**
   * Voir ses quotas
   */
  async getQuotas() {
    if (!this.token) {
      throw new Error('Non authentifié');
    }

    const response = await fetch(`${SERVER_URL}/mcp/quotas`, {
      headers: {
        'Authorization': `Bearer ${this.token}`
      }
    });

    return await response.json();
  }
}

/**
 * Démonstration complète
 */
async function demo() {
  console.log('═══════════════════════════════════════');
  console.log('🔒 Démo Client Sécurisé MCP');
  console.log('═══════════════════════════════════════\n');

  const client = new SecureClient();

  // Test 1 : Authentification
  console.log('📝 Test 1 : Authentification\n');
  await client.login('user', 'password');

  // Test 2 : Voir ses infos
  console.log('\n📝 Test 2 : Informations utilisateur\n');
  const me = await client.getMe();
  console.log(JSON.stringify(me, null, 2));

  // Test 3 : Découverte des outils
  console.log('\n📝 Test 3 : Découverte des outils\n');
  const discovery = await client.discoverTools();
  console.log(`Outils disponibles : ${discovery.tools.length}`);
  discovery.tools.forEach((tool: any) => {
    console.log(`  - ${tool.name}: ${tool.description}`);
  });

  // Test 4 : Exécution d'un outil
  console.log('\n📝 Test 4 : Exécution d\'un outil\n');
  const result = await client.executeTool('listFiles', {
    chemin_du_dossier: '.'
  });
  
  if (result.success) {
    console.log('✅ Succès !');
  } else {
    console.log(`❌ Erreur : ${result.error}`);
  }

  // Test 5 : Vérifier les quotas
  console.log('\n📝 Test 5 : Quotas restants\n');
  const quotas = await client.getQuotas();
  console.log(JSON.stringify(quotas, null, 2));

  console.log('\n═══════════════════════════════════════');
}

demo().catch(console.error);

// Créez un fichier .env
SECRET_KEY=your-super-secret-key-change-me-in-production
JWT_EXPIRATION=86400

// Dans votre code
import dotenv from 'dotenv';
dotenv.config();

const SECRET_KEY = process.env.SECRET_KEY;

import bcrypt from 'bcrypt';

// Lors de la création d'un utilisateur
const hashedPassword = await bcrypt.hash(password, 10);

// Lors de l'authentification
const isValid = await bcrypt.compare(password, user.hashedPassword);

app.use((req, res, next) => {
  if (req.header('x-forwarded-proto') !== 'https' && process.env.NODE_ENV === 'production') {
    res.redirect(`https://${req.header('host')}${req.url}`);
  } else {
    next();
  }
});

function logSecurityEvent(event: string, details: any) {
  // En production : envoyer vers un service d'audit
  console.log(JSON.stringify({
    timestamp: new Date().toISOString(),
    event: event,
    ...details
  }));
}

// Utilisation
logSecurityEvent('AUTH_FAILED', { username, ip: req.ip });
logSecurityEvent('PERMISSION_DENIED', { user: req.user.username, tool });

class AuditLogger {
  log(action: string, userId: string, details: any) {
    // En production : envoyer vers un service d'audit
    console.log({
      timestamp: new Date().toISOString(),
      action,
      userId,
      ...details
    });
  }
}