import hilog from '@ohos.hilog';

/**
 * Log level define
 *
 * @syscap SystemCapability.HiviewDFX.HiLog
 */
enum LogLevel {
  DEBUG = 3,
  INFO = 4,
  WARN = 5,
  ERROR = 6,
  FATAL = 7
}

/**
 * Common log for all features.
 *
 * @param {string} prefix Identifies the log tag.
 */
export class Logger {
  private static domain: number = 0xFF00;
  private static prefix: string = 'RMRB';
  private static format: string = `%{public}s, %{public}s`;
  private static format_ext: string = `%{public}s`;
  /**
   * 暂时没找到限制大小相关文档，尝试4000是不行的，3500可以。可以后续优化
   */
  private static CHUNK_SIZE: number = 3500;
  static isDebug: boolean = true;
  static isCloseOptimzied: boolean = false;  // 正常用false，打开是为了暴露性能问题

  /**
   * constructor.
   *
   * @param Prefix Identifies the log tag.
   * @param domain Domain Indicates the service domain, which is a hexadecimal integer ranging from 0x0 to 0xFFFFF.
   */
  constructor(prefix: string = 'RMRB', domain: number = 0xFF00) {
    Logger.prefix = prefix;
    Logger.domain = domain;
  }

  static debug(...args: string[]) {
    if (!Logger.isDebug) {
      return
    }
    Logger.logContent(LogLevel.DEBUG, ...args)
  }

  static debugOptimize(tag: string, func: () => string) {
    if (!Logger.isDebug || Logger.isCloseOptimzied) {
      return
    }
    let param: string[] = []
    param.push(tag)
    param.push(func())
    Logger.logContent(LogLevel.DEBUG, ...param)
  }

  static info(...args: string[]) {
    if (!Logger.isDebug) {
      return
    }
    Logger.logContent(LogLevel.INFO, ...args)
  }

  static infoOptimize(tag: string, func: () => string) {
    if (!Logger.isDebug || Logger.isCloseOptimzied) {
      return
    }
    let param: string[] = []
    param.push(tag)
    param.push(func())
    Logger.logContent(LogLevel.INFO, ...param)
  }

  static warn(...args: string[]) {
    if (!Logger.isDebug) {
      return
    }
    Logger.logContent(LogLevel.WARN, ...args)
  }

  static warnOptimize(tag: string, func: () => string) {
    if (!Logger.isDebug || Logger.isCloseOptimzied) {
      return
    }
    let param: string[] = []
    param.push(tag)
    param.push(func())
    Logger.logContent(LogLevel.WARN, ...param)
  }

  static error(...args: string[]) {
    if (!Logger.isDebug || Logger.isCloseOptimzied) {
      return
    }
    Logger.logContent(LogLevel.ERROR, ...args)
  }

  static errorOptimize(tag: string, func: () => string) {
    if (!Logger.isDebug || Logger.isCloseOptimzied) {
      return
    }
    let param: string[] = []
    param.push(tag)
    param.push(func())
    Logger.logContent(LogLevel.ERROR, ...param)
  }

  static fatal(...args: string[]) {
    if (!Logger.isDebug) {
      return
    }
    Logger.logContent(LogLevel.FATAL, ...args)
  }

  static fatalOptimize(tag: string, func: () => string) {
    if (!Logger.isDebug || Logger.isCloseOptimzied) {
      return
    }
    let param: string[] = []
    param.push(tag)
    param.push(func())
    Logger.logContent(LogLevel.FATAL, ...param)
  }

  static isLoggable(level: LogLevel) {
    if (!Logger.isDebug) {
      return
    }
    // 判断是否打印 TODO
    hilog.isLoggable(Logger.domain, Logger.prefix, level);
  }

  static logContent(level: LogLevel, ...args: string[]) {
    let msg = Logger.getMsg(...args)
    let tag = Logger.getTag(...args)
    let length = msg.length
    if (length < Logger.CHUNK_SIZE) {
      // 不超限，保持原来的打印
      Logger.print(tag, level, ...args)
    } else {
      // 超限，分段打印
      for (let i = 0; i < length; i += Logger.CHUNK_SIZE) {
        let count = Math.min(length - i, Logger.CHUNK_SIZE);
        Logger.printExt(tag, level, msg.substring(i, i + count));
      }
    }
  }

  static print(tag: string, level: LogLevel, ...msg: string[]) {

    let prefix = Logger.prefix
    if (tag) {
      prefix += "-" + tag
    }

    switch (level) {
      case LogLevel.DEBUG:
        hilog.debug(Logger.domain, prefix, Logger.format, msg);
        break
      case LogLevel.INFO:
        hilog.info(Logger.domain, prefix, Logger.format, msg);
        break
      case LogLevel.WARN:
        hilog.warn(Logger.domain, prefix, Logger.format, msg);
        break
      case LogLevel.ERROR:
        hilog.error(Logger.domain, prefix, Logger.format, msg);
        break
      case LogLevel.FATAL:
        hilog.fatal(Logger.domain, prefix, Logger.format, msg);
        break
    }
  }

  static printExt(tag: string, level: LogLevel, msg: string) {

    let prefix = Logger.prefix
    if (tag) {
      prefix += "-" + tag
    }

    switch (level) {
      case LogLevel.DEBUG:
        hilog.debug(Logger.domain, prefix, Logger.format_ext, msg);
        break
      case LogLevel.INFO:
        hilog.info(Logger.domain, prefix, Logger.format_ext, msg);
        break
      case LogLevel.WARN:
        hilog.warn(Logger.domain, prefix, Logger.format_ext, msg);
        break
      case LogLevel.ERROR:
        hilog.error(Logger.domain, prefix, Logger.format_ext, msg);
        break
      case LogLevel.FATAL:
        hilog.fatal(Logger.domain, prefix, Logger.format_ext, msg);
        break
    }
  }

  static getMsg(...args: string[]): string {
    if (args == null || args.length <= 0) {
      return '';
    }
    let msg = ''
    args.forEach((v) => {
      msg = msg.concat(', ').concat(v)
    })
    return msg.substring(2, msg.length);
  }

  static getTag(...args: string[]): string {
    if (args == null || args.length <= 0) {
      return '';
    }

    if (args.length > 1) {

      return args[0]
    } else {
      return ''
    }

  }
}

// export default new Logger('SightApp', 0xFF00)