'use strict';

const fs = require('fs');
const path = require('path');
const assert = require('assert');
const is = require('is-type-of');
const debug = require('debug')('ee-core:EeLoader');
const FileLoader = require('./file_loader');
const ContextLoader = require('./context_loader');
const Utils = require('../utils');
const Timing = require('../utils/timing');
const Ps = require('../../../ps');

const REQUIRE_COUNT = Symbol('EeLoader#requireCount');

class EeLoader {

  /**
   * @class
   * @param {Object} options - options
   * @param {String} options.baseDir - the directory of application
   * @param {EeCore} options.app - Application instance
   * @param {Logger} options.logger - logger
   * @since 1.0.0
   */
  constructor(options) {
    this.options = options;
    // assert(fs.existsSync(this.options.baseDir), `${this.options.baseDir} not exists`);
    assert(this.options.app, 'options.app is required');
    assert(this.options.logger, 'options.logger is required');

    this.app = this.options.app;
    this.timing = this.app.timing || new Timing();
    this[REQUIRE_COUNT] = 0;
    
    /**
     * @member {Object} EeLoader#pkg
     * @see {@link AppInfo#pkg}
     * @since 1.0.0
     */
    this.pkg = this.getPkg();

    /**
     * Framework directories
     *
     * @member {Array} EeLoader#EePaths
     * @see EeLoader#getEePaths
     * @since 1.0.0
     */
    this.EePaths = this.getEePaths();
    debug('Loaded EePaths %j', this.EePaths);

    /**
     * @member {String} EeLoader#serverEnv
     * @see AppInfo#env
     * @since 1.0.0
     */
    this.serverEnv = this.getServerEnv();
    debug('Loaded serverEnv %j', this.serverEnv);

    /**
     * @member {AppInfo} EeLoader#appInfo
     * @since 1.0.0
     */
    this.appInfo = this.getAppInfo();

    /**
     * @member {String} EeLoader#serverScope
     * @see AppInfo#serverScope
     */
    this.serverScope = options.serverScope !== undefined
      ? options.serverScope
      : this.getServerScope();
  }

  /**
   * Get {@link AppInfo#env}
   * @return {String} env
   * @see AppInfo#env
   * @private
   * @since 1.0.0
   */
  getServerEnv() {
    let serverEnv = this.options.env;

    if (!serverEnv) {
      throw new Error('[core] [lib] [loader] getServerEnv serverEnv can not be empty!');
    }

    return serverEnv;
  }

  /**
   * Get {@link AppInfo#scope}
   * @return {String} serverScope
   * @private
   */
  getServerScope() {
    return process.env.EE_SERVER_SCOPE || '';
  }

  /**
   * Get {@link AppInfo#name}
   * @return {String} appname
   * @private
   * @since 1.0.0
   */
  getAppname() {
    if (this.pkg.name) {
      debug('Loaded appname(%s) from package.json', this.pkg.name);
      return this.pkg.name;
    }

    throw new Error(`name is required from ${pkg}`);
  }

  /**
   * Get home directory
   * @return {String} home directory
   * @since 3.4.0
   */
  getHomedir() {
    return this.options.homeDir;
  }

  /**
   * Get app info
   * @return {AppInfo} appInfo
   * @since 1.0.0
   */
  getAppInfo() {
    const env = this.serverEnv;
    
    /**
     * Meta information of the application
     * @class AppInfo
     */
    return {
      /**
       * The name of the application, retrieve from the name property in `package.json`.
       * @member {String} AppInfo#name
       */
      name: this.getAppname(),

      /**
       * The current directory, where the application code is.
       * @member {String} AppInfo#baseDir
       */
      baseDir: this.options.baseDir,

      /**
       * The environment of the application, **it's not NODE_ENV**
       *
       * 1. from `$baseDir/config/env`
       * 2. from EE_SERVER_ENV
       * 3. from NODE_ENV
       *
       * env | description
       * ---       | ---
       * test      | system integration testing
       * prod      | production
       * local     | local on your own computer
       * unittest  | unit test
       *
       * @member {String} AppInfo#env
       * @see https://Eejs.org/zh-cn/basics/env.html
       */
      env: env,

      /**
       * @member {String} AppInfo#scope
       */
      scope: this.serverScope,

      /**
       * The use directory, same as `process.env.HOME`
       * @member {String} AppInfo#HOME
       */
      home: this.getHomedir(),

      /**
       * The directory whether is homeDir or appUserData depend on env.
       * @member {String} AppInfo#root
       */
      root: Ps.getRootDir(),

      /**
       * electron application data dir
       * @member {String} AppInfo#appUserDataDir
       */
      appUserDataDir: this.options.appUserData,

      /**
       * system user home dir 
       * @member {String} AppInfo#userHome
       */
      userHome: this.options.userHome,

      /**
       * application version
       * @member {String} AppInfo#appVersion
       */
      appVersion: this.options.appVersion,

      /**
       * application package status
       * @member {boolean} AppInfo#isPackaged
       */      
      isPackaged: this.options.isPackaged,

      /**
       * application exec file dir
       * @member {String} AppInfo#execDir
       */  
      execDir: this.options.execDir
    };
  }

  /**
   * Get {@link EeLoader#EePaths}
   * @return {Array} framework directories
   * @see {@link EeLoader#EePaths}
   * @private
   * @since 1.0.0
   */
  getEePaths() {
    // avoid require recursively
    const EePaths = [];
    EePaths.push(this.app[Symbol.for('ee#eePath')]);

    return EePaths;
  }

  // Low Level API

  /**
   * Load single file, will invoke when export is function
   *
   * @param {String} filepath - fullpath
   * @param {Array} inject - pass rest arguments into the function when invoke
   * @return {Object} exports
   * @example
   * ```js
   * app.loader.loadFile(path.join(app.options.baseDir, 'config/router.js'));
   * ```
   * @since 1.0.0
   */
  loadFile(filepath, ...inject) {
    filepath = filepath && this.resolveModule(filepath);
    if (!filepath) {
      return null;
    }

    // function(arg1, args, ...) {}
    if (inject.length === 0) inject = [ this.app ];

    let ret = this.requireFile(filepath);
    if (is.function(ret) && !is.class(ret) && !Utils.isBytecodeClass(ret)) {
      ret = ret(...inject);
    }
    return ret;
  }

  /**
   * @param {String} filepath - fullpath
   * @return {Object} exports
   * @private
   */
  requireFile(filepath) {
    const timingKey = `Require(${this[REQUIRE_COUNT]++}) ${Utils.getResolvedFilename(filepath, this.options.baseDir)}`;
    this.timing.start(timingKey);
    const ret = Utils.loadFile(filepath);
    this.timing.end(timingKey);
    return ret;
  }

  /**
   * Get all loadUnit
   *
   * loadUnit is a directory that can be loaded by EeLoader, it has the same structure.
   * loadUnit has a path and a type(app, framework, plugin).
   *
   * The order of the loadUnits:
   *
   * 1. plugin
   * 2. framework
   * 3. app
   *
   * @return {Array} loadUnits
   * @since 1.0.0
   */
  getLoadUnits() {
    if (this.dirs) {
      return this.dirs;
    }

    const dirs = this.dirs = [];

    // framework or Ee path
    for (const EePath of this.EePaths) {
      dirs.push({
        path: EePath,
        type: 'framework',
      });
    }

    // application
    dirs.push({
      path: this.options.baseDir,
      type: 'app',
    });

    debug('Loaded dirs %j', dirs);
    return dirs;
  }

  /**
   * Load files using {@link FileLoader}, inject to {@link Application}
   * @param {String|Array} directory - see {@link FileLoader}
   * @param {String} property - see {@link FileLoader}
   * @param {Object} opt - see {@link FileLoader}
   * @since 1.0.0
   */
  loadToApp(directory, property, opt) {
    const target = this.app[property] = {};
    opt = Object.assign({}, {
      directory,
      target,
      inject: this.app,
    }, opt);

    const timingKey = `Load "${String(property)}" to Application`;
    this.timing.start(timingKey);
    new FileLoader(opt).load();
    this.timing.end(timingKey);
  }

  /**
   * Load files using {@link ContextLoader}
   * @param {String|Array} directory - see {@link ContextLoader}
   * @param {String} property - see {@link ContextLoader}
   * @param {Object} opt - see {@link ContextLoader}
   * @since 1.0.0
   */
  loadToContext(directory, property, opt) {
    opt = Object.assign({}, {
      directory,
      property,
      inject: this.app,
      loader: this
    }, opt);
    const timingKey = `Load "${String(property)}" to Context`;
    this.timing.start(timingKey);
    if (['addon'].includes(property)) {
      new ContextLoader(opt).loadAddons();
    } else {
      new ContextLoader(opt).load();
    }
    
    this.timing.end(timingKey);
  }

  /**
   * @member {FileLoader} EeLoader#FileLoader
   * @since 1.0.0
   */
  get FileLoader() {
    return FileLoader;
  }

  /**
   * @member {ContextLoader} EeLoader#ContextLoader
   * @since 1.0.0
   */
  get ContextLoader() {
    return ContextLoader;
  }

  getTypeFiles(filename) {
    const files = [ `${filename}.default` ];
    files.push(`${filename}.${this.serverEnv}`);

    return files;
  }

  resolveModule(filepath) {
    let fullpath;
    try {
      fullpath = require.resolve(filepath);
    } catch (e) {

      // 特殊后缀处理
      if (filepath && (filepath.endsWith('.defalut') || filepath.endsWith('.prod'))) {
        fullpath = filepath + '.jsc';
      } else if (filepath && filepath.endsWith('.js')) {
        fullpath = filepath + 'c';
      }
      
      if (!fs.existsSync(filepath) && !fs.existsSync(fullpath)) {
        //this.options.logger.warn(`[ee-core] [core/lib/loader/ee_loader] resolveModule unknow filepath: ${filepath}`)
        return undefined;
      }
    }

    return fullpath;
  }

  getPkg() {
    const filePath = path.join(this.options.homeDir, 'package.json');
    if (!fs.existsSync(filePath)) {
      throw new Error(filePath + ' is not found');
    }
    const json = JSON.parse(fs.readFileSync(filePath));

    return json;
  }  
}

/**
 * Mixin methods to EeLoader
 * // ES6 Multiple Inheritance
 * https://medium.com/@leocavalcante/es6-multiple-inheritance-73a3c66d2b6b
 */
const loaders = [
  require('./mixin/config'),
  require('./mixin/service'),
  require('./mixin/controller'),
  require('./mixin/addon'),
];

for (const loader of loaders) {
  Object.assign(EeLoader.prototype, loader);
}

module.exports = EeLoader;