import global from '../common/global';
import system from '../common/system';
import baseUtil from '../utils/base';

// level信息
const LEVELS = {
  Debug: { type: 'debug', level: 1 },
  Info: { type: 'info', level: 2 },
  Warn: { type: 'warn', level: 3 },
  Error: { type: 'error', level: 4 },
  Disable: { type: 'dis', level: 5 },
};

// console api 映射
const CONSOLE_API_MAP = {
  'debug': 'info',
  'error': 'warn'
};

/**
 * 日志上报数据格式化
 * @param {string} tag 
 * @param {string} type 
 * @param {...any} args 
 */
const _formatLog = function (tag, type, ...args) {
  return {
    tag,
    level: type,
    msg: args,
    // category: tag, 日志瘦身
    // time: Date.now(),
  }
};

/**
 * @typedef {Object} Options
 * @property {boolse} closeReport 关闭上报，默认false
 * @property {number} level 日志上报等级，默认 1
 * @property {number} printLevel 日志打印等级，默认报错 4
 * @property {string} [tag] 日志标识
 */
/**
 * 日志管理器
 */
class LogManager {
  /**
   * @param {Options} opt 
   */
  constructor(opt) {
    this._opt = {
      tag: '', // 日志标识
      level: LEVELS.Debug.level, // 日志上报等级，默认Debug
      printLevel: LEVELS.Warn.level, // 日志打印等级，默认报错
      closeReport: false,
      ...(opt || {})
    }
  }

  async _log({ type, level }, ...args) {
    const { logger } = global.platform.adapter || {};
    const { postLog, TAG } = logger || {};
    const config = await this.getConfig();
    const tag = config.tag || TAG || 'EXT'; // 没定义

    // 日志等级判断 上报平台
    try {
      if (level >= config.level && !config.closeReport) {
        const formatData = _formatLog(tag, type, ...args);
        if (baseUtil.isFun(postLog)) {
          postLog(type, formatData);
        }
      }
    } catch (_) {
      // console.warn(_);
    }

    // 本地打印
    try {
      if (level >= config.printLevel) {
        const api = CONSOLE_API_MAP[type] || type;
        const prefix = `[${tag}][${type}]`;
        if (baseUtil.isFun(console[api])) {
          console[api](prefix, ...args);
        }
      }
    } catch (_) {
      // console.warn(_);
    }
  }

  /**
   * debug
   * @param {...any} args 
   */
  debug(...args) {
    this._log(LEVELS.Debug, ...args).catch(err => { });
  }

  /**
   * 信息日志
   * @param {...any} args 
   */
  info(...args) {
    this._log(LEVELS.Info, ...args).catch(err => { });
  }

  /**
   * 警告日志
   * @param {...any} args 
   */
  warn(...args) {
    this._log(LEVELS.Warn, ...args).catch(err => { });
  }

  /**
   * 报错日志
   * @param {...any} args 
   */
  error(...args) {
    this._log(LEVELS.Error, ...args).catch(err => { });
  }

  /**
   * 修改配置
   * @param {Options} options 
   * @returns boolean
   */
  setConfig(options) {
    if (!options) return false;
    const { level, printLevel } = options;
    if (baseUtil.isNumber(level)) {
      this._opt.level = level;
    }
    if (baseUtil.isNumber(printLevel)) {
      this._opt.printLevel = printLevel;
    }
    return true;
  }

  /**
   * 获取配置信息
   * @returns 
   */
  async getConfig() {
    if (!this._storageConfig) {
      return this._opt;
    }

    // 获取缓存的配置信息
    try {
      let sConfig = null;
      if (baseUtil.isFun(this._storageConfig)) {
        sConfig = await this._storageConfig()
      } else {
        sConfig = this._storageConfig;
      }
      if (sConfig && JSON.stringify(sConfig) !== JSON.stringify(this._opt)) {
        this.setConfig(sConfig);
      }
    } catch (err) {
      // console.warn('get logger storage fail: ', err)
    }
    return this._opt;
  }

  /**
   * 设置缓存配置信息
   * @param {*} config 
   */
  setStorageConfig(config) {
    if (config) {
      this._storageConfig = config;
    }
  }
}

LogManager.LEVELS = LEVELS;

/**
 * 日志管理器
 */
export default LogManager;
