import { LogLevel } from '../LogLevel';
import { LogObj } from '../LogObj';
import { ErrorCode } from '../ErrorCode';
import { LOG_SOURCE } from '../LogSource';
import { Guid } from '../../Guid';
export * from '../LogSource';

const isDev = false;
export class Logger {
  private _logSource: LOG_SOURCE;
  private _logLevel: LogLevel = LogLevel.Information;
  private static timerId: number = null;
  public static tabId: string = Guid.Default;
  private static loopBuffer: LogObj[] = [];
  private static traceBuffer: LogObj[] = [];
  private static debugBuffer: LogObj[] = [];
  private static informationBuffer: LogObj[] = [];
  private static warningBuffer: LogObj[] = [];
  private static errorBuffer: LogObj[] = [];
  private static criticalBuffer: LogObj[] = [];
  private _isDev = false;
  private ApiServiceUrl: string = null;

  constructor(logSource: LOG_SOURCE = LOG_SOURCE.Other, isDev: boolean = false, apiUrl: string = null) {
    this._logSource = logSource;
    if (this._logLevel == null) {
      this._logLevel = LogLevel.Loop;
    }

    if (Logger.timerId == null) {
      Logger.timerId = window.setInterval(this.pushLogs.bind(this), 10000);
    }

    this.ApiServiceUrl = apiUrl;
    this.syncLogLevel();
    this._isDev = isDev;
  }

  get apiUrl() {
    return this.ApiServiceUrl;
  }

  set apiUrl(apiUrl: string) {
    this.ApiServiceUrl = apiUrl;
    this.syncLogLevel();
  }

  get isDev(): boolean {
    return this._isDev;
  }

  set isDev(isDev: boolean) {
    this._isDev = isDev;
  }

  get logLevel(): LogLevel {
    return this._logLevel;
  }

  set logLevel(logLevel: LogLevel) {
    this._logLevel = logLevel;
  }

  get logSource() {
    return this._logSource;
  }

  set logSource(logSourceIn: LOG_SOURCE) {
    this._logSource = logSourceIn;
  }

  private printConsoleLog(logObj: LogObj): void {
    if (this.isDev) {
      console.log(JSON.stringify(logObj, null, '\t'));
    }
  }

  private generateLogObj(logLevel: LogLevel, errorCode: ErrorCode, message: string, localTime: Date = new Date()): LogObj {
    return new LogObj(errorCode, message, logLevel, this.logLevel, Logger.tabId, Logger.tabId, localTime);
  }

  private logMessage(methodLogLevel: LogLevel, message: string, errorCode: ErrorCode, localTime: Date): void {
    const logObj: LogObj = this.generateLogObj(methodLogLevel, errorCode, message, localTime);

    if (this.logLevel <= methodLogLevel) {
      if (isDev) {
        this.printConsoleLog(logObj);
      } else {
        Logger.getLogBufferReference(methodLogLevel).push(logObj);
      }
    }
  }

  logLoop(message: string, errorCode: ErrorCode = ErrorCode.Other, localTime: Date = new Date()): void {
    this.logMessage(LogLevel.Loop, message, errorCode, localTime);
  }

  logTrace(message: string, errorCode: ErrorCode = ErrorCode.Other, localTime: Date = new Date()): void {
    this.logMessage(LogLevel.Trace, message, errorCode, localTime);
  }

  logDebug(message: string, errorCode: ErrorCode = ErrorCode.Other, localTime: Date = new Date()): void {
    this.logMessage(LogLevel.Debug, message, errorCode, localTime);
  }

  logInformation(message: string, errorCode: ErrorCode = ErrorCode.Other, localTime: Date = new Date()): void {
    this.logMessage(LogLevel.Information, message, errorCode, localTime);
  }

  logWarning(message: string, errorCode: ErrorCode = ErrorCode.Other, localTime: Date = new Date()): void {
    this.logMessage(LogLevel.Warning, message, errorCode, localTime);
  }

  logError(message: string, errorCode: ErrorCode = ErrorCode.Other, localTime: Date = new Date()): void {
    this.logMessage(LogLevel.Error, message, errorCode, localTime);
  }

  logCriticial(message: string, errorCode: ErrorCode = ErrorCode.Other, localTime: Date = new Date()): void {
    this.logMessage(LogLevel.Critical, message, errorCode, localTime);
  }

  pushLogs(): void {
    /** **********
     * this line has been commented for mocking purpose only.
     */
    // if (!Logger.ApiServiceUrl) {
    //     return;
    // }
    Logger.loopBuffer = [];
    Logger.traceBuffer = [];
    Logger.debugBuffer = [];
    Logger.informationBuffer = [];
    Logger.warningBuffer = [];
    Logger.errorBuffer = [];
    Logger.criticalBuffer = [];
  }

  static clearTimeOutForLogger(): void {
    clearTimeout(Logger.timerId);
    Logger.timerId = null;
  }

  private static getLogBufferReference(logLevel: LogLevel): LogObj[] {
    switch (logLevel) {
      case LogLevel.Loop:
        return Logger.loopBuffer;
      case LogLevel.Trace:
        return Logger.traceBuffer;
      case LogLevel.Debug:
        return Logger.debugBuffer;
      case LogLevel.Information:
        return Logger.informationBuffer;
      case LogLevel.Warning:
        return Logger.warningBuffer;
      case LogLevel.Error:
        return Logger.errorBuffer;
      case LogLevel.Critical:
        return Logger.criticalBuffer;
      default:
        return [];
    }
  }
  //* ************************************************* */
  // below functions are part of only mock test cases///
  /// **************************************************** */

  static getBufferedLogsMock(logLevel: LogLevel): LogObj[] {
    switch (logLevel) {
      case LogLevel.Loop:
        return Logger.loopBuffer;
      case LogLevel.Trace:
        return Logger.traceBuffer;
      case LogLevel.Debug:
        return Logger.debugBuffer;
      case LogLevel.Information:
        return Logger.informationBuffer;
      case LogLevel.Warning:
        return Logger.warningBuffer;
      case LogLevel.Error:
        return Logger.errorBuffer;
      case LogLevel.Critical:
        return Logger.criticalBuffer;
      default:
        return [];
    }
  }

  syncLogLevel(): void {
    this.logLevel = LogLevel.Information;
  }
}