/*
 * Copyright (C) 2019 Intel Corporation.  All rights reserved.
 * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 */

import * as fileSystem from 'fs';
import * as os from 'os';
import * as path from 'path';
import * as vscode from 'vscode';

import { WasmTaskProvider } from './taskProvider';
import { TargetConfigPanel } from './view/TargetConfigPanel';
import { NewProjectPanel } from './view/NewProjectPanel';
import {
    checkIfDirectoryExists,
    writeIntoFile,
    readFromFile,
} from './utilities/directoryUtilities';
import { decorationProvider } from './decorationProvider';
import { WasmDebugConfigurationProvider } from './debugConfigurationProvider';
import {
    isLLDBInstalled,
    promptInstallLLDB,
    getWAMRExtensionVersion,
} from './utilities/lldbUtilities';

import {
    checkIfDockerStarted,
    checkIfDockerImagesExist,
    promptSetupDockerImages,
} from './utilities/dockerUtilities';
import { SelectionOfPrompt } from './constants';

let wasmTaskProvider: WasmTaskProvider;
let wasmDebugConfigProvider: WasmDebugConfigurationProvider;
let currentPrjDir = '';
let isWasmProject = false;

// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
export async function activate(context: vscode.ExtensionContext) {
    const extensionPath = context.extensionPath;
    const osPlatform = os.platform();
    const wamrVersion = getWAMRExtensionVersion(context.extensionPath);
    const typeMap = new Map<string, string>();
    const scriptMap = new Map<string, string>();
    /* set relative path of build.bat|sh script */
    const scriptPrefix = 'resource/scripts/';

    let buildScript = '',
        runScript = '',
        debugScript = '',
        destroyScript = '',
        buildScriptFullPath = '',
        runScriptFullPath = '',
        debugScriptFullPath = '',
        destroyScriptFullPath = '',
        /* include paths array used for written into config file */
        includePathArr = new Array<string>(),
        /* exclude files array used for written into config file */
        excludeFileArr = new Array<string>();

    /**
     * Provide Build & Run Task with Task Provider instead of "tasks.json"
     */

    if (osPlatform === 'win32') {
        buildScript = scriptPrefix.concat('build.bat');
        runScript = scriptPrefix.concat('run.bat');
        debugScript = scriptPrefix.concat('boot_debugger_server.bat');
        destroyScript = scriptPrefix.concat('destroy.bat');
    } else if (osPlatform === 'linux' || osPlatform === 'darwin') {
        buildScript = scriptPrefix.concat('build.sh');
        runScript = scriptPrefix.concat('run.sh');
        debugScript = scriptPrefix.concat('boot_debugger_server.sh');
        destroyScript = scriptPrefix.concat('destroy.sh');
    }

    buildScriptFullPath = path.join(extensionPath, buildScript);
    runScriptFullPath = path.join(extensionPath, runScript);
    debugScriptFullPath = path.join(extensionPath, debugScript);
    destroyScriptFullPath = path.join(extensionPath, destroyScript);

    scriptMap.set('buildScript', buildScriptFullPath);
    scriptMap.set('runScript', runScriptFullPath);
    scriptMap.set('debugScript', debugScriptFullPath);
    scriptMap.set('destroyScript', destroyScriptFullPath);

    typeMap.set('Build', 'Build');
    typeMap.set('Run', 'Run');
    typeMap.set('Debug', 'Debug');
    typeMap.set('Destroy', 'Destroy');

    wasmTaskProvider = new WasmTaskProvider(typeMap, scriptMap, wamrVersion);

    vscode.tasks.registerTaskProvider('wasm', wasmTaskProvider);

    if (vscode.workspace.workspaceFolders?.[0]) {
        if (osPlatform === 'win32') {
            currentPrjDir = vscode.workspace.workspaceFolders?.[0].uri
                .fsPath as string;
        } else if (osPlatform === 'linux' || osPlatform === 'darwin') {
            currentPrjDir = vscode.workspace.workspaceFolders?.[0].uri
                .path as string;
        }

        /**
         * check whether current project opened in vscode workspace is wasm project
         * it not, `build`, `run` and `debug` will be disabled
         */
        if (currentPrjDir !== '') {
            const wamrFolder = fileSystem
                .readdirSync(currentPrjDir, {
                    withFileTypes: true,
                })
                .filter(
                    folder => folder.isDirectory() && folder.name === '.wamr'
                );

            if (wamrFolder.length !== 0) {
                isWasmProject = true;
                vscode.commands.executeCommand(
                    'setContext',
                    'ext.isWasmProject',
                    isWasmProject
                );
                if (
                    vscode.workspace
                        .getConfiguration()
                        .has('C_Cpp.default.systemIncludePath')
                ) {
                    let newIncludeInCppArr: string[] | undefined | null;

                    newIncludeInCppArr = vscode.workspace
                        .getConfiguration()
                        .get('C_Cpp.default.systemIncludePath');

                    const libcBuiltinHeaderPath = path.join(
                        extensionPath,
                        'resource/wamr-sdk/libc-builtin-sysroot/include'
                    );

                    if (newIncludeInCppArr !== undefined) {
                        /* in case the configuration has not been set up, push directly */
                        if (newIncludeInCppArr === null) {
                            newIncludeInCppArr = [];
                            newIncludeInCppArr.push(libcBuiltinHeaderPath);
                        } else {
                            /* if the configuration has been set up, check the condition */
                            if (
                                /* include libc-builtin-sysroot */
                                newIncludeInCppArr.indexOf(
                                    libcBuiltinHeaderPath
                                ) < 0
                            ) {
                                newIncludeInCppArr.push(libcBuiltinHeaderPath);
                            }
                        }

                        vscode.workspace
                            .getConfiguration()
                            .update(
                                'C_Cpp.default.systemIncludePath',
                                newIncludeInCppArr,
                                vscode.ConfigurationTarget.Workspace
                            );
                    }
                }
            }
        }
    }

    /* register debug configuration */
    wasmDebugConfigProvider = new WasmDebugConfigurationProvider(
        context.extensionPath
    );

    vscode.debug.registerDebugConfigurationProvider(
        'wamr-debug',
        wasmDebugConfigProvider
    );

    /* update ext.includePaths to show or hide 'Remove' button in menus */
    vscode.commands.executeCommand('setContext', 'ext.supportedFileType', [
        '.c',
        '.cpp',
        '.cxx',
    ]);

    if (readFromConfigFile() !== '') {
        const configData = JSON.parse(readFromConfigFile());
        includePathArr = configData['includePaths'];
        excludeFileArr = configData['excludeFiles'];

        if (Object.keys(configData['buildArgs']).length !== 0) {
            TargetConfigPanel.buildArgs = configData['buildArgs'];
        }
    }

    const disposableNewProj = vscode.commands.registerCommand(
        'wamride.newProject',
        () => {
            const okStr = 'Set up now';
            const cancelStr = 'Maybe later';
            const curWorkspace = vscode.workspace
                .getConfiguration()
                .get('WAMR-IDE.configWorkspace');

            /* if user has not set up workspace yet, prompt to set up */
            if (curWorkspace === '' || curWorkspace === undefined) {
                vscode.window
                    .showWarningMessage(
                        'Please setup your workspace firstly.',
                        okStr,
                        cancelStr
                    )
                    .then(item => {
                        if (item === okStr) {
                            vscode.commands.executeCommand(
                                'wamride.changeWorkspace'
                            );
                        } else {
                            return;
                        }
                    });
            } else if (!checkIfDirectoryExists(curWorkspace as string)) {
                vscode.window
                    .showWarningMessage(
                        'Invalid workspace:',
                        {
                            modal: true,
                            detail:
                                '' +
                                vscode.workspace
                                    .getConfiguration()
                                    .get('WAMR-IDE.configWorkspace') +
                                '',
                        },
                        okStr
                    )
                    .then(item => {
                        if (item === okStr) {
                            vscode.commands.executeCommand(
                                'wamride.changeWorkspace'
                            );
                        } else {
                            return;
                        }
                    });
            } else {
                NewProjectPanel.render(context);
            }
        }
    );

    const disposableTargetConfig = vscode.commands.registerCommand(
        'wamride.targetConfig',
        () => {
            if (currentPrjDir !== '') {
                TargetConfigPanel.render(context);
            } else {
                vscode.window.showWarningMessage(
                    'Please create and open project firstly.',
                    'OK'
                );
            }
        }
    );

    const disposableChangeWorkspace = vscode.commands.registerCommand(
        'wamride.changeWorkspace',
        async () => {
            const options: vscode.OpenDialogOptions = {
                canSelectFiles: false,
                canSelectFolders: true,
                openLabel: 'Select Workspace',
            };

            const workSpace = await vscode.window
                .showOpenDialog(options)
                .then(res => {
                    if (res) {
                        return res[0].fsPath as string;
                    } else {
                        return '';
                    }
                });

            /* update workspace value to vscode global settings */
            if (workSpace !== '' && workSpace !== undefined) {
                await vscode.workspace
                    .getConfiguration()
                    .update(
                        'WAMR-IDE.configWorkspace',
                        workSpace.trim(),
                        vscode.ConfigurationTarget.Global
                    )
                    .then(
                        () => {
                            vscode.window.showInformationMessage(
                                'Workspace has been set up successfully!'
                            );
                        },
                        () => {
                            vscode.window.showErrorMessage(
                                'Set up Workspace failed!'
                            );
                        }
                    );
            }
        }
    );

    const disposableBuild = vscode.commands.registerCommand(
        'wamride.build',
        async () => {
            if (!isWasmProject) {
                vscode.window.showErrorMessage('Build failed', {
                    modal: true,
                    detail: 'Current project is not wasm project, please open wasm project and try again.',
                });
                return;
            }

            try {
                /* check if docker images are ready before building */
                if (
                    (await checkIfDockerStarted()) &&
                    !(await checkIfDockerImagesExist(context))
                ) {
                    /**NOTE - if users select to skip install,
                     *        we should return rather than continue
                     *        the execution
                     */
                    if (
                        (await promptSetupDockerImages(context)) ===
                        SelectionOfPrompt.skip
                    ) {
                        return;
                    }
                }
            } catch (e) {
                vscode.window.showWarningMessage((e as Error).message);
                return;
            }

            generateCMakeFile(includePathArr, excludeFileArr);
            /* destroy the wasm-toolchain-ctr if it exists */
            vscode.commands
                .executeCommand(
                    'workbench.action.tasks.runTask',
                    'Destroy: Wasm-Container-Before-Build'
                )
                .then(() => {
                    const disposable = vscode.tasks.onDidEndTaskProcess(t => {
                        if (
                            t.execution.task.name ===
                            'Wasm-Container-Before-Build'
                        ) {
                            if (t.exitCode !== 0) {
                                disposable.dispose();
                                return;
                            }

                            /* execute the build task */
                            vscode.commands
                                .executeCommand(
                                    'workbench.action.tasks.runTask',
                                    'Build: Wasm'
                                )
                                .then(() => {
                                    /* destroy the wasm-toolchain-ctr after building */
                                    const disposableAft =
                                        vscode.tasks.onDidEndTask(a => {
                                            if (
                                                a.execution.task.name ===
                                                    'Wasm' &&
                                                a.execution.task.source ===
                                                    'Build'
                                            ) {
                                                vscode.commands
                                                    .executeCommand(
                                                        'workbench.action.tasks.runTask',
                                                        'Destroy: Wasm-Container-After-Build'
                                                    )
                                                    .then(() => {
                                                        /* dispose the event after this building process
                                                         */
                                                        disposableAft.dispose();
                                                    });
                                            }
                                        });
                                });
                            /* dispose the event after this building process */
                            disposable.dispose();
                        }
                    });
                });
        }
    );

    const disposableDebug = vscode.commands.registerCommand(
        'wamride.debug',
        async () => {
            if (!isWasmProject) {
                vscode.window.showErrorMessage('debug failed', {
                    modal: true,
                    detail: 'Current project is not wasm project, please open wasm project and try again.',
                });
                return;
            }

            /* we should check again whether the user installed lldb, as this can be skipped during activation */
            try {
                if (!isLLDBInstalled(context.extensionPath)) {
                    /**NOTE - if users select to skip install,
                     *        we should return rather than continue
                     *        the execution
                     */
                    if (
                        (await promptInstallLLDB(context.extensionPath)) ===
                        SelectionOfPrompt.skip
                    ) {
                        return;
                    }
                }

                if (
                    (await checkIfDockerStarted()) &&
                    !(await checkIfDockerImagesExist(context))
                ) {
                    /**NOTE - save as above lldb, should return if
                     *        users select to skip set up
                     */
                    if (
                        (await promptSetupDockerImages(context)) ===
                        SelectionOfPrompt.skip
                    ) {
                        return;
                    }
                }
            } catch (e) {
                vscode.window.showWarningMessage((e as Error).message);
                return;
            }

            /* refuse to debug if build process failed */
            if (!checkIfBuildSuccess()) {
                vscode.window.showErrorMessage('Debug failed', {
                    modal: true,
                    detail: 'Can not find WASM binary, please build WASM firstly.',
                });
                return;
            }

            /* show debug view */
            vscode.commands.executeCommand('workbench.view.debug');

            /* should destroy the wasm-debug-server-ctr before debugging */
            vscode.commands
                .executeCommand(
                    'workbench.action.tasks.runTask',
                    'Destroy: Wasm-Container-Before-Debug'
                )
                .then(() => {
                    /* execute the debug task when destroy task finish */
                    const disposableBfr = vscode.tasks.onDidEndTask(t => {
                        if (
                            t.execution.task.name ===
                            'Wasm-Container-Before-Debug'
                        ) {
                            vscode.commands
                                .executeCommand(
                                    'workbench.action.tasks.runTask',
                                    'Debug: Wasm'
                                )
                                .then(() => {
                                    vscode.debug
                                        .startDebugging(
                                            undefined,
                                            wasmDebugConfigProvider.getDebugConfig()
                                        )
                                        .then(() => {
                                            /* register to listen debug session finish event */
                                            const disposableAft =
                                                vscode.debug.onDidTerminateDebugSession(
                                                    s => {
                                                        if (
                                                            s.type !==
                                                            'wamr-debug'
                                                        ) {
                                                            return;
                                                        }

                                                        /* execute the task to destroy
                                                         * wasm-debug-server-ctr */
                                                        vscode.commands.executeCommand(
                                                            'workbench.action.tasks.runTask',
                                                            'Destroy: Wasm-Container-After-Debug'
                                                        );

                                                        /* execute the task to kill the terminal */
                                                        vscode.commands.executeCommand(
                                                            'workbench.action.terminal.kill',
                                                            'Debug: Wasm'
                                                        );

                                                        disposableAft.dispose();
                                                    }
                                                );
                                        });
                                });
                        }
                        disposableBfr.dispose();
                    });
                });
        }
    );

    const disposableRun = vscode.commands.registerCommand(
        'wamride.run',
        async () => {
            if (!isWasmProject) {
                vscode.window.showErrorMessage('run failed', {
                    modal: true,
                    detail: 'Current project is not wasm project, please open wasm project and try again.',
                });
                return;
            }

            try {
                /* check if docker images are set up before building */
                if (
                    (await checkIfDockerStarted()) &&
                    !(await checkIfDockerImagesExist(context))
                ) {
                    await promptSetupDockerImages(context);
                }
            } catch (e) {
                vscode.window.showWarningMessage((e as Error).message);
                return;
            }

            /* refuse to debug if build process failed */
            if (!checkIfBuildSuccess()) {
                vscode.window.showErrorMessage('Debug failed', {
                    modal: true,
                    detail: 'Can not find WASM binary, please build WASM firstly.',
                });
                return;
            }

            vscode.commands
                .executeCommand(
                    'workbench.action.tasks.runTask',
                    'Destroy: Wasm-Container-Before-Run'
                )
                .then(() => {
                    const disposableAft = vscode.tasks.onDidEndTaskProcess(
                        e => {
                            if (
                                e.execution.task.name ===
                                'Wasm-Container-Before-Run'
                            ) {
                                /* make sure that run wasm task will be executed when destroy task finish */
                                vscode.commands
                                    .executeCommand(
                                        'workbench.action.tasks.runTask',
                                        'Run: Wasm'
                                    )
                                    .then(() => {
                                        if (e.exitCode !== 0) {
                                            disposableAft.dispose();
                                            return;
                                        }
                                    });
                                disposableAft.dispose();
                            }
                        }
                    );
                });
        }
    );

    const disposableToggleIncludePath = vscode.commands.registerCommand(
        'wamride.build.toggleStateIncludePath',
        fileUri => {
            const path =
                fileUri._fsPath !== null && fileUri._fsPath !== undefined
                    ? fileUri._fsPath
                    : vscode.Uri.parse(fileUri.path as string).fsPath;
            const pathRelative = path.replace(currentPrjDir, '..');

            if (includePathArr.indexOf(pathRelative) > -1) {
                /* this folder has been added to include path, remove it */
                includePathArr = includePathArr.filter(value => {
                    return value !== pathRelative;
                });
            } else {
                includePathArr.push(pathRelative);
            }

            writeIntoConfigFile(
                includePathArr,
                excludeFileArr,
                TargetConfigPanel.buildArgs
            );

            decorationProvider.updateDecorationsForSource(fileUri);
        }
    );

    const disposableToggleExcludeFile = vscode.commands.registerCommand(
        'wamride.build.toggleStateExclude',
        fileUri => {
            const path =
                fileUri._fsPath !== null && fileUri._fsPath !== undefined
                    ? fileUri._fsPath
                    : vscode.Uri.parse(fileUri.path as string).fsPath;

            /* replace the current project absolute path with .. to change to relative path */
            const pathRelative = path.replace(currentPrjDir, '..');

            if (excludeFileArr.indexOf(pathRelative) > -1) {
                excludeFileArr = excludeFileArr.filter(val => {
                    return val !== pathRelative;
                });
            } else {
                excludeFileArr.push(pathRelative);
            }

            writeIntoConfigFile(
                includePathArr,
                excludeFileArr,
                TargetConfigPanel.buildArgs
            );

            /* update decoration for this source file */
            decorationProvider.updateDecorationsForSource(fileUri);
        }
    );

    const disposableOpenFolder = vscode.commands.registerCommand(
        'wamride.openFolder',
        () => {
            /* get projects list under current workspace */
            const okStr = 'Set up now';
            const cancelStr = 'Maybe later';
            const createStr = 'Create now';
            const curWorkspace = vscode.workspace
                .getConfiguration()
                .get('WAMR-IDE.configWorkspace') as string;

            /* if user has not set up workspace yet, prompt to set up */
            if (curWorkspace === '' || curWorkspace === undefined) {
                vscode.window
                    .showWarningMessage(
                        'Please setup your workspace firstly.',
                        okStr,
                        cancelStr
                    )
                    .then(item => {
                        if (item === okStr) {
                            vscode.commands.executeCommand(
                                'wamride.changeWorkspace'
                            );
                        } else {
                            return;
                        }
                    });
            } else if (!checkIfDirectoryExists(curWorkspace as string)) {
                vscode.window
                    .showWarningMessage(
                        'Invalid workspace:',
                        {
                            modal: true,
                            detail:
                                '' +
                                vscode.workspace
                                    .getConfiguration()
                                    .get('WAMR-IDE.configWorkspace') +
                                '',
                        },
                        okStr
                    )
                    .then(item => {
                        if (item === okStr) {
                            vscode.commands.executeCommand(
                                'wamride.changeWorkspace'
                            );
                        } else {
                            return;
                        }
                    });
            } else {
                /* get all directories within directory, ignore files */
                let directoryArrDirent, directoryArr;
                try {
                    directoryArrDirent = fileSystem.readdirSync(curWorkspace, {
                        withFileTypes: true,
                    });
                } catch (err) {
                    vscode.window.showErrorMessage(
                        'Read projects from current workspace failed.'
                    );
                }

                if (directoryArrDirent !== undefined) {
                    directoryArr = directoryArrDirent
                        .filter(dirent => dirent.isDirectory())
                        .map(dirent => dirent.name);

                    const projFilesArr = directoryArr.filter(obj => {
                        if (checkIfWasmProj(path.join(curWorkspace, obj))) {
                            return true;
                        }
                    });

                    if (projFilesArr.length === 0) {
                        vscode.window
                            .showWarningMessage(
                                'Current workspace is empty, please create your project firstly.',
                                createStr,
                                cancelStr
                            )
                            .then(item => {
                                if (item === createStr) {
                                    vscode.commands.executeCommand(
                                        'wamride.newProject'
                                    );
                                } else {
                                    return;
                                }
                            });
                    } else {
                        vscode.window
                            .showQuickPick(projFilesArr, {
                                title: 'Select project',
                                placeHolder: 'Please select project',
                            })
                            .then(option => {
                                if (!option) {
                                    return;
                                }

                                const path = curWorkspace.concat(
                                    osPlatform === 'win32'
                                        ? '\\'
                                        : osPlatform === 'linux' ||
                                          osPlatform === 'darwin'
                                        ? '/'
                                        : '',
                                    option
                                );

                                /* open the selected wasm project */
                                openWindowWithSituation(vscode.Uri.file(path));
                            });
                    }
                }
            }
        }
    );

    context.subscriptions.push(
        disposableNewProj,
        disposableTargetConfig,
        disposableChangeWorkspace,
        disposableBuild,
        disposableRun,
        disposableToggleIncludePath,
        disposableOpenFolder,
        disposableToggleExcludeFile,
        disposableDebug
    );

    try {
        if (!isLLDBInstalled(context.extensionPath)) {
            await promptInstallLLDB(context.extensionPath);
        }

        if (
            (await checkIfDockerStarted()) &&
            !(await checkIfDockerImagesExist(context))
        ) {
            await promptSetupDockerImages(context);
        }
    } catch (e) {
        vscode.window.showWarningMessage((e as Error).message);
    }
}

function openWindowWithSituation(uri: vscode.Uri) {
    /**
     * check if the workspace folder is empty,
     * if yes, open new window, else open in current window
     */
    const isWorkspaceEmpty = !vscode.workspace.workspaceFolders?.[0]
        ? true
        : false;

    isWorkspaceEmpty === false
        ? vscode.commands.executeCommand('vscode.openFolder', uri, {
              forceNewWindow: true,
          })
        : vscode.commands.executeCommand('vscode.openFolder', uri);

    return;
}

interface BuildArgs {
    outputFileName: string;
    initMemorySize: string;
    maxMemorySize: string;
    stackSize: string;
    exportedSymbols: string;
    hostManagedHeapSize: string;
}

/**
 * @param: includePathArr
 * @param: excludeFileArr
 *   Get current includePathArr and excludeFileArr from the json string that
 *   will be written into compilation_config.json
 */
export function writeIntoConfigFile(
    includePathArr: string[],
    excludeFileArr: string[],
    buildArgs?: BuildArgs
): void {
    const jsonStr = JSON.stringify(
        {
            includePaths: includePathArr,
            excludeFiles: excludeFileArr,
            buildArgs: buildArgs ? buildArgs : '{}',
        },
        null,
        '\t'
    );

    const prjConfigDir = path.join(currentPrjDir, '.wamr');
    const configFilePath = path.join(prjConfigDir, 'compilation_config.json');
    writeIntoFile(configFilePath, jsonStr);
}

export function readFromConfigFile(): string {
    const prjConfigDir = path.join(currentPrjDir, '.wamr');
    const configFilePath = path.join(prjConfigDir, 'compilation_config.json');
    return readFromFile(configFilePath);
}

/**
 * will be triggered when the user clicking `build` button
 */
function generateCMakeFile(
    includePathArr: string[],
    excludeFileArr: string[]
): void {
    // -Wl,--export=${EXPORT_SYMBOLS}
    const srcFilePath = path.join(currentPrjDir, 'src');
    const prjConfigDir = path.join(currentPrjDir, '.wamr');
    const cmakeFilePath = path.join(prjConfigDir, 'project.cmake');

    let strIncludeList = 'set (PROJECT_INCLUDES';
    let strSrcList = 'set (PROJECT_SRC_LIST';

    let strOutputFileName = 'set (OUTPUT_FILE_NAME';
    let strInitMemSize = 'set (INIT_MEM_SIZE';
    let strMaxMemSize = 'set (MAX_MEM_SIZE';
    let strStackSize = 'set (STACK_SIZE';
    let strExportedSymbols = 'set (EXPORTED_SYMBOLS';

    let fullStr = '';
    let i, s, e: number;

    /* change the absolute path into relative path */
    const _re = currentPrjDir;
    const _substr = '${CMAKE_CURRENT_SOURCE_DIR}/..';

    /**
     * set PROJECT_SRC_LIST
     *     default ADD every c OR c++ OR cpp under the src/ path
     *     except the files saved in the excludeFiles array
     */

    const srcPathArr = getAllSrcFiles(srcFilePath);

    if (srcPathArr === undefined) {
        return;
    }

    for (s = 0; s < srcPathArr.length; s++) {
        if (
            excludeFileArr.indexOf(
                srcPathArr[s].path.replace(currentPrjDir, '..')
            ) === -1
        ) {
            /* replace currentPrjDir with ${CMAKE_CURRENT_SOURCE_DIR} */
            const newStr = srcPathArr[s].path
                .replace(_re, _substr)
                .replace(/\\/g, '/');

            strSrcList = strSrcList.concat(' ', newStr);
        }
    }
    strSrcList = strSrcList.concat(' )');

    for (i = 0; i < includePathArr.length; i++) {
        const newStr = includePathArr[i]
            .replace(/../, _substr)
            .replace(/\\/g, '/');
        strIncludeList = strIncludeList.concat(' ', newStr);
    }
    strIncludeList = strIncludeList.concat(' )');

    /* set up user customized input in configBuildArgs webview */
    strOutputFileName = strOutputFileName.concat(
        ' ',
        TargetConfigPanel.buildArgs.outputFileName + ')'
    );

    strInitMemSize = strInitMemSize.concat(
        ' ',
        TargetConfigPanel.buildArgs.initMemorySize + ')'
    );

    strMaxMemSize = strMaxMemSize.concat(
        ' ',
        TargetConfigPanel.buildArgs.maxMemorySize + ')'
    );

    strStackSize = strStackSize.concat(
        ' ',
        TargetConfigPanel.buildArgs.stackSize + ')'
    );

    const exportedSymbolArr =
        TargetConfigPanel.buildArgs.exportedSymbols.split(',');

    strExportedSymbols = strExportedSymbols.concat(' "');

    for (e = 0; e < exportedSymbolArr.length; e++) {
        strExportedSymbols = strExportedSymbols.concat(
            ' -Wl,',
            '--export=',
            exportedSymbolArr[e]
        );
    }

    strExportedSymbols = strExportedSymbols.concat('")');

    fullStr = strOutputFileName
        .concat('\n', strInitMemSize)
        .concat('\n', strMaxMemSize)
        .concat('\n', strStackSize)
        .concat('\n', strExportedSymbols)
        .concat('\n', strSrcList)
        .concat('\n', strIncludeList);

    writeIntoFile(cmakeFilePath, fullStr);
}

function getAllSrcFiles(_path: string) {
    try {
        const entries = fileSystem.readdirSync(_path, {
            withFileTypes: true,
        });

        const files = entries
            .filter(
                /* filter files mismatch .c |.cpp |.cxx */
                file =>
                    !file.isDirectory() && file.name.match('(.c|.cpp|.cxx)$')
            )
            .map(file => ({
                path: path.join(_path, file.name),
            }));

        const folders = entries.filter(folder => folder.isDirectory());

        for (const folder of folders) {
            const fileArr = getAllSrcFiles(path.join(_path, folder.name));
            fileArr ? files.push(...fileArr) : '';
        }

        return files;
    } catch (error) {
        vscode.window.showErrorMessage(error as string);
    }
}

function checkIfBuildSuccess(): boolean {
    try {
        let wasmExist = false;
        const entries = fileSystem.readdirSync(
            path.join(currentPrjDir, 'build'),
            {
                withFileTypes: true,
            }
        );

        entries.map(e => {
            if (e.name.match('(.wasm)$')) {
                wasmExist = true;
            }
        });

        return wasmExist;
    } catch {
        return false;
    }
}

function checkIfWasmProj(path: string): boolean {
    try {
        let isWasmProj = false;
        const entries = fileSystem.readdirSync(path, {
            withFileTypes: true,
        });

        entries.map(e => {
            if (e.isDirectory() && e.name === '.wamr') {
                isWasmProj = true;
            }
        });

        return isWasmProj;
    } catch {
        return false;
    }
}