/**
 * Unified logging utility for ColaFlow
 * Provides type-safe logging with environment-aware behavior
 */

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

interface LoggerConfig {
  isDevelopment: boolean;
  enableDebug: boolean;
  enableInfo: boolean;
}

class Logger {
  private config: LoggerConfig;

  constructor() {
    this.config = {
      isDevelopment: process.env.NODE_ENV === 'development',
      enableDebug: process.env.NODE_ENV === 'development',
      enableInfo: process.env.NODE_ENV === 'development',
    };
  }

  /**
   * Debug level logging - only in development
   */
  debug(message: string, data?: unknown): void {
    if (this.config.enableDebug) {
      console.log(`[DEBUG] ${message}`, data !== undefined ? data : '');
    }
  }

  /**
   * Info level logging - only in development
   */
  info(message: string, data?: unknown): void {
    if (this.config.enableInfo) {
      console.info(`[INFO] ${message}`, data !== undefined ? data : '');
    }
  }

  /**
   * Warning level logging - always logged
   */
  warn(message: string, data?: unknown): void {
    console.warn(`[WARN] ${message}`, data !== undefined ? data : '');
  }

  /**
   * Error level logging - always logged
   * In production, this should integrate with error tracking services
   */
  error(message: string, error?: unknown): void {
    console.error(`[ERROR] ${message}`, error !== undefined ? error : '');

    // In production, send to error tracking service
    if (!this.config.isDevelopment) {
      // TODO: Integrate with Sentry/DataDog/etc
      // errorTracker.captureException(error, { message });
    }
  }

  /**
   * Log with context information for better debugging
   */
  logWithContext(level: LogLevel, message: string, context?: Record<string, unknown>): void {
    const contextString = context ? JSON.stringify(context) : '';

    switch (level) {
      case 'debug':
        this.debug(message, context);
        break;
      case 'info':
        this.info(message, context);
        break;
      case 'warn':
        this.warn(message, context);
        break;
      case 'error':
        this.error(message, context);
        break;
    }
  }
}

// Export singleton instance
export const logger = new Logger();