/**
 * Logger Utility
 *
 * Centralized logging for the SDK
 *
 * @module utils/logger
 */

import { LogLevel } from '../types/SDKConfig';

/**
 * Logger configuration
 */
interface LoggerConfig {
  /** Minimum log level to output */
  level: LogLevel;
  /** Custom logger function */
  customLogger?: (level: LogLevel, message: string, ...args: unknown[]) => void;
  /** Prefix for log messages */
  prefix?: string;
}

/**
 * Log levels in priority order (lower index = higher priority)
 */
const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
  [LogLevel.NONE]: 0,
  [LogLevel.ERROR]: 1,
  [LogLevel.WARN]: 2,
  [LogLevel.INFO]: 3,
  [LogLevel.DEBUG]: 4,
  [LogLevel.VERBOSE]: 5,
};

/**
 * Logger class
 *
 * Provides structured logging with log levels and custom logger support.
 */
export class Logger {
  private config: LoggerConfig;

  /**
   * Create a logger
   *
   * @param config - Logger configuration
   */
  constructor(config: LoggerConfig) {
    this.config = config;
  }

  /**
   * Update logger configuration
   *
   * @param config - New configuration
   */
  configure(config: Partial<LoggerConfig>): void {
    this.config = {
      ...this.config,
      ...config,
    };
  }

  /**
   * Check if a log level should be output
   *
   * @param level - Log level to check
   * @returns True if should log, false otherwise
   */
  private shouldLog(level: LogLevel): boolean {
    const configPriority = LOG_LEVEL_PRIORITY[this.config.level];
    const levelPriority = LOG_LEVEL_PRIORITY[level];
    return levelPriority <= configPriority;
  }

  /**
   * Format a log message
   *
   * @param level - Log level
   * @param message - Message
   * @returns Formatted message
   */
  private formatMessage(level: LogLevel, message: string): string {
    const timestamp = new Date().toISOString();
    const prefix = this.config.prefix || 'Orbis1SDK';
    return `[${timestamp}] [${prefix}] [${level.toUpperCase()}] ${message}`;
  }

  /**
   * Log a message
   *
   * @param level - Log level
   * @param message - Message
   * @param args - Additional arguments
   */
  private log(level: LogLevel, message: string, ...args: unknown[]): void {
    if (!this.shouldLog(level)) {
      return;
    }

    const formattedMessage = this.formatMessage(level, message);

    if (this.config.customLogger) {
      this.config.customLogger(level, formattedMessage, ...args);
    } else {
      this.defaultLog(level, formattedMessage, ...args);
    }
  }

  /**
   * Default console logging
   *
   * @param level - Log level
   * @param message - Formatted message
   * @param args - Additional arguments
   */
  private defaultLog(
    level: LogLevel,
    message: string,
    ...args: unknown[]
  ): void {
    switch (level) {
      case LogLevel.ERROR:
        console.error(message, ...args);
        break;
      case LogLevel.WARN:
        console.warn(message, ...args);
        break;
      case LogLevel.INFO:
        console.info(message, ...args);
        break;
      case LogLevel.DEBUG:
      case LogLevel.VERBOSE:
        console.log(message, ...args);
        break;
      default:
        break;
    }
  }

  /**
   * Log an error
   *
   * @param message - Error message
   * @param args - Additional arguments
   */
  error(message: string, ...args: unknown[]): void {
    this.log(LogLevel.ERROR, message, ...args);
  }

  /**
   * Log a warning
   *
   * @param message - Warning message
   * @param args - Additional arguments
   */
  warn(message: string, ...args: unknown[]): void {
    this.log(LogLevel.WARN, message, ...args);
  }

  /**
   * Log an info message
   *
   * @param message - Info message
   * @param args - Additional arguments
   */
  info(message: string, ...args: unknown[]): void {
    this.log(LogLevel.INFO, message, ...args);
  }

  /**
   * Log a debug message
   *
   * @param message - Debug message
   * @param args - Additional arguments
   */
  debug(message: string, ...args: unknown[]): void {
    this.log(LogLevel.DEBUG, message, ...args);
  }

  /**
   * Log a verbose message
   *
   * @param message - Verbose message
   * @param args - Additional arguments
   */
  verbose(message: string, ...args: unknown[]): void {
    this.log(LogLevel.VERBOSE, message, ...args);
  }

  /**
   * Create a child logger with a prefix
   *
   * @param prefix - Prefix for the child logger
   * @returns Child logger
   */
  child(prefix: string): Logger {
    const childPrefix = this.config.prefix
      ? `${this.config.prefix}:${prefix}`
      : prefix;

    return new Logger({
      ...this.config,
      prefix: childPrefix,
    });
  }

  /**
   * Get current log level
   *
   * @returns Current log level
   */
  getLevel(): LogLevel {
    return this.config.level;
  }

  /**
   * Set log level
   *
   * @param level - New log level
   */
  setLevel(level: LogLevel): void {
    this.config.level = level;
  }
}

/**
 * Create a logger
 *
 * @param config - Logger configuration
 * @returns Logger instance
 */
export function createLogger(config: Partial<LoggerConfig> = {}): Logger {
  return new Logger({
    level: LogLevel.INFO,
    ...config,
  });
}

/**
 * Default logger instance
 */
export const defaultLogger = createLogger({ prefix: 'Orbis1SDK' });