/* eslint-disable @typescript-eslint/no-require-imports */
import fs from 'fs';
import path from 'path';

import doctrine from 'doctrine';
import prettier from 'prettier';
import { CLIEngine, Linter } from 'eslint';
const cli = new CLIEngine({});
import insertTag from 'insert-tag';
import xmlEscape from 'xml-escape';

import {
    NAMESPACE_CONFIG,
    NAMESPACES,
    buildEslintrcMeta,
    Namespace,
    Rule,
    locale
} from '../config';

import '../site/vendor/prism';
declare const Prism: any;

class Builder {
    private namespace: Namespace = NAMESPACES[0];
    /** 插件的 meta 信息 */
    private ruleMetaMap: {
        [key: string]: {
            fixable: boolean;
            extendsBaseRule: string;
            requiresTypeChecking: boolean;
        };
    } = {};
    /** 当前 namespace 的规则列表 */
    private ruleList: Rule[] = [];
    /** 当前 namespace 的所有规则合并后的文本，包含注释 */
    private rulesContent = '';
    /** 插件初始配置的内容，如 test/react/.eslintrc.js */
    private initialEslintrcContent = '';
    /** build base 时，暂存当前 ruleConfig，供后续继承用 */
    private baseRuleConfig: {
        [key: string]: Rule;
    } = {};

    public build(namespace: Namespace) {
        this.namespace = namespace;
        this.ruleMetaMap = this.getRuleMetaMap();
        this.ruleList = this.getRuleList();
        this.rulesContent = this.getRulesContent();
        this.initialEslintrcContent = this.getInitialEslintrc();
        this.buildRulesJson();
        this.buildLocaleJson();
        this.buildEslintrc();
    }

    /** 获取插件的 meta 信息 */
    private getRuleMetaMap() {
        const { rulePrefix, pluginName } = NAMESPACE_CONFIG[this.namespace];
        const ruleEntries = pluginName
            ? Object.entries<any>(require(pluginName).rules)
            : Array.from<any>(require('eslint/lib/rules').entries());
        return ruleEntries.reduce((prev, [ruleName, ruleValue]) => {
            const fullRuleName = rulePrefix + ruleName;
            const meta = ruleValue.meta;
            prev[fullRuleName] = {
                fixable: meta.fixable === 'code',
                extendsBaseRule:
                    // 若为 string，则表示继承的规则，若为 true，则提取继承的规则的名称
                    meta.docs.extendsBaseRule === true
                        ? ruleName.replace(NAMESPACE_CONFIG[this.namespace].rulePrefix, '')
                        : meta.docs.extendsBaseRule ?? '',
                requiresTypeChecking: meta.docs.requiresTypeChecking ?? false
            };
            return prev;
        }, {});
    }

    /** 获取规则列表，根据字母排序 */
    private getRuleList() {
        const ruleList = fs
            .readdirSync(path.resolve(__dirname, '../test', this.namespace))
            .filter((ruleName) =>
                fs
                    .lstatSync(path.resolve(__dirname, '../test', this.namespace, ruleName))
                    .isDirectory()
            )
            .map((ruleName) => this.getRule(ruleName));

        return ruleList;
    }

    /** 解析单条规则为一个规则对象 */
    private getRule(ruleName: string) {
        const filePath = path.resolve(
            __dirname,
            '../test',
            this.namespace,
            ruleName,
            '.eslintrc.js'
        );
        const fileModule = require(filePath);
        const fileContent = fs.readFileSync(filePath, 'utf-8');
        const fullRuleName = NAMESPACE_CONFIG[this.namespace].rulePrefix + ruleName;
        const comments = /\/\*\*.*\*\//gms.exec(fileContent);
        const rule: Rule = {
            name: fullRuleName,
            value: fileModule.rules[fullRuleName],
            description: '',
            reason: '',
            badExample: '',
            goodExample: '',
            ...this.ruleMetaMap[fullRuleName]
        };
        if (comments !== null) {
            // 通过 doctrine 解析注释
            const commentsAST = doctrine.parse(comments[0], { unwrap: true });
            // 将注释体解析为 description
            rule.description = commentsAST.description;
            // 解析其他的注释内容，如 @reason
            rule.reason =
                commentsAST.tags.find(({ title }) => title === 'reason')?.description ?? '';
        }
        // 若没有描述，并且有继承的规则，则使用继承的规则的描述
        if (!rule.description && rule.extendsBaseRule) {
            rule.description = this.baseRuleConfig[rule.extendsBaseRule].description;
        }
        // 若没有原因，并且有继承的规则，并且本规则的配置项与继承的规则的配置项一致，则使用继承的规则的原因
        if (
            !rule.reason &&
            rule.extendsBaseRule &&
            JSON.stringify(rule.value) ===
                JSON.stringify(this.baseRuleConfig[rule.extendsBaseRule].value)
        ) {
            rule.reason = this.baseRuleConfig[rule.extendsBaseRule].reason;
        }
        const badFilePath = path.resolve(
            path.dirname(filePath),
            `bad.${NAMESPACE_CONFIG[this.namespace].exampleExtension}`
        );
        const goodFilePath = path.resolve(
            path.dirname(filePath),
            `good.${NAMESPACE_CONFIG[this.namespace].exampleExtension}`
        );

        if (fs.existsSync(badFilePath)) {
            const { results } = cli.executeOnFiles([badFilePath]);
            // 通过 Prism 和 insertMark 生成 html 格式的代码
            rule.badExample = this.insertMark(
                Prism.highlight(
                    fs.readFileSync(badFilePath, 'utf-8'),
                    Prism.languages[NAMESPACE_CONFIG[this.namespace].prismLanguage],
                    NAMESPACE_CONFIG[this.namespace].prismLanguage
                ),
                results[0].messages
            ).trim();
        }
        if (fs.existsSync(goodFilePath)) {
            rule.goodExample = Prism.highlight(
                fs.readFileSync(goodFilePath, 'utf-8'),
                Prism.languages[NAMESPACE_CONFIG[this.namespace].prismLanguage],
                NAMESPACE_CONFIG[this.namespace].prismLanguage
            ).trim();
        }
        return rule;
    }

    /** 获取插件初始配置的内容 */
    private getInitialEslintrc() {
        const initialEslintrcPath = path.resolve(
            __dirname,
            `../test/${this.namespace}/.eslintrc.js`
        );
        if (!fs.existsSync(initialEslintrcPath)) {
            return '';
        }
        return fs.readFileSync(initialEslintrcPath, 'utf-8');
    }

    /** 获取当前 namespace 的所有规则合并后的文本，包含注释 */
    private getRulesContent() {
        return this.ruleList
            .map((rule) => {
                let content = [
                    '\n/**',
                    ...rule.description.split('\n').map((line) => ` * ${line}`)
                ];
                if (rule.reason) {
                    content = [
                        ...content,
                        ...rule.reason
                            .split('\n')
                            .map((line, index) =>
                                index === 0 ? ` * @reason ${line}` : ` * ${line}`
                            )
                    ];
                }
                content.push(' */');
                // 若继承自基础规则，则需要先关闭基础规则
                const extendsBaseRule = this.ruleMetaMap[rule.name].extendsBaseRule;
                if (extendsBaseRule) {
                    content.push(`'${extendsBaseRule}': 'off',`);
                }
                content.push(`'${rule.name}': ${JSON.stringify(rule.value, null, 4)},`);
                return content.join('\n        ');
            })
            .join('');
    }

    /** 写入 config/rules/***.json */
    private buildRulesJson() {
        const ruleConfig = this.ruleList.reduce<{
            [key: string]: Rule;
        }>((prev, rule) => {
            prev[rule.name] = rule;
            return prev;
        }, {});
        /** build base 时，暂存当前 ruleConfig，供后续继承用 */
        if (this.namespace === 'base') {
            this.baseRuleConfig = ruleConfig;
        }
        this.writeWithPrettier(
            path.resolve(__dirname, `../config/rules/${this.namespace}.json`),
            JSON.stringify(ruleConfig),
            'json'
        );
    }

    /** 写入 config/locale/*.json */
    private buildLocaleJson() {
        const current: any = locale['en-US'];

        Object.values(this.ruleList).forEach((rule) => {
            if (!current[rule.description]) {
                current[rule.description] = rule.description;
            }
            if (rule.reason && !current[rule.reason]) {
                current[rule.reason] = rule.reason;
            }
        });

        this.writeWithPrettier(
            path.resolve(__dirname, '../config/locale/en-US.json'),
            JSON.stringify(current),
            'json'
        );
    }

    /** 写入各插件的 eslintrc 文件 */
    private buildEslintrc() {
        const eslintrcContent =
            buildEslintrcMeta() +
            this.initialEslintrcContent
                // 去掉 extends
                .replace(/extends:.*],/, '')
                // 将 rulesContent 写入 rules
                .replace(/(,\s*rules: {([\s\S]*?)})?\s*};/, (_match, _p1, p2) => {
                    const rules = p2 ? `${p2},${this.rulesContent}` : this.rulesContent;
                    return `,rules:{${rules}}};`;
                });

        this.writeWithPrettier(path.resolve(__dirname, `../${this.namespace}.js`), eslintrcContent);
    }

    /** 经过 Prettier 格式化后写入文件 */
    private writeWithPrettier(filePath: string, content: string, parser = 'babel') {
        fs.writeFileSync(
            filePath,
            // 使用 prettier 格式化文件内容
            prettier.format(content, {
                ...require('../.prettierrc'),
                parser
            }),
            'utf-8'
        );
    }

    /** 依据 ESLint 结果，给 badExample 添加 <mark> 标签 */
    private insertMark(badExample: string, eslintMessages: Linter.LintMessage[]) {
        let insertedBadExample = badExample;
        eslintMessages.forEach(({ ruleId, message, line, column, endLine, endColumn }) => {
            const insertLine = line - 1;
            const insertColumn = column - 1;
            const insertLineEnd = (endLine || line) - 1;
            let insertColumnEnd = (endColumn || column + 1) - 1;
            if (insertLineEnd === insertLine && insertColumnEnd === insertColumn) {
                insertColumnEnd = insertColumnEnd + 1;
            }
            insertedBadExample = insertTag(
                insertedBadExample,
                `<mark class="eslint-error" data-tip="${`${xmlEscape(
                    xmlEscape(message)
                )}<br/><span class='eslint-error-rule-id'>eslint(${ruleId})</span>`}">`,
                [insertLine, insertColumn, insertLineEnd, insertColumnEnd]
            );
        });
        return insertedBadExample;
    }
}

const builder = new Builder();
NAMESPACES.forEach((namespace) => builder.build(namespace));