const fs = require("fs");
const path = require("path");
const prettier = require("prettier");
const { exec } = require("child_process");

async function fix(path) {
    new Promise(res => {
        exec(`yarn eslint --fix ${path}`, () => {
            res();
        });
    });
}

async function handleFile(srcName) {
    const sourceCode = fs.readFileSync(srcName).toString();

    const result = /BI\.(.*?)\s\=\sBI\.inherit\(/.exec(sourceCode);
    if (!result) {
        console.log(`可能是已经es6过了 ${srcName}`);

        return;
    }
    const clzName = result[1];

    const superName = /inherit\(BI\.(.*?),/.exec(sourceCode)[1];

    // const xtype = /BI.shortcut\(\"(.*?)\"/.exec(sourceCode)[1];

    const collection = {
        "static": {},
        attr: {},
    };

    const BI = {
        inherit(_, options) {
            collection.methods = Object.keys(options)
                .filter(key => typeof options[key] === "function")
                .map(key => options[key]);
            Object.keys(options)
                .filter(key => typeof options[key] !== "function")
                .forEach(key => {
                    collection.attr[key] = options[key];
                });

            return collection.static;
        },
        shortcut(xtype) {
            collection.xtype = xtype;
        },
    };

    eval(sourceCode);

    let M = "";
    let E = "";
    let I = "";
    let A = "";

    const coreImport = {
        shortcut: true,
    };

    if (superName === "Widget") {
        coreImport.Widget = true;
    }

    Object.keys(collection.attr).forEach(key => {
        A = `${key} = ${JSON.stringify(collection.attr[key])};`;
    });

    // 静态方法
    Object.keys(collection.static).forEach(key => {
        E += `\tstatic ${key} = "${collection.static[key]}"\n`;
    });

    // 对函数进行替换
    collection.methods.forEach(el => {
        let f = `${el.toString().replace(/^function/, el.name)}\n`;

        // 换 BI.Button.superclass
        f = f.replace(`BI.${clzName}.superclass`, "super");
        // 换 super._defaultConfig
        f = f.replace(
            `super\._defaultConfig\.apply\(this\,\sarguments\)`,
            "super._defaultConfig(arguments)"
        );
        // 换 super.xxx.apply
        f = f.replace(/super\.(.*?)\.apply\(this\,\sarguments\)/, a => {
            const f = /super\.(.*?)\.apply\(this\,\sarguments\)/.exec(a);

            return `super.${f[1]}(...arguments)`;
        });

        const target = [
          "isNull",
          "toPix",
          "isKey",
          "isObject",
          "map",
          "extend",
          "isFunction",
          "isEmptyArray",
          "isArray",
          "Controller",
          clzName,
          "createWidget",
          "Events",
          "emptyFn",
          "nextTick",
          "bind",
          "i18nText",
          "isNotNull",
          "isString",
          "isNumber",
          "isEmpty",
          "isEmptyString",
          "any",
          "deepContains",
          "isNotEmptyString",
          "each",
          "contains",
          "remove",
          "createItems",
          "makeArrayByArray",
        ];

        target.forEach(t => {
            const arr = f.split(`BI.${t}`);
            // nodejs 低版本没有 replaceAll
            if (arr.length > 1) {
                if (t !== clzName) coreImport[t] = true;
                f = arr.join(t);
            }
        });

        M += `${f}\n`;
    });

    Object.keys(coreImport).forEach(el => {
        I += `${el},`;
    });

    const outputCode = `
import {${I}} from "@/core"

@shortcut()
export class ${clzName} extends ${superName} {
\tstatic xtype = "${collection.xtype}"

${A}

${E}

${M}
}
`;

    const prettierCode = prettier.format(outputCode);
    fs.writeFileSync(srcName, prettierCode);
    await fix(srcName);

    return clzName;
}

async function traverse(srcName) {
    if (srcName.indexOf("__test__") >= 0) return;

    if (srcName.endsWith(".js")) {
        return await handleFile(srcName);
    } else {
        const stat = fs.statSync(srcName);
        const flag = stat.isDirectory();
        if (flag) {
            const files = fs.readdirSync(srcName);
            // let indexContent = "";
            for (let i = 0; i < files.length; i++) {
                const file = files[i];
                await traverse(path.resolve(srcName, file));
                // const clzName = await traverse(path.resolve(srcName, file));
                // const moduleName = path.basename(srcName).replace(/.js$/, "");
                // if (clzName) {
                //     indexContent += `export { ${clzName} } from '${moduleName}'\n`;
                // }
            }
        }
    }
}

const srcName = process.argv[2];
traverse(srcName);