import * as ps from 'path';
import * as fs from 'fs-extra';
import { cchelper, Paths } from "../utils";
import { CocosProjectTasks } from './cocosProjectTypes';
import { gzipSync } from 'zlib';
const globby = require('globby');
const xxtea = require('xxtea-node');

const PackageNewConfig = 'cocos-project-template.json';

export interface ICMakeConfig {
    // 引擎模块
    USE_AUDIO?: boolean;
    USE_VIDEO?: boolean;
    USE_WEBVIEW?: boolean;
    // 任务调度系统配置，配置为布尔值的属性，会在生成时修改为 set(XXX ON) 的形式
    USE_JOB_SYSTEM_TBB?: boolean;
    USE_JOB_SYSTEM_TASKFLOW?: boolean;
    // 是否勾选竖屏
    USE_PORTRAIT?: boolean;

    // 渲染后端
    CC_USE_METAL?: boolean;
    CC_USE_VUKAN?: boolean;
    CC_USE_GLES3: boolean;
    CC_USE_GLES2: boolean;

    // 引擎路径
    COCOS_X_PATH?: string;

    // app名称
    APP_NAME?: string;

    // xxteakey
    XXTEAKEY: string;

    // // ios 和 mac 的bundle id设置
    // MACOSX_BUNDLE_GUI_IDENTIFIER?: string;

    // // ios 开发者
    // DEVELOPMENT_TEAM?: string;
    // TARGET_IOS_VERSION?: string;

    // // mac
    // TARGET_OSX_VERSION ?: string;

    // // android
    // CC_ENABLE_SWAPPY?: boolean;

    // 其他属性
    [propName: string]: any;

    // 以服务器端模式运行
    USE_SERVER_MODE: string;
}

export type InternaleNativePlatform = 'mac' | 'android' | 'windows' | 'ios' | 'ohos';

const ErrorCodeIncompatible = 15004;

export interface INativePlatformOptions {
    extends?: InternaleNativePlatform, //传入继承的平台，将会继承已有平台注册的一些代码
    overwrite?: InternaleNativePlatform, //传入继承但如果有同名的方法等会复写平台，将会继承已有平台注册的一些代码
    create: () => Promise<boolean>;
    genrate: () => Promise<boolean>;
    make?: () => Promise<boolean>;
    run?: () => Promise<boolean>;
    init: (params: CocosParams<Object>) => void;
}

export abstract class NativePackTool {
    // 传入的打包参数
    params!: CocosParams<Object>;
    // 收集初始化的一些路径信息
    paths!: Paths;
    // 存储调用 cmake 的命令行参数
    cmakeArgs: string[] = [];

    // 设置命令行调用时的环境参数
    setEnv(key: string, value: any) {
        process.env[key] = value;
    }

    init(params: CocosParams<Object>) {
        this.params = new CocosParams(params);
        this.paths = new Paths(params);

        this.setEnv('NATIVE_DIR', this.paths.platformTemplateDirInPrj);
        this.setEnv('COMMON_DIR', this.paths.commonDirInPrj);
        this.setEnv('PROJECT_NAME', this.params.projectName);
    }

    protected parseVersion(content: string, key: string, def: number): number {
        const regexp = new RegExp(`${key}=(.*)`);
        const r = content.match(regexp);
        if (!r) { return def; }
        const v = Number.parseInt(r[1], 10);
        return Number.isNaN(v) ? def : v;
    }

    protected async copyCommonTemplate() {
        if (!fs.existsSync(ps.join(this.paths.commonDirInPrj, 'CMakeLists.txt'))) {
            await fs.copy(this.paths.commonDirInCocos, this.paths.commonDirInPrj, { overwrite: false });
        }
    }

    private get projEngineVersionPath() {
        return ps.join(this.paths.commonDirInPrj, 'cocos-version.json');
    }

    private _debugInfo: any = null;
    private get DebugInfos(): { [key: number]: string } {
        if (!this._debugInfo) {
            this._debugInfo = require(ps.join(Paths.enginePath, 'DebugInfos.json'));
            if (!this._debugInfo) {
                console.error(`Failed to load DebugInfos.json`);
            }
        }
        return this._debugInfo;
    }

    private _versionParser: any = null;
    private get versionParser() {
        if (!this._versionParser) {
            const scriptPath = ps.join(Paths.enginePath, 'native/cmake/scripts/plugin_support/plugin_cfg.js');
            this._versionParser = require(scriptPath);
        }
        return this._versionParser;
    }

    /**
     * Debug / Release
     */
    protected get buildType(): string {
        return this.params.debug ? "Debug" : "Release";
    }

    /**
     * Read version number from cocos-version.json
     */
    protected tryReadProjectTemplateVersion(): { version: string, skipCheck: boolean | undefined } | null {
        const versionJsonPath = this.projEngineVersionPath;
        if (!fs.existsSync(versionJsonPath)) {
            console.log(`warning: ${versionJsonPath} not exists`);
            return null;
        }
        try {
            const content = fs.readJsonSync(versionJsonPath);
            if (content.version === undefined) {
                console.error(`Field 'version' missing in ${versionJsonPath}`);
                return null;
            }
            return content;
        } catch (e) {
            console.error(`Failed to read json file ${versionJsonPath}`);
            console.error(e);
        }
        return null;
    }

    /**
     * Read package.json file in the root folder and return the version field. 
     */
    protected tryGetEngineVersion(): string | null {
        const pkgJSON = ps.join(Paths.enginePath, 'package.json');
        if (!fs.existsSync(pkgJSON)) {
            console.error(`Failed to read file ${pkgJSON}`);
            return null;
        }
        return fs.readJsonSync(pkgJSON).version || "3.6.0";
    }

    /**
     * Version condition from compatibility-info.json for current platform.
     */
    protected tryGetCompatibilityInfo(): string | null {
        const compInfo = ps.join(Paths.enginePath, 'templates/compatibility-info.json');
        if (!fs.existsSync(compInfo)) {
            console.error(`${compInfo} does not exist`);
            return null;
        }
        const json = fs.readJsonSync(compInfo);
        if (!json.native) {
            console.error(`${compInfo} does not contain "native" field`);
            return null;
        }
        const native = json.native;
        const defaultCfg = native.default;
        if (!defaultCfg) {
            console.error(`${compInfo} does not contain "native.default" field`);
            return null;
        }
        const plt = this.params.platform;
        if (!native[plt]) {
            return defaultCfg;
        }
        return native[plt];
    }

    private commonDirAreIdentical(): boolean {
        let commonSrc = this.paths.commonDirInCocos;
        let commonDst = this.paths.commonDirInPrj;
        const compFile = (src: string, dst: string): boolean => {
            const linesSrc: string[] = fs.readFileSync(src).toString("utf8").split("\n").map((line) => line.trim());
            const linesDst: string[] = fs.readFileSync(dst).toString("utf8").split("\n").map((line) => line.trim());
            return linesSrc.length === linesDst.length && linesSrc.every((line, index) => line === linesDst[index]);
        };
        let compFiles = ["Classes/Game.h", "Classes/Game.cpp"];
        for (let f of compFiles) {
            const srcFile = ps.join(commonSrc, f);
            const dstFile = ps.join(commonDst, f);
            if (!fs.existsSync(dstFile)) {
                return false;
            }

            if (!fs.existsSync(srcFile)) {
                console.warn(`${f} not exists in ${commonSrc}`);
                return false;
            }

            if (!compFile(srcFile, dstFile)) {
                console.log(`File ${dstFile} differs from ${srcFile}`);
                return false;
            }
        }
        return true;
    }

    private skipVersionCheck = false;
    /**
     * The engine version used to generate the 'native/' folder should match the 
     * condition written in the 'compatibility-info.json' file.
     */
    private validateTemplateVersion(): boolean {
        console.log(`Checking template version...`);
        const engineVersion = this.tryGetEngineVersion();
        const projEngineVersionObj = this.tryReadProjectTemplateVersion();
        if (projEngineVersionObj === null) {
            if (this.commonDirAreIdentical()) {
                console.log(`The files under common/Classes directory are identical with the ones in the template. Append version file to the project.`);
                this.writeEngineVersion();
                return true;
            }
            console.error(`Error code ${ErrorCodeIncompatible}, ${this.DebugInfos[ErrorCodeIncompatible]}`)
            return false;
        }
        let versionRange = this.tryGetCompatibilityInfo();
        const projEngineVersion = projEngineVersionObj?.version;
        if (!versionRange) {
            console.warn(`Ignore version range check`);
            return true;
        }
        if (projEngineVersionObj.skipCheck === true) {
            console.log(`Skip version range check by project`);
            this.skipVersionCheck = true;
            return true;
        }
        let cond = this.versionParser.parse(versionRange);
        if (!cond) {
            return true;
        }
        if (cond.match(projEngineVersion)) {

            const newerThanEngineVersion = this.versionParser.parse(`>${engineVersion}`);
            if (newerThanEngineVersion.match(projEngineVersion)) {
                console.log(`warning: ${projEngineVersion} is newer than engine version ${engineVersion}`);
            }
            return true;
        }
        console.error(`'native/' folder was generated by ${projEngineVersion} which is incompatible with ${engineVersion}, condition: '${versionRange}'`);
        console.error(`${this.DebugInfos[ErrorCodeIncompatible]}`)
        return false;
    }

    /**
     * Utility function to check if a file exists dst as in src.
     */
    protected validateDirectory(src: string, dst: string, missingDirs: string[]) {
        if (!fs.existsSync(dst)) {
            missingDirs.push(dst);
            return;
        }
        const st = fs.statSync(src);
        if (!st.isDirectory()) {
            return;
        }
        let list = fs.readdirSync(src);
        for (let f of list) {
            if (f.startsWith('.')) continue;
            this.validateDirectory(ps.join(src, f), ps.join(dst, f), missingDirs);
        }
    }

    /**
     *  Check files under `native/engine/platform` folder
     */
    protected validatePlatformDirectory(missing: string[]): void {
        console.log(`Validating platform source code directories...`);
        const srcDir = ps.join(this.paths.nativeTemplateDirInCocos, this.params.platform);
        const dstDir = this.paths.platformTemplateDirInPrj;
        this.validateDirectory(srcDir, dstDir, missing)
    }

    /**
     * Check if any file removed from the 'native/' folder
     */
    private validateTemplateConsistency() {
        console.log(`Validating template consistency...`);
        let commonSrc = this.paths.commonDirInCocos;
        let commonDst = this.paths.commonDirInPrj;
        let missingDirs: string[] = [];
        // validate common directory
        this.validateDirectory(commonSrc, commonDst, missingDirs);
        this.validatePlatformDirectory(missingDirs);
        if (missingDirs.length > 0) {
            console.log(`Following files are missing`);
            for (let f of missingDirs) {
                console.log(`  ${f}`);
            }
            console.log(`Consider fix the problem or remove the directory`);
            console.log(`To avoid this warning, set field \'skipCheck\' in cocos-version.json to true.`);
            return false;
        }
        return true;
    }

    /**
     * - Ensure the engine version used to generete 'native/' folder is compatible
     *   with the current engine version.
     * - Check if any file under the 'native/' folder is removed.
     */
    protected validateNativeDir() {
        try {
            if (this.validateTemplateVersion()) {
                if (!this.skipVersionCheck && !this.validateTemplateConsistency()) {
                    console.log(`Failed to validate "native" directory`);
                }
            }
        } catch (e) {
            console.warn(`Failed to validate native directory`);
            console.warn(e);
        }
    }

    /**
     * Write cocos-version.json into native/common/cocos-version.json
     */
    protected writeEngineVersion() {
        if (!fs.existsSync(this.projEngineVersionPath)) {
            fs.writeJSON(this.projEngineVersionPath, {
                version: this.tryGetEngineVersion(),
                skipCheck: false,
            });
        }
    }

    protected async copyPlatformTemplate() {
        if (!fs.existsSync(this.paths.platformTemplateDirInPrj)) {
            // 拷贝 templates/平台/ 文件到 "native" 目录
            await fs.copy(ps.join(this.paths.nativeTemplateDirInCocos, this.params.platform), this.paths.platformTemplateDirInPrj, { overwrite: false });
            this.writeEngineVersion();
        } else {
            this.validateNativeDir();
        }
    }

    protected async excuteTemplateTask(tasks: CocosProjectTasks) {
        if (tasks.appendFile) {
            await Promise.all(tasks.appendFile.map((task) => {
                const dest = cchelper.replaceEnvVariables(task.to);
                fs.ensureDirSync(ps.dirname(dest));
                return fs.copy(ps.join(Paths.nativeRoot, task.from), dest);
            }))
            delete tasks.appendFile;
        }

        const replaceFilesDelay: { [key: string]: { reg: string, content: string }[] } = {};

        if (tasks.projectReplaceProjectName) {
            const cmd = tasks.projectReplaceProjectName;

            cmd.files.forEach((file) => {
                const fp = cchelper.join(this.paths.buildDir, file);
                replaceFilesDelay[fp] = replaceFilesDelay[fp] || [];
                replaceFilesDelay[fp].push({
                    reg: cmd.srcProjectName,
                    content: this.params.projectName,
                });
            });
            delete tasks.projectReplaceProjectName;
        }

        if (tasks.projectReplacePackageName) {
            const cmd = tasks.projectReplacePackageName;
            const name = cmd.srcPackageName.replace(/\./g, '\\.');
            cmd.files.forEach((file) => {
                const fp = cchelper.join(this.paths.buildDir, file);
                replaceFilesDelay[fp] = replaceFilesDelay[fp] || [];
                replaceFilesDelay[fp].push({
                    reg: name,
                    content: this.params.platformParams.packageName!,
                });
            });
            delete tasks.projectReplacePackageName;
        }

        for (const fullpath in replaceFilesDelay) {
            const cfg = replaceFilesDelay[fullpath];
            await cchelper.replaceInFile(cfg.map((x) => {
                return { reg: x.reg, text: x.content };
            }), fullpath);
        }

        if (Object.keys(tasks).length > 0) {
            for (const f in tasks) {
                console.error(`command "${f}" is not parsed in ${PackageNewConfig}`);
            }
        }
    }

    protected async generateCMakeConfig() {
        // 添加一些 cmake 配置到 cfg.cmake
        const file = ps.join(this.paths.nativePrjDir, 'cfg.cmake');
        let content = '';
        const config = this.params.cMakeConfig;
        Object.keys(config).forEach((key: string) => {
            // convert boolean to CMake option.
            if (typeof config[key] === 'boolean') {
                config[key] = `set(${key} ${config[key] ? 'ON' : 'OFF'})`;
            }
        });
        Object.keys(config).forEach((key: string) => {
            content += config[key] + '\n';
        });
        console.debug(`generateCMakeConfig, ${JSON.stringify(config)}`);
        await fs.outputFile(file, content);
    }

    protected appendCmakeCommonArgs(args: string[]) {
        args.push(`-DRES_DIR="${cchelper.fixPath(this.paths.buildDir)}"`);
        args.push(`-DAPP_NAME="${this.params.projectName}"`);
        args.push(`-DLAUNCH_TYPE="${this.buildType}"`);
        if (this.params.platformParams?.skipUpdateXcodeProject) {
            args.push(`-DCMAKE_SUPPRESS_REGENERATION=ON`);
        }
    }


    /**
     * 加密脚本，加密后，会修改 cmake 参数，因而需要再次执行 cmake 配置文件的生成
     * @returns 
     */
    protected async encrypteScripts() {
        if (!this.params.encrypted) {
            return;
        }

        if (!this.params.xxteaKey) {
            throw new Error('Encryption Key can not be empty');
        }
        console.debug('Start encrypte scripts...');
        // native 加密步骤(1/3)：生成完工程所有文件添加 cmake 配置
        if (this.params.encrypted) {
            this.params.cMakeConfig.XXTEAKEY = `set(XXTEAKEY "${this.params.xxteaKey}")`;
        }
        const backupPath = ps.join(this.paths.buildDir, 'script-backup');
        fs.ensureDirSync(backupPath);
        fs.emptyDirSync(backupPath);

        const allBundleConfigs: string[] = await globby([
            ps.join(this.paths.buildAssetsDir, 'assets/*/cc.config*.json'),
            ps.join(this.paths.buildAssetsDir, 'remote/*/cc.config*.json'),
        ]);
        for (const configPath of allBundleConfigs) {
            const config = await fs.readJSON(configPath);

            // native 加密步骤(2/3)：加密的标志位，需要写入到 bundle 的 config.json 内运行时需要
            const version = configPath.match(/\/cc.config(.*).json/)![1];
            const scriptDest = ps.join(ps.dirname(configPath), `index${version}.js`);
            let content: any = fs.readFileSync(scriptDest, 'utf8');
            if (this.params.compressZip) {
                content = gzipSync(content);
                content = xxtea.encrypt(content, xxtea.toBytes(this.params.xxteaKey));
            } else {
                content = xxtea.encrypt(xxtea.toBytes(content), xxtea.toBytes(this.params.xxteaKey));
            }
            const newScriptDest = ps.join(ps.dirname(scriptDest), ps.basename(scriptDest, ps.extname(scriptDest)) + '.jsc');
            fs.writeFileSync(newScriptDest, content);

            config.encrypted = true;
            fs.writeJSONSync(configPath, config);

            fs.copySync(scriptDest, ps.join(backupPath, ps.relative(this.paths.buildAssetsDir, scriptDest)));
            fs.removeSync(scriptDest);
        }
        await this.generateCMakeConfig();
        console.debug('Encrypte scriptes success');
    }

    /**
     * 解析、执行 cocos-template.json 模板任务
     */
    protected async excuteCocosTemplateTask() {
        const templatTaskMap: Record<string, CocosProjectTasks> = await fs.readJSON(ps.join(this.paths.nativeTemplateDirInCocos, PackageNewConfig));
        for (const templatTask of Object.values(templatTaskMap)) {
            await this.excuteTemplateTask(templatTask);
        }
    }

    abstract create(): Promise<boolean>;
    generate?(): Promise<boolean>;
    make?(): Promise<boolean>;
    run?(): Promise<boolean>;
}

// cocos.compile.json 
export class CocosParams<T> {
    platformParams!: T | any;
    public debug: boolean;
    public projectName: string;
    public cmakePath: string;
    public platform: string;
    public platformName: string;
    /**
     * engine root
     */
    public enginePath: string;
    /**
     * native engine root
     */
    public nativeEnginePath: string;
    /**
     * project path
     */
    public projDir: string;
    /**
     * build/[platform]
     */
    public buildDir: string;
    /**
     * @zh 构建资源路径
     * @en /build/[platform]/data
     */
    public buildAssetsDir: string;
    /**
     * @zh 是否加密脚本
     * @en is encrypted
     */
    encrypted?: boolean;
    /**
     * @zh 是否压缩脚本
     * @en is compress script
     */
    compressZip?: boolean;
    /**
     * @zh 加密密钥
     * @en encrypt Key
     */
    xxteaKey?: string;
    /**
     * @zh 是否为模拟器
     * @en is simulator
     */
    simulator?: boolean;


    public cMakeConfig: ICMakeConfig = {
        CC_USE_GLES3: false,
        CC_USE_GLES2: true,
        USE_SERVER_MODE: 'set(USE_SERVER_MODE OFF)',
        NET_MODE: 'set(NET_MODE 0)',
        XXTEAKEY: '',
        CC_ENABLE_SWAPPY: false,
    }

    constructor(params: CocosParams<Object>) {
        this.buildAssetsDir = params.buildAssetsDir;
        this.projectName = params.projectName;
        this.debug = params.debug;
        this.cmakePath = params.cmakePath;
        this.platform = params.platform;
        this.platformName = params.platformName;
        this.enginePath = params.enginePath;
        this.nativeEnginePath = params.nativeEnginePath;
        this.projDir = params.projDir;
        this.buildDir = params.buildDir;
        this.xxteaKey = params.xxteaKey;
        this.encrypted = params.encrypted;
        Object.assign(this.cMakeConfig, params.cMakeConfig);
        this.platformParams = params.platformParams;
    }
}