import mainManager from './mainManager';
import uponManager from './uponManager';
import errUtil from '../../utils/error';
import { sysLogger } from '../logger';

const core = {
  /**
   * 实例化
   */
  init() {
    return mainManager.init();
  },

  /**
   * @typedef {Object} PlatformInstance 平台实例
   * @property {Object} adapter 平台适配器，必填，主要包括 core、message、logger、network、storage等
   * @property {Object} modules 平台模块，
   * @property {boolean} disabled 是否禁用当前平台，根据环境，同步确定
   */
  /**
   * 添加平台实例，用于支持多平台打到同一个包，但仅使用一个平台，进入就确定；
   * @param {PlatformInstance} platform 要添加的平台实例
   */
  addPlatform(platform) {
    return mainManager.addPlatform(platform);
  },

  /**
   * 适配器注入
   * @param {Object} adapter 
   */
  injectAdapters(adapter) {
    return mainManager.injectAdapters(adapter);
  },

  /**
   * 注入模块，与老模块重名会覆盖
   * @param {Object} modules { [moduleName: string]: any };
   */
  injectModules(modules) {
    return mainManager.injectModules(modules);
  },

  /**
   * 获取平台自定义 common 组件
   */
  getCommon() {
    return mainManager.getCommon();
  },

  getAdapter(name) {
    return mainManager.getAdapter(name)
  },

  /**
   * API回溯查找，仅查找，可以是 function 或其他值
   * 回溯顺序：注入module -> 基础module -> 默认方法 
   * @param {string} moduleName 要调用的模块
   * @param {string} api 要调用的api
   * @param {any} defReturn 回溯失败时返回的默认值
   */
  backTrackAPI(moduleName, api, defReturn) {
    return uponManager.backTrackAPI(moduleName, api, defReturn);
  },

  /**
   * 事件注册，要记录并区分每次调用，确保触发回调一致
   * @param {string} moduleName 要调用的模块
   * @param {string} api 要调用的api
   * @param {...any} params 传参
   */
  onEvent(moduleName, api, ...params) {
    return uponManager.onEvent(moduleName, api, ...params);
  },

  /**
   * 事件注销，要记录并区分每次调用
   * @param {string} moduleName 要调用的模块
   * @param {string} api 要调用的模块
   * @param {...any} params 传参
   */
  offEvent(moduleName, api, ...params) {
    return uponManager.offEvent(moduleName, api, ...params);
  },

  /**
   * 异步事件调用，返回 Promise，不区分每次调用
   * @param {string} moduleName 要调用的模块
   * @param {string} api 要调用的模块
   * @param {...any} params 传参
   */
  callEvent(moduleName, api, ...params) {
    return uponManager.callEvent(moduleName, api, ...params);
  },

  /**
   * 同步事件调用，同步返回结果
   * @param {string} moduleName 要调用的模块
   * @param {string} api 要调用的模块
   * @param {...any} params 传参
   */
  callEventSync(moduleName, api, ...params) {
    return uponManager.callEventSync(moduleName, api, ...params);
  },
}

core.onEvent = errUtil.catchErrStack(core.onEvent, core, sysLogger)
core.offEvent = errUtil.catchErrStack(core.offEvent, core, sysLogger)
core.callEvent = errUtil.catchErrStack(core.callEvent, core, sysLogger)
core.callEventSync = errUtil.catchSyncErrStack(core.callEventSync, core, sysLogger)

export default core