/**
 * 统一日志管理器
 * 提供结构化的日志记录功能，支持环境区分和敏感信息脱敏
 */

type LogLevel = 'debug' | 'info' | 'warn' | 'error';

interface LogData {
  [key: string]: any;
}

class Logger {
  private isDev: boolean;
  private enabledLevels: Set<LogLevel>;
  private sensitiveKeys = ['token', 'password', 'api_key', 'authorization', 'secret', 'apikey'];

  constructor() {
    this.isDev = import.meta.env.DEV;
    // 开发环境：所有级别；生产环境：仅 error
    this.enabledLevels = new Set(this.isDev ? ['debug', 'info', 'warn', 'error'] : ['error']);
  }

  /**
   * 格式化日志消息
   */
  private formatMessage(level: LogLevel, module: string, message: string): string {
    const timestamp = new Date().toISOString();
    return `[${timestamp}] [${level.toUpperCase()}] [${module}] ${message}`;
  }

  /**
   * 脱敏处理：移除或隐藏敏感信息
   */
  private sanitize(data: any): any {
    if (!data) return data;

    // 处理基本类型
    if (typeof data !== 'object') return data;

    // 处理数组
    if (Array.isArray(data)) {
      return data.map((item) => this.sanitize(item));
    }

    // 处理对象
    const sanitized: LogData = {};
    for (const key in data) {
      if (!Object.prototype.hasOwnProperty.call(data, key)) continue;

      const lowerKey = key.toLowerCase();
      const isSensitive = this.sensitiveKeys.some((k) => lowerKey.includes(k));

      if (isSensitive) {
        sanitized[key] = '***REDACTED***';
      } else if (typeof data[key] === 'object' && data[key] !== null) {
        sanitized[key] = this.sanitize(data[key]);
      } else {
        sanitized[key] = data[key];
      }
    }

    return sanitized;
  }

  /**
   * 检查日志级别是否启用
   */
  private isLevelEnabled(level: LogLevel): boolean {
    return this.enabledLevels.has(level);
  }

  /**
   * 调试日志 - 仅开发环境
   */
  debug(module: string, message: string, data?: LogData) {
    if (!this.isLevelEnabled('debug')) return;

    const formattedMessage = this.formatMessage('debug', module, message);
    if (data) {
      console.log(formattedMessage, this.sanitize(data));
    } else {
      console.log(formattedMessage);
    }
  }

  /**
   * 信息日志 - 仅开发环境
   */
  info(module: string, message: string, data?: LogData) {
    if (!this.isLevelEnabled('info')) return;

    const formattedMessage = this.formatMessage('info', module, message);
    if (data) {
      console.log(formattedMessage, this.sanitize(data));
    } else {
      console.log(formattedMessage);
    }
  }

  /**
   * 警告日志 - 仅开发环境
   */
  warn(module: string, message: string, data?: LogData) {
    if (!this.isLevelEnabled('warn')) return;

    const formattedMessage = this.formatMessage('warn', module, message);
    if (data) {
      console.warn(formattedMessage, this.sanitize(data));
    } else {
      console.warn(formattedMessage);
    }
  }

  /**
   * 错误日志 - 所有环境
   * 生产环境会发送到错误追踪服务（如已配置）
   */
  error(module: string, message: string, error?: any, data?: LogData) {
    if (!this.isLevelEnabled('error')) return;

    const formattedMessage = this.formatMessage('error', module, message);

    if (error || data) {
      console.error(formattedMessage, error || '', data ? this.sanitize(data) : '');
    } else {
      console.error(formattedMessage);
    }

    // 生产环境发送到错误追踪服务（如 Sentry）
    if (!this.isDev && typeof window !== 'undefined' && (window as any).Sentry) {
      (window as any).Sentry.captureException(error || new Error(message), {
        tags: { module },
        extra: { message, ...this.sanitize(data || {}) },
      });
    }
  }

  /**
   * 性能日志 - 记录操作耗时
   */
  performance(module: string, operation: string, durationMs: number, data?: LogData) {
    this.debug(module, `Performance: ${operation} took ${durationMs}ms`, data);
  }
}

// 导出单例
export const logger = new Logger();

// 导出类型
export type { LogLevel, LogData };