import {Disposable} from '@techniker-me/tools';
import ConsoleAppender from './appenders/ConsoleAppender';
import IAppender from './appenders/IAppender';
import Threshold from './level/Threshold';
import Logger from './Logger';
import {LoggingLevelType} from './level/LoggingLevel';
import LoggingLevelMapping from './level/LoggingLevelMapping';
import TechnikerMeAppender from './appenders/TechnikerMeAppender';

type Category = string;

export default class LoggerFactory {
  private static readonly _appenders: Set<IAppender> = new Set();
  private static readonly _threshold: Threshold = new Threshold();
  private static readonly _loggers: Map<Category, Logger> = new Map();

  static {
    this.applyConsoleAppender();
    this.applyRemoteAppender();
  }

  public static getLogger(category: string): Logger {
    if (!LoggerFactory._loggers.has(category)) {
      this._loggers.set(category, new Logger(category, LoggerFactory._threshold, LoggerFactory._appenders));
    }

    return LoggerFactory._loggers.get(category) as Logger;
  }

  public static applyApppender(appender: IAppender): Disposable {
    LoggerFactory._appenders.add(appender);

    return new Disposable(() => LoggerFactory._appenders.delete(appender));
  }

  public static setLoggingLevel(loggingLevelType: LoggingLevelType): void {
    const loggingLevel = LoggingLevelMapping.convertLoggingLevelTypeToLoggingLevel(loggingLevelType);

    LoggerFactory._threshold.value = loggingLevel;
  }

  private static applyConsoleAppender(): void {
    LoggerFactory.applyApppender(new ConsoleAppender());
  }

  private static applyRemoteAppender(): void {
    LoggerFactory.applyApppender(new TechnikerMeAppender());
  }
}