export function loadConfig(
    configFilePath: string,
    { configFileName, moduleResolver }: { configFileName: string; moduleResolver: TextLintModuleResolver }
) {
    // if specify Config module, use it
    if (configFilePath) {
        try {
            const modulePath = moduleResolver.resolveConfigPackageName(configFilePath);
            return {
                config: interopRequire(modulePath),
                filePath: modulePath
            };
        } catch (error) {
            // not found config module
        }
    }
    // auto or specify path to config file
    const result = rcConfigLoader(configFileName, {
        configFileName: configFilePath,
        defaultExtension: [".json", ".js", ".yml"]
    });
    if (result === undefined) {
        return {
            config: {},
            filePath: undefined
        };
    }
    return {
        config: result.config,
        filePath: result.filePath
    };
}

 /**
  * load filter rule file with `ruleName` and define rule.
  * if rule is not found, then throw ReferenceError.
  * if already rule is loaded, do not anything.
  * @param {string} ruleName
  */
 loadFilterRule(ruleName: string) {
     /*
        Task
          - check already define
          - resolve package name
          - load package
          - emit rule
     */
     // ignore already defined rule
     // ignore rules from rulePaths because avoid ReferenceError is that try to require.
     if (isFile(ruleName)) {
         const ruleCreator = interopRequire(ruleName);
         const ruleEntry = [ruleName, ruleCreator];
         this.emit(TextLintModuleLoader.Event.filterRule, ruleEntry);
         return;
     }
     const RULE_NAME_PREFIX = this.config.constructor.FILTER_RULE_NAME_PREFIX;
     const prefixMatch = new RegExp(`^${RULE_NAME_PREFIX}`);
     const definedRuleName = ruleName.replace(prefixMatch, "");
     // ignore plugin's rule
     if (isPluginRuleKey(definedRuleName)) {
         Logger.warn(`${definedRuleName} is Plugin's rule. This is unknown case, please report issue.`);
         return;
     }
     const pkgPath = this.moduleResolver.resolveFilterRulePackageName(ruleName);
     debug("Loading filter rules from %s", pkgPath);
     const ruleCreator = interopRequire(pkgPath);
     const ruleEntry = [definedRuleName, ruleCreator];
     this.emit(TextLintModuleLoader.Event.filterRule, ruleEntry);
 }

 /**
  * load filter rule file with `ruleName` and define rule.
  * if rule is not found, then throw ReferenceError.
  * if already rule is loaded, do not anything.
  * @param {string} ruleName
  */
 loadFilterRule(ruleName: string) {
     /*
        Task
          - check already define
          - resolve package name
          - load package
          - emit rule
     */
     // ignore already defined rule
     // ignore rules from rulePaths because avoid ReferenceError is that try to require.
     if (isFile(ruleName)) {
         const ruleCreator = interopRequire(ruleName);
         const ruleEntry = [ruleName, ruleCreator];
         this.emit(TextLintModuleLoader.Event.filterRule, ruleEntry);
         return;
     }
     const definedRuleName = normalizeTextlintFilterRuleKey(ruleName);
     // ignore plugin's rule
     if (isPluginRuleKey(definedRuleName)) {
         Logger.warn(`${definedRuleName} is Plugin's rule. This is unknown case, please report issue.`);
         return;
     }
     const pkgPath = this.moduleResolver.resolveFilterRulePackageName(ruleName);
     debug("Loading filter rules from %s", pkgPath);
     const ruleCreator = interopRequire(pkgPath);
     const ruleEntry = [definedRuleName, ruleCreator];
     this.emit(TextLintModuleLoader.Event.filterRule, ruleEntry);
 }

export function createFormatter(formatterConfig: FormatterConfig) {
    const formatterName = formatterConfig.formatterName;
    debug(`formatterName: ${formatterName}`);
    let formatter: (results: TextlintResult[], formatterConfig: FormatterConfig) => string;
    let formatterPath;
    if (fs.existsSync(formatterName)) {
        formatterPath = formatterName;
    } else if (fs.existsSync(path.resolve(process.cwd(), formatterName))) {
        formatterPath = path.resolve(process.cwd(), formatterName);
    } else {
        if (isFile(`${path.join(__dirname, "formatters/", formatterName)}.js`)) {
            formatterPath = `${path.join(__dirname, "formatters/", formatterName)}.js`;
        } else if (isFile(`${path.join(__dirname, "formatters/", formatterName)}.ts`)) {
            formatterPath = `${path.join(__dirname, "formatters/", formatterName)}.ts`;
        } else {
            const pkgPath = tryResolve(`textlint-formatter-${formatterName}`) || tryResolve(formatterName);
            if (pkgPath) {
                formatterPath = pkgPath;
            }
        }
    }
    try {
        formatter = interopRequire(formatterPath);
    } catch (ex) {
        throw new Error(`Could not find formatter ${formatterName}
${ex}`);
    }
    return function(results: TextlintResult[]) {
        return formatter(results, formatterConfig);
    };
}

    loadPreset(presetName: string) {
        /*
         Caution: Rules of preset are defined as following.
             {
                "rules": {
                    "preset-gizmo": {
                        "ruleA": false

                }
            }

        It mean that "ruleA" is defined as "preset-gizmo/ruleA"

         */
        const RULE_NAME_PREFIX = this.config.constructor.RULE_NAME_PREFIX;
        // Strip **rule** prefix
        // textlint-rule-preset-gizmo -> preset-gizmo
        const prefixMatch = new RegExp(`^${RULE_NAME_PREFIX}`);
        const presetRuleNameWithoutPrefix = presetName.replace(prefixMatch, "");
        // ignore plugin's rule
        if (isPluginRuleKey(presetRuleNameWithoutPrefix)) {
            Logger.warn(`${presetRuleNameWithoutPrefix} is Plugin's rule. This is unknown case, please report issue.`);
            return;
        }

        const pkgPath = this.moduleResolver.resolvePresetPackageName(presetName);
        debug("Loading rules from preset: %s", pkgPath);
        const preset = interopRequire(pkgPath);
        const entities = TextLintModuleMapper.createEntities(preset.rules, presetRuleNameWithoutPrefix);
        entities.forEach(entry => {
            this.emit(TextLintModuleLoader.Event.rule, entry);
        });
    }

    loadPreset(presetName: string) {
        /*
         Caution: Rules of preset are defined as following.
             {
                "rules": {
                    "preset-gizmo": {
                        "ruleA": false

                }
            }

        It mean that "ruleA" is defined as "preset-gizmo/ruleA"

         */
        const presetRuleNameWithoutPrefix = normalizeTextlintRulePresetKey(presetName);
        // ignore plugin's rule
        if (isPluginRuleKey(presetRuleNameWithoutPrefix)) {
            Logger.warn(`${presetRuleNameWithoutPrefix} is Plugin's rule. This is unknown case, please report issue.`);
            return;
        }

        const pkgPath = this.moduleResolver.resolvePresetPackageName(presetName);
        debug("Loading rules from preset: %s", pkgPath);
        const preset = interopRequire(pkgPath);
        const entities = TextLintModuleMapper.createEntities(preset.rules, presetRuleNameWithoutPrefix);
        entities.forEach(entry => {
            this.emit(TextLintModuleLoader.Event.rule, entry);
        });
    }

 fs.readdirSync(rulesDirAbsolutePath).forEach((file: string) => {
     if (path.extname(file) !== extname) {
         return;
     }
     const withoutExt = path.basename(file, extname);
     rules[withoutExt] = interopRequire(path.join(rulesDirAbsolutePath, file));
 });

 ruleNames.forEach(ruleName => {
     const pkgPath = moduleResolver.resolvePresetPackageName(ruleName);
     const preset = interopRequire(pkgPath);
     if (!preset.hasOwnProperty("rules")) {
         throw new Error(`${ruleName} has not rules`);
     }
     if (!preset.hasOwnProperty("rulesConfig")) {
         throw new Error(`${ruleName} has not rulesConfig`);
     }
     // set config of <rule> to "<preset>/<rule>"
     ObjectAssign(presetRulesConfig, mapRulesConfig(preset.rulesConfig, ruleName));
 });

 pluginNames.forEach(pluginName => {
     const pkgPath = moduleResolver.resolvePluginPackageName(pluginName);
     const plugin = interopRequire(pkgPath);
     if (!plugin.hasOwnProperty("Processor")) {
         return;
     }
     const Processor = plugin.Processor;
     debug(`${pluginName} has Processor`);
     assert(
         typeof Processor.availableExtensions === "function",
         "Processor.availableExtensions() should be implemented"
     );
     availableExtensions.push(...Processor.availableExtensions());
 });

    /**
     * load rule from plugin name.
     * plugin module has `rules` object and define rule with plugin prefix.
     * @param {string} pluginName
     */
    loadPlugin(pluginName: string) {
        const pkgPath = this.moduleResolver.resolvePluginPackageName(pluginName);
        debug("Loading rules from plugin: %s", pkgPath);
        const plugin = interopRequire(pkgPath);
        const pluginNameWithoutPrefix = normalizeTextlintPluginKey(pluginName);
        // Notes: plugins not support "rules" and "rulesConfig"
        // https://github.com/textlint/textlint/issues/291
        if (plugin.hasOwnProperty("rules")) {
            throw new Error(`textlint plugins not support "rules" and "rulesConfig".
But ${pluginName} has these filed.
For more details, See https://github.com/textlint/textlint/issues/291`);
        }
        // register plugin.Processor
        if (!plugin.hasOwnProperty("Processor")) {
            throw new Error(`textlint plugin should have "Processor".
For more details. See https://github.com/textlint/textlint/blob/master/docs/plugin.md`);
        }
        const pluginEntry = [pluginNameWithoutPrefix, plugin];
        this.emit(TextLintModuleLoader.Event.plugin, pluginEntry);
    }