import {Level, type Options, type Writer} from './types'

export const writers = new Map<string, Writer>()
export let options: Options = {
  format: '[$time] $level $namespace :',
  pad_level: true,
  verbose: true
}

export class Logger {
  constructor(private readonly _namespace: string) {}

  public get namespace(): string {
    return this._namespace
  }

  public extend(sub_namespace: string): Logger {
    return new Logger(`${this.namespace}:${sub_namespace}`)
  }

  public debug(...data: any[]): void {
    log(data, Level.DEBUG, this._namespace)
  }

  public trace(...data: any[]): void {
    log(data, Level.TRACE, this._namespace)
  }

  public info(...data: any[]): void {
    log(data, Level.INFO, this._namespace)
  }

  public warn(...data: any[]): void {
    log(data, Level.WARNING, this._namespace)
  }

  public error(...data: any[]): void {
    log(data, Level.ERROR, this._namespace)
  }
}

function log(message: any[], level: Level, namespace: string): void {
  if (writers.size === 0) {
    if (options.verbose) console.log('No writer subscribed, discard message')
    return
  }

  // Format header of log
  const head = options.format.replace('$time', new Date().toISOString()).replace('$namespace', namespace)

  let lvl = get_string(level)
  if (!options.pad_level) lvl = lvl.trimEnd()

  const head_bw = head.replace('$level', lvl)

  for (const [name, writer] of writers.entries()) {
    const options = writer.options
    if (options?.minLevel > level) {
      if (options.verbose) console.log(`Writer's level is lower, discard message for ${name}`)
      continue
    }
    writer.log(level, head_bw, ...message)
  }
}

function get_string(level: Level): string {
  switch (level) {
    case Level.DEBUG:
      return 'DEBUG  '
    case Level.TRACE:
      return 'TRACE  '
    case Level.INFO:
      return 'INFO   '
    case Level.WARNING:
      return 'WARNING'
    case Level.ERROR:
      return 'ERROR  '
  }
}