// Native implementation of util.format functionality
function format(f: unknown, ...args: unknown[]): string {
  if (typeof f !== 'string') {
    // If first argument is not a string, just join all args with spaces
    return [f, ...args].map(arg => {
      if (arg === null) return 'null';
      if (arg === undefined) return 'undefined';
      if (typeof arg === 'object') {
        try {
          return JSON.stringify(arg, null, 0);
        } catch {
          // Handle circular references and other JSON errors
          return '[object Object]';
        }
      }
      return String(arg);
    }).join(' ');
  }

  let i = 0;
  // First, handle %% replacement - if there are no args, %% stays as %%
  // If there are args, %% becomes %
  const handlePercentPercent = args.length === 0 ? '%%' : '%';

  const str = f.replace(/%[sdifj%]/g, (match: string) => {
    if (match === '%%') {
      return handlePercentPercent;
    }

    if (i >= args.length) return match;

    const arg = args[i++];

    switch (match) {
      case '%s':
        if (arg === null) return 'null';
        if (arg === undefined) return 'undefined';
        if (typeof arg === 'object') {
          try {
            // For objects without %j, use a simplified string representation
            if (Array.isArray(arg)) {
              return `[ ${arg.join(', ')} ]`;
            }
            // For plain objects, show key-value pairs
            const entries = Object.entries(arg).map(([k, v]) => `${k}: ${typeof v === 'string' ? `'${v}'` : v}`);
            return `{ ${entries.join(', ')} }`;
          } catch {
            return '[object Object]';
          }
        }
        try {
          return String(arg);
        } catch {
          return '[object Object]';
        }

      case '%d':
        if (arg === null) return '0';
        if (arg === undefined) return 'NaN';
        return String(Number(arg));

      case '%i':
        if (arg === null) return '0';
        if (arg === undefined) return 'NaN';
        return String(parseInt(String(Number(arg)), 10));

      case '%f':
        if (arg === null) return '0';
        if (arg === undefined) return 'NaN';
        return String(parseFloat(String(Number(arg))));

      case '%j':
        try {
          return JSON.stringify(arg);
        } catch {
          return '[Circular]';
        }

      default:
        return match;
    }
  });

  // Append any remaining arguments
  const remainingArgs = args.slice(i);
  if (remainingArgs.length > 0) {
    return str + ' ' + remainingArgs.map(arg => {
      if (arg === null) return 'null';
      if (arg === undefined) return 'undefined';
      if (typeof arg === 'object') {
        try {
          if (Array.isArray(arg)) {
            return `[ ${arg.join(', ')} ]`;
          }
          const entries = Object.entries(arg).map(([k, v]) => `${k}: ${typeof v === 'string' ? `'${v}'` : v}`);
          return `{ ${entries.join(', ')} }`;
        } catch {
          return '[object Object]';
        }
      }
      return String(arg);
    }).join(' ');
  }

  return str;
}

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

export interface LogLevels {
  [level: string]: number;
  silent: -1;
  error: 0;
  warn: 1;
  info: 2;
  debug: 3;
}

export interface Colours {
  [level: string]: string;
  error: string;
  warn: string;
  info: string;
  debug: string;
  reset: string;
}

export interface LogEntry {
  level: string;
  levelNumber: number;
  time: string;
  pid: number;
  hostname: string;
  msg: string;
  callerFile?: string;
  callerLine?: number;
  [key: string]: unknown;
}

export type Formatter = (logEntry: LogEntry) => string;

export interface LoggerOptions {
  level?: LogLevel;
  levels?: Partial<LogLevels>;
  format?: 'json' | 'simple';
  time?: 'long' | 'short';
  callerLevel?: LogLevel;
  colours?: Partial<Colours>;
}

class Logger {
  options: {
    level: LogLevel;
    levels: LogLevels;
    format: 'json' | 'simple';
    time: 'long' | 'short';
    callerLevel: LogLevel;
    colours: Colours;
  };
  isRedirected: boolean;
  formatters: { [key: string]: Formatter };
  callerErrorCount: number;
  maxCallerErrors: number;

  constructor(options: LoggerOptions = {}) {
    this.validateOptions(options);

    const defaultLevels: LogLevels = {
      silent: -1,
      error: 0,
      warn: 1,
      info: 2,
      debug: 3,
    };

    const defaultColours: Colours = {
      error: '\x1b[91m',
      warn: '\x1b[33m',
      info: '\x1b[94m',
      debug: '\x1b[37m',
      reset: '\x1b[0m',
    };

    this.options = {
      level: options.level || 'info',
      levels: Object.assign({}, defaultLevels, options.levels),
      format: options.format || 'json',
      time: options.time || 'short',
      callerLevel: options.callerLevel || 'warn',
      colours: Object.assign({}, defaultColours, options.colours),
    };

    // Detect if output is redirected to a file
    this.isRedirected = !Deno.stdout.isTerminal();

    // Initialize formatters registry
    this.formatters = {
      json: this.jsonFormatter.bind(this),
      simple: this.simpleFormatter.bind(this),
    };

    // prevent infinite loop when reporting internal errors in getCallerInfo()
    this.callerErrorCount = 0;
    this.maxCallerErrors = 5;
  }

  validateOptions(options: LoggerOptions): void {
    // Validate level if provided
    if (options.level !== undefined) {
      const validLevels: LogLevel[] = ['silent', 'error', 'warn', 'info', 'debug'];
      if (!validLevels.includes(options.level)) {
        throw new Error(
          `Invalid log level: ${
            options.level
          }. Valid levels are: ${validLevels.join(', ')}`
        );
      }
    }

    // Validate format if provided
    if (options.format !== undefined) {
      const validFormats = ['json', 'simple'];
      if (!validFormats.includes(options.format)) {
        throw new Error(
          `Invalid format: ${
            options.format
          }. Valid formats are: ${validFormats.join(', ')}`
        );
      }
    }

    // Validate time if provided
    if (options.time !== undefined) {
      const validTimes = ['long', 'short'];
      if (!validTimes.includes(options.time)) {
        throw new Error(
          `Invalid time: ${
            options.time
          }. Valid times are: ${validTimes.join(', ')}`
        );
      }
    }

    // Validate callerLevel if provided
    if (options.callerLevel !== undefined) {
      const validLevels: LogLevel[] = ['silent', 'error', 'warn', 'info', 'debug'];
      if (!validLevels.includes(options.callerLevel)) {
        throw new Error(
          `Invalid callerLevel: ${
            options.callerLevel
          }. Valid levels are: ${validLevels.join(', ')}`
        );
      }
    }

    // Validate colours if provided (should be an object)
    if (options.colours !== undefined && typeof options.colours !== 'object') {
      throw new Error('colours option must be an object');
    }

    // Validate levels if provided (should be an object with numeric values)
    if (options.levels !== undefined) {
      if (typeof options.levels !== 'object') {
        throw new Error('levels option must be an object');
      }

      for (const [level, value] of Object.entries(options.levels)) {
        if (
          typeof value !== 'number' ||
          value < 0 ||
          !Number.isInteger(value)
        ) {
          throw new Error(
            `Level value for '${level}' must be a non-negative integer`
          );
        }
      }
    }
  }

  // JSON log formatter
  jsonFormatter(logEntry: LogEntry): string {
    try {
      return JSON.stringify(logEntry);
    } catch (error) {
      // Fallback for circular references or other JSON.stringify errors
      try {
        // Try to create a safe version by stringifying individual fields
        const safeEntry = {
          level: logEntry.level,
          levelNumber: logEntry.levelNumber,
          time: logEntry.time,
          pid: logEntry.pid,
          hostname: logEntry.hostname,
          msg: String(logEntry.msg), // Convert to string safely
          callerFile: logEntry.callerFile,
          callerLine: logEntry.callerLine,
          jsonError: `JSON stringify failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
        };
        return JSON.stringify(safeEntry);
      } catch {
        // Last resort - return a plain string
        return `{"level":"${logEntry.level}","msg":"${String(
          logEntry.msg
          // eslint-disable-next-line no-useless-escape
        ).replace(/"/g, '\"')}","jsonError":"Multiple JSON errors occurred"}`;
      }
    }
  }

  // Simple text log formatter
  simpleFormatter(logEntry: LogEntry): string {
    const levelPadded = logEntry.level.toUpperCase().padEnd(5);
    const caller = logEntry.callerFile
      ? `${logEntry.callerFile.split('/').pop()}:${logEntry.callerLine}`
      : null;

    return caller
      ? `[${logEntry.time}] [${levelPadded}] [${caller}] ${logEntry.msg}`
      : `[${logEntry.time}] [${levelPadded}] ${logEntry.msg}`;
  }

  getCallerInfo(): { callerFile: string; callerLine: number } {
    const originalFunc = (Error as unknown as { prepareStackTrace?: unknown }).prepareStackTrace;
    let callerFile = 'unknown';
    let callerLine = 0;
    try {
      const err = new Error();
      // deno-lint-ignore prefer-const
      let currentFile: string | undefined;
      (Error as unknown as { prepareStackTrace?: unknown }).prepareStackTrace = function (_err: unknown, stack: unknown) {
        return stack;
      };
      const stack = err.stack as unknown as { shift: () => { getFileName: () => string; getLineNumber: () => number }; length: number };
      currentFile = stack.shift().getFileName();
      while (stack.length) {
        const stackFrame = stack.shift();
        callerFile = stackFrame.getFileName();
        if (currentFile !== callerFile) {
          callerLine = stackFrame.getLineNumber();
          break;
        }
      }
      this.callerErrorCount = 0;
    } catch (e) {
      this.callerErrorCount++;
      if (this.callerErrorCount <= this.maxCallerErrors) {
        console.error('Error retrieving caller info:', e);
        if (this.callerErrorCount === this.maxCallerErrors) {
          // loop detected
          console.error(
            `Caller detection failed ${this.maxCallerErrors} times. Suppressing further caller error messages.`
          );
        }
      }
      // callerFile and callerLine already set to defaults above
    } finally {
      (Error as unknown as { prepareStackTrace?: unknown }).prepareStackTrace = originalFunc;
    }
    return { callerFile, callerLine };
  }

  log(level: LogLevel, message: unknown, ...args: unknown[]): void {
    if (this.options.levels[level] > this.options.levels[this.options.level]) {
      return;
    }

    // Only get caller info if current level is at or above callerLevel threshold
    const shouldIncludeCaller =
      this.options.levels[level] <=
      this.options.levels[this.options.callerLevel];
    const { callerFile, callerLine } = shouldIncludeCaller
      ? this.getCallerInfo()
      : { callerFile: undefined, callerLine: undefined };

    const now = new Date();
    const time =
      this.options.time === 'long'
        ? now.toISOString()
        : now.toISOString().slice(0, 16).replace('T', ' ');

    const logEntry: LogEntry = {
      level,
      levelNumber: this.options.levels[level],
      time: time,
      pid: Deno.pid,
      hostname: Deno.hostname(),
      msg: format(message, ...args),
    };

    // Only include caller info if it was requested
    if (shouldIncludeCaller && callerFile !== undefined && callerLine !== undefined) {
      logEntry.callerFile = callerFile;
      logEntry.callerLine = callerLine;
    }

    const colour = this.options.colours[level];
    const resetColour = this.options.colours.reset;

    // Select the appropriate formatter
    const formatter =
      this.formatters[this.options.format] || this.formatters.json;

    let formattedLog: string;
    try {
      formattedLog = formatter(logEntry);

      // Ensure formatter returned a string
      if (typeof formattedLog !== 'string') {
        throw new Error(
          `Formatter returned ${typeof formattedLog} instead of string`
        );
      }
    } catch (error) {
      // Formatter failed, fall back to JSON formatter
      try {
        const safeEntry = {
          ...logEntry,
          formatterError: `Formatter failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
        };
        formattedLog = this.formatters.json(safeEntry);
      } catch {
        // Even JSON formatter failed, create minimal safe output
        formattedLog = `{"level":"${logEntry.level}","msg":"${String(
          logEntry.msg
        ).replace(
          /"/g,
          // eslint-disable-next-line no-useless-escape
          '\"'
        )}","formatterError":"Formatter failed: ${error instanceof Error ? error.message : 'Unknown error'}"}`;
      }
    }

    // only show colours if logging to console
    if (this.isRedirected) {
      console.log(formattedLog);
    } else {
      console.log(`${colour}${formattedLog}${resetColour}`);
    }
  }

  error(message: unknown, ...args: unknown[]): void {
    this.log('error', message, ...args);
  }

  warn(message: unknown, ...args: unknown[]): void {
    this.log('warn', message, ...args);
  }

  info(message: unknown, ...args: unknown[]): void {
    this.log('info', message, ...args);
  }

  debug(message: unknown, ...args: unknown[]): void {
    this.log('debug', message, ...args);
  }

  level(): LogLevel;
  level(newLevel: LogLevel): LogLevel;
  level(newLevel?: LogLevel): LogLevel {
    // If argument provided, set the new level
    if (arguments.length > 0 && newLevel !== undefined) {
      if (Object.hasOwn(this.options.levels, newLevel)) {
        this.options.level = newLevel;
      } else {
        throw new Error(`Invalid log level: ${newLevel}`);
      }
    }
    return this.options.level;
  }

  setLevel(): LogLevel;
  setLevel(newLevel: LogLevel): LogLevel;
  setLevel(newLevel?: LogLevel): LogLevel {
    if (arguments.length === 0) {
      // Why are you using this as a getter?
      return this.level();
    }
    return this.level(newLevel!);
  }
}

export default Logger;