const path = require('path');
const fs = require('fs');
const assert = require('assert');
const is = require('is-type-of');
const Koa = require('koa');
const koaServe = require('koa-static');
const https = require('https');
const BaseApp = require('./baseApp');
const Log = require('../log');
const CoreElectron = require('../electron');
const CoreElectronApp = require('../electron/app');
const CoreElectronWindow = require('../electron/window');
const Conf = require('../config');
const Ps = require('../ps');
const Socket = require('../socket');
const GetPort = require('../utils/get-port');
const UtilsHelper = require('../utils/helper');
const HttpClient = require('../httpclient');
const Cross = require('../cross');
const Html = require('../html');

class EeApp extends BaseApp {
  constructor(options = {}) {
    super(options);

    // 兼容旧的api
    this.electron = CoreElectron;
    this.mainWindow;
  }

  /**
   * 生成端口
   */
  async createPorts() {
    if (Ps.isFrameworkMode() && Conf.isWebProtocol(this.config.mainServer)) {
      const mainPort = await GetPort({port: parseInt(this.config.mainServer.port)});
      process.env.EE_MAIN_PORT = mainPort;
      this.config.mainServer.port = mainPort;
    }

    if (this.config.socketServer.enable) {
      const socketPort = await GetPort({port: parseInt(this.config.socketServer.port)});
      process.env.EE_SOCKET_PORT = socketPort;
      this.config.socketServer.port = socketPort;
    }
    
    if (this.config.httpServer.enable) {
      const httpPort = await GetPort({port: parseInt(this.config.httpServer.port)});
      process.env.EE_HTTP_PORT = httpPort;
      this.config.httpServer.port = httpPort;
    }
    
    // [todo] 更新db配置 (system.json 不再主进程中使用了，后续可能在子进程中使用）
    Conf.setAll(this.config);
  }

  /**
   * 启动通信模块
   */
  async startSocket() {
    Socket.startAll(this);
  }
  
  /**
   * 启动跨语言服务
   */
  async crossService() {
    Cross.create();
  }

  /**
   * 创建electron应用
   */
  async createElectronApp() {
    if (!Ps.isFrameworkMode()) return;
    const newApp = CoreElectronApp.create();
    if (!newApp) {
      return
    }

    await this.crossService();
    
    await this.electronAppReady();
  }
    
  /**
   * 创建应用主窗口
   */
  async createWindow() {

    // 初始化一个主窗口
    this.mainWindow = CoreElectronWindow.getMainWindow();

    await this.windowReady();
  
    await this._loderAddons();

    await this._loderPreload();

    this.selectAppType();
  }

  /**
   * 应用类型 （远程、html、单页应用）
   */
  async selectAppType() {
    let type = '';
    let url = '';

    // 远程模式
    const remoteConfig = this.config.remoteUrl;
    if (remoteConfig.enable == true) {
      type = 'remote_web';
      url = remoteConfig.url;
      this.loadMainUrl(type, url);
      return;
    }

    const mainServer = this.config.mainServer;

    // 开发环境
    if (Ps.isDev()) {
      let modeInfo;
      let url;
      let load = 'url';
      const configFile = './electron/config/bin.js';
      let electronCfg = {};

      const isBin = UtilsHelper.checkConfig(configFile);
      if (isBin) {
        const binConfig = UtilsHelper.loadConfig(configFile);
        modeInfo = binConfig.dev.frontend;
        electronCfg = binConfig.dev.electron;
      } else {
        // 兼容旧的 developmentMode
        const developmentModeConfig = this.config.developmentMode;
        const selectMode = developmentModeConfig.default;
        modeInfo = developmentModeConfig.mode[selectMode];
      }

      url = modeInfo.protocol + modeInfo.hostname + ':' + modeInfo.port;
      if (Conf.isFileProtocol(modeInfo)) {
        url = path.join(this.config.homeDir, modeInfo.directory, modeInfo.indexPath);
        load = 'file';
      }

      // 检查 UI serve是否启动，先加载一个boot page
      if (load == 'url') {
        // loading page
        let lp = Html.getFilepath('boot.html');
        if (electronCfg.hasOwnProperty('loadingPage') && electronCfg.loadingPage != '') {
          lp = path.join(this.config.homeDir, electronCfg.loadingPage);
        }
        this._loadingPage(lp);

        const retryTimes = modeInfo.force === true ? 3 : 60;
        let count = 0;
        let frontendReady = false;
        const hc = new HttpClient();
        while(!frontendReady && count < retryTimes){
          await UtilsHelper.sleep(1 * 1000);
          try {
            await hc.request(url, {
              method: 'GET',
              timeout: 1000,
            });
            frontendReady = true;
          } catch(err) {
            // console.log('The frontend service is starting');
          }

          count++;
        }

        if (frontendReady == false && modeInfo.force !== true) {
          const bootFailurePage = Html.getFilepath('failure.html');
          this.mainWindow.loadFile(bootFailurePage);
          Log.coreLogger.error(`[ee-core] Please check the ${url} !`);
          return;
        }
      }

      this.loadMainUrl('spa', url, load);
      return;
    }

    // 生产环境
    // cross service takeover web
    if (mainServer.hasOwnProperty('takeover')) {
      await this._crossTakeover(mainServer)
      return
    }

    // 主进程
    if (mainServer.protocol == "") {
      return
    }
    if (Conf.isFileProtocol(mainServer)) {
      url = path.join(this.config.homeDir, mainServer.indexPath);
      this.loadMainUrl('spa', url, 'file');
    } else {
      this.loadLocalWeb('spa');
    }
  }

  /**
   * cross service takeover web
   */
  async _crossTakeover(mainCfg = {}) {
    const crossConfig = this.config.cross;

    // loading page
    if (mainCfg.hasOwnProperty('loadingPage')) {
      const lp = path.join(this.config.homeDir, mainCfg.loadingPage);
      this._loadingPage(lp);
    }

    // cross service url
    const service = mainCfg.takeover;
    if (!crossConfig.hasOwnProperty(service)) {
      throw new Error(`[ee-core] Please Check the value of mainServer.takeover in the config file !`);
    }
    // check service
    if (crossConfig[service].enable != true) {
      throw new Error(`[ee-core] Please Check the value of cross.${service} enable is true !`);
    }

    const entityName = crossConfig[service].name;
    const url = Cross.getUrl(entityName);

    let count = 0;
    let serviceReady = false;
    const hc = new HttpClient();

    // 循环检查
    const times = Ps.isDev() ? 20 : 100;
    const sleeptime = Ps.isDev() ? 1000 : 100;
    while(!serviceReady && count < times){
      await UtilsHelper.sleep(sleeptime);
      try {
        await hc.request(url, {
          method: 'GET',
          timeout: 100,
        });
        serviceReady = true;
      } catch(err) {
        //console.log('The cross service is starting');
      }
      count++;
    }
    //console.log('count:', count)
    if (serviceReady == false) {
      const bootFailurePage = Html.getFilepath('cross-failure.html');
      this.mainWindow.loadFile(bootFailurePage);
      throw new Error(`[ee-core] Please check cross service [${service}] ${url} !`)
    }

    Log.coreLogger.info(`[ee-core] cross service [${service}] is started successfully`);
    this.loadMainUrl('spa', url);
  }  

  /**
   * 加载本地前端资源
   */
  loadLocalWeb(mode, staticDir) {
    if (!staticDir) {
      staticDir = path.join(this.config.homeDir, 'public', 'dist')
    }

    const koaApp = new Koa();	
    koaApp.use(koaServe(staticDir));

    const mainServer = this.config.mainServer;
    let url = mainServer.protocol + mainServer.host + ':' + mainServer.port;

    const isHttps = mainServer.protocol == 'https://' ? true : false;
    if (isHttps) {
      const keyFile = path.join(this.config.homeDir, mainServer.ssl.key);
      const certFile = path.join(this.config.homeDir, mainServer.ssl.cert);
      assert(fs.existsSync(keyFile), 'ssl key file is required');
      assert(fs.existsSync(certFile), 'ssl cert file is required');

      const sslOpt = {
        key: fs.readFileSync(keyFile),
        cert: fs.readFileSync(certFile)
      };
      https.createServer(sslOpt, koaApp.callback()).listen(mainServer.port, (err) => {
        if (err) {
          Log.coreLogger.info('[ee-core] [lib/eeApp] createServer error: ', err);
          return
        }
        this.loadMainUrl(mode, url);
      });
    } else {
      // 使用 host port 
      const koaOpt = {
        host: mainServer.open ? undefined : mainServer.host, // 根据配置是否开放0.0.0.0，默认关闭，避免绑定到0.0.0.0
        port: mainServer.port
      }
      koaApp.listen(koaOpt, () => {
        this.loadMainUrl(mode, url);
      });
    }
  }

  /**
   * 主服务
   * @params load <string> value: "url" 、 "file"
   */
  loadMainUrl(type, url, load  =  'url') {
    const mainServer = this.config.mainServer;
    Log.coreLogger.info('[ee-core] Env: %s, Type: %s', this.config.env, type);
    Log.coreLogger.info('[ee-core] App running at: %s', url);
    if (load ==  'file')  {
      this.mainWindow.loadFile(url, mainServer.options)
      .then()
      .catch((err)=>{
        Log.coreLogger.error(`[ee-core] Please check the ${url} !`);
      });
    } else {
      this.mainWindow.loadURL(url, mainServer.options)
      .then()
      .catch((err)=>{
        Log.coreLogger.error(`[ee-core] Please check the ${url} !`);
      });
    }
  }

  /**
   * loading page
   */  
  _loadingPage(name) {
    if (!UtilsHelper.fileIsExist(name)) {
      return
    }
    this.mainWindow.loadFile(name);
  }

  /**
   * electron app退出
   */  
  async appQuit() {
    await this.beforeClose();
    CoreElectronApp.quit();
  }

  /**
   * 加载插件
   */
  async _loderAddons() {
    this.loader.loadAddons();

    // 注册主窗口Contents id
    const addonsCfg = this.config.addons;
    if (addonsCfg.window.enable && Ps.isFrameworkMode()) {
      const win = this.mainWindow;
      const addonWindow = this.addon.window;
      addonWindow.registerWCid('main', win.webContents.id);
    }
  }

  /**
   * 预加载模块
   */
  async _loderPreload() {
    let filepath = this.loader.resolveModule(path.join(this.config.baseDir, 'preload', 'index'));
    if (!filepath) return; 
    const fileObj = this.loader.loadFile(filepath);
    if (is.function(fileObj) && !is.generatorFunction(fileObj) && !is.asyncFunction(fileObj)) {
      fileObj();
    } else if (is.asyncFunction(fileObj)) {
      await fileObj();
    }
  }

  /**
   * module模式初始化
   */
  async InitModuleMode() {
    if (!Ps.isModuleMode()) return;

    await this._loderAddons();

    await this._loderPreload();
  }

  /**
   * electron app已经准备好，主窗口还未创建
   */
  async electronAppReady() {
    // do some things
  }

  /**
   * 主应用窗口已经创建
   */
  async windowReady() {
    // do some things
  }

  /**
   * app关闭之前
   */  
  async beforeClose() {
    // do some things
  }  
}

module.exports = EeApp;