ihm_client/src/utils/logger.ts

/**
 * Système de logging structuré pour l'application 4NK
 * Fournit des logs cohérents avec différents niveaux et contextes
 */

export enum LogLevel {
  DEBUG = 0,
  INFO = 1,
  WARN = 2,
  ERROR = 3,
}

export interface LogContext {
  component?: string;
  operation?: string;
  userId?: string;
  deviceId?: string;
  pairingId?: string;
  [key: string]: any;
}

export interface LogEntry {
  level: LogLevel;
  message: string;
  context?: LogContext;
  timestamp: number;
  stack?: string;
}

class Logger {
  private static instance: Logger;
  private logLevel: LogLevel;
  private logs: LogEntry[] = [];
  private maxLogs: number = 1000;

  private constructor(level: LogLevel = LogLevel.INFO) {
    this.logLevel = level;
  }

  public static getInstance(level?: LogLevel): Logger {
    if (!Logger.instance) {
      Logger.instance = new Logger(level);
    }
    return Logger.instance;
  }

  public setLevel(level: LogLevel): void {
    this.logLevel = level;
  }

  private shouldLog(level: LogLevel): boolean {
    return level >= this.logLevel;
  }

  private createLogEntry(level: LogLevel, message: string, context?: LogContext): LogEntry {
    return {
      level,
      message,
      context: context !== null && context !== undefined ? context : undefined,
      timestamp: Date.now(),
      stack: level >= LogLevel.ERROR ? new Error().stack : undefined,
    };
  }

  private log(level: LogLevel, message: string, context?: LogContext): void {
    if (!this.shouldLog(level)) return;

    const entry = this.createLogEntry(level, message, context);
    this.logs.push(entry);

    // Garder seulement les derniers logs
    if (this.logs.length > this.maxLogs) {
      this.logs = this.logs.slice(-this.maxLogs);
    }

    // Afficher dans la console avec formatage
    this.consoleLog(entry);
  }

  private consoleLog(entry: LogEntry): void {
    const timestamp = new Date(entry.timestamp).toISOString();
    const levelName = LogLevel[entry.level];
    const contextStr = entry.context ? ` ${JSON.stringify(entry.context)}` : '';

    const logMessage = `[${timestamp}] ${levelName}: ${entry.message}${contextStr}`;

    switch (entry.level) {
      case LogLevel.DEBUG:
        console.debug(logMessage);
        break;
      case LogLevel.INFO:
        console.info(logMessage);
        break;
      case LogLevel.WARN:
        console.warn(logMessage);
        break;
      case LogLevel.ERROR:
        console.error(logMessage);
        if (entry.stack) {
          console.error(entry.stack);
        }
        break;
    }
  }

  public debug(message: string, context?: LogContext): void {
    this.log(LogLevel.DEBUG, message, context);
  }

  public info(message: string, context?: LogContext): void {
    this.log(LogLevel.INFO, message, context);
  }

  public warn(message: string, context?: LogContext): void {
    this.log(LogLevel.WARN, message, context);
  }

  public error(message: string, context?: LogContext): void {
    this.log(LogLevel.ERROR, message, context);
  }

  public metric(name: string, value: number, context?: LogContext): void {
    this.info(`METRIC: ${name} = ${value}`, { ...context, metric: name, value });
  }

  public getLogs(): LogEntry[] {
    return [...this.logs];
  }

  public clearLogs(): void {
    this.logs = [];
  }

  public exportLogs(): string {
    return JSON.stringify(this.logs, null, 2);
  }
}

// Export de l'instance par défaut
export const logger = Logger.getInstance();

// Export de fonctions utilitaires
export function createLogger(component: string): Logger {
  const logger = Logger.getInstance();
  return {
    ...logger,
    debug: (message: string, context?: LogContext) =>
      logger.debug(message, { ...context, component }),
    info: (message: string, context?: LogContext) =>
      logger.info(message, { ...context, component }),
    warn: (message: string, context?: LogContext) =>
      logger.warn(message, { ...context, component }),
    error: (message: string, context?: LogContext) =>
      logger.error(message, { ...context, component }),
    metric: (name: string, value: number, context?: LogContext) =>
      logger.metric(name, value, { ...context, component }),
  } as Logger;
}