/**
 * 获取自定义配置
 */
function getCustomConfig (cwd: string = systemConfig.cwd): { [key: string]: CustomConfig } {
  const pkgPath = getProjectPackagePath(cwd)
  const filePath = getCustomConfigFilePath(cwd)

  let customConfigFromPkg: CustomConfig = {} // for package.json
  let customConfigFromFile: CustomConfig = {} // for min.config.json

  // in package.json
  if (fs.existsSync(pkgPath)) {
    customConfigFromPkg = _.pick(fs.readJsonSync(pkgPath)['minConfig'] || {}, CUSTOM_CONFIG_MEMBER) as CustomConfig
  }

  // in min.config.json
  if (fs.existsSync(filePath)) {
    customConfigFromFile = _.pick(fs.readJsonSync(filePath), CUSTOM_CONFIG_MEMBER) as CustomConfig
  }

  // merge customConfigFromPkg and customConfigFromFile
  let customConfig = _.merge({}, customConfigFromPkg, customConfigFromFile)

  return {
    customConfig,
    customConfigFromPkg,
    customConfigFromFile
  }
}

    /**
     * uninstall the module package
     * @param module_name
     * @param callback
     */
    uninstall(module_name: string, callback: Function) {
        var modules_file = fs.readJsonSync(modules_configuration_path);
        if (modules_file[module_name] !== undefined) {

            for (var i = 0; i < modules_file[module_name].routes.length; i++) {
                try {
                    fs.unlinkSync(serverRoot + "\\routes\\" + modules_file[module_name].routes[i].path);
                } catch (e) { }
            }

            deleteFolderRecursive(global.clientAppRoot + "\\modules\\" + module_name);

            delete modules_file[module_name];
        }







        fs.writeFileSync(modules_configuration_path, JSON.stringify(modules_file));


        try {
            var manifest_file = fs.readJsonSync(global.clientAppRoot + "\\modules\\" + module_name + "\\" + consts.MANIFEST_NAME, { throws: false });
            //merge the manifest into the modules.json file
            if (manifest_file === null)
                callback("invalid json, try using ascii file");




            dal.connect(function (err: any, db: any) {
                if (manifest_file.navigation) {
                    for (var i = 0; i < manifest_file.navigation.length; i++) {
                        db.collection("Navigation").remove({ "_id": manifest_file.navigation[i]._id }, function (err: any, data: any) {


                        });
                    }
                }

            })
        
        
            //delete module folder
            this.deleteFolderRecursive(global.clientAppRoot+ "\\modules\\" + module_name + "\\");




            callback("ok");
        }
        catch (e) {
            callback("ok");
        }
    }

    export function commit(message: string, options: any) {
        if (!!options.quiet) log.silence();
        let repo = cwdRepo();

        let allowEmpty = !!options.allowEmpty;
        if (repo.staged.length < 1 && !allowEmpty) {
            log.info('no changes to commit');
            return;
        }

        let authorName: string = conf.get('authorName');
        let authorEMail: string = conf.get('authorEMail');
        var noAuthor = !authorName || !authorEMail;
        if (noAuthor) {
            log.error('either author name or email is not specified!');
            return;
        }

        if (!repo.currentBranchName) {
            log.error('you can not commit in detached HEAD state. Create new branch.');
            return;
        }

        let optionConfig: string = options.reeditMessage || options.reuseMessage;
        let amend = !!options.amend;
        var oldCommitData: string[] = null;
        var basedOnSomeCommit = false;

        if (!!optionConfig) {
            let lcOption = optionConfig.toLowerCase();
            if (lcOption === "orig_head") {
                oldCommitData = fse.readJsonSync(path.join(repo.root, '.jerk', 'ORIG_HEAD'));
                basedOnSomeCommit = true;
            } else if (lcOption === "head") {
                oldCommitData = fse.readJsonSync(path.join(repo.root, '.jerk', 'HEAD'));
                basedOnSomeCommit = true;
            } else {
                let branch = repo.ref<Common.Ref>(optionConfig);
                if (!!branch) {
                    let cm = repo.commit(branch.head);
                    if (!!cm) {
                        oldCommitData = cm.data();
                        basedOnSomeCommit = true;
                    }
                } else {
                    let cm = repo.commit(optionConfig);
                    if (!!cm) {
                        oldCommitData = cm.data();
                        basedOnSomeCommit = true;
                    }
                }
            }
        }

        var commit = repo.head.commit;
        var newCommit = repo.createCommit(commit, message, authorName, authorEMail, amend, oldCommitData);
        log.success(Format.formatCommitMessage(newCommit, '%Cyellow%h%Creset: %s'));
    }

forEach(tasks.getTasks(), (task) => {
    const targetNodeCommonDir = path.join(task.directory, "common");
    const taskNodeModules = path.join(task.directory, "node_modules");
    const targetPowershellCommonDir = path.join(task.directory, "ps_modules");

    const taskFilePath = path.join(task.directory, "task.json");
    const taskFile = fs.existsSync(taskFilePath) ? fs.readJsonSync(taskFilePath) : {};

    if (taskFile.execution.Node) {
        fs.ensureDirSync(targetNodeCommonDir);
        fs.ensureDirSync(taskNodeModules);
        forEach(nodeFiles, (commonFile) => {
            const targetFile = path.join(targetNodeCommonDir, commonFile);
            console.log(targetFile);
            fs.copySync(path.join(nodeCommonFilesRoot, commonFile), targetFile, { overwrite: true });
        });
    }

    if (taskFile.execution.PowerShell3) {
        fs.ensureDirSync(targetPowershellCommonDir);
        forEach(powershellFiles, (commonFile) => {
            const targetFile = path.join(targetPowershellCommonDir, commonFile);
            console.log(targetFile);
            fs.copySync(path.join(powershellCommonFilesRoot, commonFile), targetFile, { overwrite: true });
        });
    }
});

 /**
  * Processes all the mocks that are present in the given directory.
  * @param {string} directory The directory containing the mocks.
  * @returns {Mock[]} mocks The mocks.
  */
 function _processMock(file: string): void {
     try {
         const mock: Mock = fs.readJsonSync(file);
         utils.updateMock(mock);
     } catch (ex) {
         console.info(file, 'contains invalid json');
     }
 }

 .reduce( (versionCache, dirName) => {
   const version = fs.readJsonSync(getPackageRoot(dirName, 'package.json')).version;
   versionCache[dirName] = {
     commit: getLastCommit(dirName),
     version
   };
   return versionCache;
 }, {});

export function getAppScriptsPackageJson() {
  if (!cachedAppScriptsPackageJson) {
    try {
      cachedAppScriptsPackageJson = readJsonSync(join(__dirname, '..', '..', 'package.json'));
    } catch (e) {}
  }
  return cachedAppScriptsPackageJson;
}

 getJSON(): any {
   const configPath = path.resolve(process.env.PWD, 'ng2-cli.json');
   if (helper.existsSync(configPath)) {
     return fse.readJsonSync(configPath);
   } else {
     throw new Error('Config file not found.');
   }
 }

 files.forEach(file => {
   const def = fs.readJsonSync(file);
   def.file = file;
   const title = getTitle(def);
   if (defs[title]) {
     throw new Error('Duplicate entry ' + title);
   }
   defs[title] = def;
 });

async function processFile ({ filePath, tempPath, entryBaseName }) {
  const indexJsStr = `
  import {AppRegistry} from 'react-native';
  import App from '../${entryBaseName}';
  // import {name as appName} from '../app.json';

  AppRegistry.registerComponent('${moduleName}', () => App);`

  if (!fs.existsSync(filePath)) {
    return
  }
  const dirname = path.dirname(filePath)
  const destDirname = dirname.replace(tempPath, jdreactPath)
  const destFilePath = path.format({dir: destDirname, base: path.basename(filePath)})
  const indexFilePath = path.join(tempPath, 'index.js')
  const tempPkgPath = path.join(tempPath, 'package.json')

  // generate jsbundles/moduleName.js
  if (filePath === indexFilePath) {
    const indexDistDirPath = path.join(jdreactPath, 'jsbundles')
    const indexDistFilePath = path.join(indexDistDirPath, `${moduleName}.js`)
    fs.ensureDirSync(indexDistDirPath)
    fs.writeFileSync(indexDistFilePath, indexJsStr)
    Util.printLog(processTypeEnum.GENERATE, `${moduleName}.js`, indexDistFilePath)
    return
  }

  // genetate package.json
  if (filePath === tempPkgPath) {
    const destPkgPath = path.join(jdreactPath, 'package.json')
    const templatePkgPath = path.join(jdreactTmpDirname, 'pkg')
    const tempPkgObject = fs.readJsonSync(tempPkgPath)
    const templatePkgObject = fs.readJsonSync(templatePkgPath)
    templatePkgObject.name = `jdreact-jsbundle-${moduleName}`
    templatePkgObject.dependencies = Object.assign({}, tempPkgObject.dependencies, templatePkgObject.dependencies)
    fs.writeJsonSync(destPkgPath, templatePkgObject, {spaces: 2})
    Util.printLog(processTypeEnum.GENERATE, 'package.json', destPkgPath)
    return
  }

  fs.ensureDirSync(destDirname)
  fs.copySync(filePath, destFilePath)
  Util.printLog(processTypeEnum.COPY, _.camelCase(path.extname(filePath)).toUpperCase(), filePath)
}