goog.loadJs('web', () => {

goog.require('path');
goog.require('BoardId');
goog.require('FSWrapper');
goog.require('DAPWrapper');
goog.require('PartialFlashing');
goog.require('esptooljs');
goog.require('CryptoJS');
goog.require('JSZip');
goog.require('Mixly.Env');
goog.require('Mixly.LayerExt');
goog.require('Mixly.Config');
goog.require('Mixly.MFile');
goog.require('Mixly.Boards');
goog.require('Mixly.Msg');
goog.require('Mixly.Workspace');
goog.require('Mixly.Debug');
goog.require('Mixly.HTMLTemplate');
goog.require('Mixly.MString');
goog.require('Mixly.LayerFirmware');
goog.require('Mixly.LayerProgress');
goog.require('Mixly.Web.Serial');
goog.require('Mixly.Web.Ampy');
goog.require('Mixly.Web.KFlash');
goog.require('Mixly.Web.SerialTransport');
goog.provide('Mixly.Web.BU');

const {
    Env,
    Web,
    LayerExt,
    Config,
    MFile,
    Boards,
    Msg,
    Workspace,
    Debug,
    HTMLTemplate,
    MString,
    LayerFirmware,
    LayerProgress
} = Mixly;

const {
    Serial,
    BU,
    Ampy,
    KFlash,
    SerialTransport
} = Web;

const { BOARD, SELECTED_BOARD } = Config;
const { ESPLoader } = esptooljs;


BU.uploading = false;
BU.burning = false;
BU.firmwareLayer = new LayerFirmware({
    width: 400,
    title: Msg.Lang['nav.btn.burn'],
    cancelValue: false,
    skin: 'layui-anim layui-anim-scale',
    cancel: false,
    cancelDisplay: false
});
BU.firmwareLayer.bind('burn', (info) => {
    const { web } = SELECTED_BOARD;
    BU.burnWithEsptool(info, web.burn.erase);
});
BU.progressLayer = new LayerProgress({
    width: 200,
    cancelValue: false,
    skin: 'layui-anim layui-anim-scale',
    cancel: false,
    cancelDisplay: false
});

if (['BBC micro:bit', 'Mithon CC'].includes(BOARD.boardType)) {
    FSWrapper.setupFilesystem(path.join(Env.boardDirPath, 'build'));
}

BU.requestPort = async () => {
    await Serial.requestPort();
}

const readBinFile = (path, offset) => {
    return new Promise((resolve, reject) => {
        fetch(path)
        .then((response) => {
            return response.blob();
        })
        .then((blob) => {
            const reader = new FileReader();
            reader.onload = function (event) {
                resolve({
                    address: parseInt(offset),
                    data: event.target.result
                });
            };
            reader.onerror = function (error) {
                throw(error);
            }
            reader.readAsBinaryString(blob);
        })
        .catch((error) => {
            reject(error);
        });
    });
}

const readBinFileAsArrayBuffer = (path, offset) => {
    return new Promise((resolve, reject) => {
        fetch(path)
        .then((response) => {
            return response.blob();
        })
        .then((blob) => {
            const reader = new FileReader();
            reader.onload = function (event) {
                resolve({
                    address: parseInt(offset),
                    data: event.target.result
                });
            };
            reader.onerror = function (error) {
                throw(error);
            }
            reader.readAsArrayBuffer(blob);
        })
        .catch((error) => {
            reject(error);
        });
    });
}

const decodeKfpkgFromArrayBuffer = async(arrayBuf) => {
    const zip = await JSZip.loadAsync(arrayBuf);
    const manifestEntry = zip.file('flash-list.json');
    if (!manifestEntry) {
        throw new Error('kfpkg is missing flash-list.json');
    }
    const manifestText = await manifestEntry.async('string');
    const manifest = JSON.parse(manifestText);

    const items = [];
    for (const f of manifest.files || []) {
        const entry = zip.file(f.bin);
        if (!entry) {
            throw new Error(`Missing files in package: ${f.bin}`);
        }
        const data = new Uint8Array(await entry.async('uint8array'));
        items.push({
            address: f.address >>> 0,
            filename: f.bin,
            sha256Prefix: !!f.sha256Prefix,
            data
        });
    }

    return { manifest, items };
}

BU.initBurn = async () => {
    if (['BBC micro:bit', 'Mithon CC'].includes(BOARD.boardType)) {
        await BU.burnWithDAP();
    } else if (['MixGo AI'].includes(BOARD.boardType)) {
        const { web } = SELECTED_BOARD;
        const boardKey = Boards.getSelectedBoardKey();
        if (!web?.burn?.binFile) {
            return;
        }
        if (typeof web.burn.binFile !== 'object') {
            return;
        }
        await BU.burnWithKFlash(web.burn.binFile, web.burn.erase);
    } else {
        const { web } = SELECTED_BOARD;
        const boardKey = Boards.getSelectedBoardKey();
        if (!web?.burn?.binFile) {
            return;
        }
        if (typeof web.burn.binFile !== 'object') {
            return;
        }
        if (web.burn.special && web.burn.special instanceof Array) {
            BU.burnWithSpecialBin();
        } else {
            await BU.burnWithEsptool(web.burn.binFile, web.burn.erase);
        }
    }
}

BU.burnWithDAP = async () => {
    const { mainStatusBarTabs } = Mixly;
    let portName = Serial.getSelectedPortName();
    if (!portName) {
        try {
            await BU.requestPort();
            portName = Serial.getSelectedPortName();
            if (!portName) {
                return;
            }
        } catch (error) {
            Debug.error(error);
            return;
        }
    }
    const statusBarSerial = mainStatusBarTabs.getStatusBarById(portName);
    if (statusBarSerial) {
        await statusBarSerial.close();
    }

    const { web } = SELECTED_BOARD;
    const { burn } = web;
    const hexStr = goog.readFileSync(path.join(Env.boardDirPath, burn.filePath));
    const hex2Blob = new Blob([ hexStr ], { type: 'text/plain' });
    const buffer = await hex2Blob.arrayBuffer();
    if (!buffer) {
        layer.msg(Msg.Lang['shell.bin.readFailed'], { time: 1000 });
        return;
    }
    BU.burning = true;
    BU.uploading = false;
    const statusBarTerminal = mainStatusBarTabs.getStatusBarById('output');
    statusBarTerminal.setValue(`${Msg.Lang['shell.burning']}...\n`);
    mainStatusBarTabs.show();
    mainStatusBarTabs.changeTo('output');
    const port = Serial.getPort(portName);
    const webUSB = new DAPjs.WebUSB(port);
    const dapLink = new DAPjs.DAPLink(webUSB);
    try {
        await dapLink.connect();
        await dapLink.setSerialBaudrate(115200);
    } catch (error) {
        Debug.error(error);
        return;
    }
    let prevPercent = 0;
    dapLink.on(DAPjs.DAPLink.EVENT_PROGRESS, progress => {
        const nowPercent = Math.floor(progress * 100);
        if (nowPercent > prevPercent) {
            prevPercent = nowPercent;
        } else {
            return;
        }
        const nowProgressLen = Math.floor(nowPercent / 2);
        const leftStr = new Array(nowProgressLen).fill('=').join('');
        const rightStr = (new Array(50 - nowProgressLen).fill('-')).join('');
        statusBarTerminal.addValue(`[${leftStr}${rightStr}] ${nowPercent}%\n`);
    });
    BU.progressLayer.title(`${Msg.Lang['shell.burning']}...`);
    BU.progressLayer.show();
    try {
        await dapLink.flash(buffer);
        BU.progressLayer.hide();
        layer.msg(Msg.Lang['shell.burnSucc'], { time: 1000 });
        statusBarTerminal.addValue(`==${Msg.Lang['shell.burnSucc']}==\n`);
    } catch (error) {
        Debug.error(error);
        BU.progressLayer.hide();
        statusBarTerminal.addValue(`==${Msg.Lang['shell.burnFailed']}==\n`);
    } finally {
        dapLink.removeAllListeners(DAPjs.DAPLink.EVENT_PROGRESS);
        await dapLink.disconnect();
        await webUSB.close();
        await port.close();
    }
}

BU.burnWithEsptool = async (binFile, erase) => {
    const { mainStatusBarTabs } = Mixly;
    let portName = Serial.getSelectedPortName();
    if (!portName) {
        try {
            await BU.requestPort();
            portName = Serial.getSelectedPortName();
            if (!portName) {
                return;
            }
        } catch (error) {
            Debug.error(error);
            return;
        }
    }
    const port = Serial.getPort(portName);
    if (['HIDDevice'].includes(port.constructor.name)) {
        layer.msg(Msg.Lang['burn.notSupport'], { time: 1000 });
        return;
    }
    const statusBarSerial = mainStatusBarTabs.getStatusBarById(portName);
    if (statusBarSerial) {
        await statusBarSerial.close();
    }
    const statusBarTerminal = mainStatusBarTabs.getStatusBarById('output');
    statusBarTerminal.setValue(Msg.Lang['shell.burning'] + '...\n');
    mainStatusBarTabs.show();
    mainStatusBarTabs.changeTo('output');
    BU.progressLayer.title(`${Msg.Lang['shell.burning']}...`);
    BU.progressLayer.show();
    let esploader = null;
    let transport = null;
    try {
        const baudrate = Boards.getSelectedBoardConfigParam('BurnSpeed') ?? '460800';
        const serial = new Serial(portName);
        transport = new SerialTransport(serial, false);
        esploader = new ESPLoader({
            transport,
            baudrate,
            terminal: {
                clean() {
                    statusBarTerminal.setValue(Msg.Lang['shell.burning'] + '...\n');
                },
                writeLine(data) {
                    statusBarTerminal.addValue(data + '\n');
                },
                write(data) {
                    statusBarTerminal.addValue(data);
                }
            }
        });
        await esploader.main();
    } catch (error) {
        Debug.error(error);
        statusBarTerminal.addValue(`\n${error.toString()}\n`);
        try {
            await transport.disconnect();
        } catch (error) {
            Debug.error(error);
        }
        BU.progressLayer.hide();
        statusBarTerminal.addValue(`==${Msg.Lang['shell.burnFailed']}==\n`);
        return;
    }

    statusBarTerminal.addValue(Msg.Lang['shell.bin.reading'] + "...");
    let firmwarePromise = [];
    statusBarTerminal.addValue("\n");
    for (let i of binFile) {
        if (i.path && i.offset) {
            let absolutePath = path.join(Env.boardDirPath, i.path);
            firmwarePromise.push(readBinFile(absolutePath, i.offset));
        }
    }
    let data = null;
    try {
        data = await Promise.all(firmwarePromise);
    } catch (error) {
        statusBarTerminal.addValue("Failed!\n" + Msg.Lang['shell.bin.readFailed'] + "！\n");
        statusBarTerminal.addValue("\n" + error + "\n", true);
        try {
            await transport.disconnect();
        } catch (error) {
            Debug.error(error);
        }
        BU.progressLayer.hide();
        statusBarTerminal.addValue(`==${Msg.Lang['shell.burnFailed']}==\n`);
        return;
    }
    statusBarTerminal.addValue("Done!\n");
    BU.burning = true;
    BU.uploading = false;
    const flashOptions = {
        fileArray: data,
        flashSize: 'keep',
        eraseAll: erase,
        compress: true,
        calculateMD5Hash: (image) => CryptoJS.MD5(CryptoJS.enc.Latin1.parse(image))
    };
    try {
        await esploader.writeFlash(flashOptions);
        await transport.setDTR(false);
        await new Promise((resolve) => setTimeout(resolve, 100));
        await transport.setDTR(true);
        BU.progressLayer.hide();
        layer.msg(Msg.Lang['shell.burnSucc'], { time: 1000 });
        statusBarTerminal.addValue(`==${Msg.Lang['shell.burnSucc']}==\n`);
    } catch (error) {
        Debug.error(error);
        BU.progressLayer.hide();
        statusBarTerminal.addValue(`==${Msg.Lang['shell.burnFailed']}==\n`);
    } finally {
        try {
            await transport.disconnect();
        } catch (error) {
            Debug.error(error);
        }
    }
}

BU.burnWithKFlash = async (binFile, erase) => {
    const { mainStatusBarTabs } = Mixly;
    let portName = Serial.getSelectedPortName();
    if (!portName) {
        try {
            await BU.requestPort();
            portName = Serial.getSelectedPortName();
            if (!portName) {
                return;
            }
        } catch (error) {
            Debug.error(error);
            return;
        }
    }
    const port = Serial.getPort(portName);
    if (['HIDDevice', 'USBDevice'].includes(port.constructor.name)) {
        layer.msg(Msg.Lang['burn.notSupport'], { time: 1000 });
        return;
    }
    const statusBarSerial = mainStatusBarTabs.getStatusBarById(portName);
    if (statusBarSerial) {
        await statusBarSerial.close();
    }
    const statusBarTerminal = mainStatusBarTabs.getStatusBarById('output');
    statusBarTerminal.setValue(Msg.Lang['shell.burning'] + '...\n');
    mainStatusBarTabs.show();
    mainStatusBarTabs.changeTo('output');
    BU.progressLayer.title(`${Msg.Lang['shell.burning']}...`);
    BU.progressLayer.show();

    let data = [];
    try {
        for (let i of binFile) {
            if (i.path && i.offset) {
                const extname = path.extname(i.path);
                const absolutePath = path.join(Env.boardDirPath, i.path);
                const info = await readBinFileAsArrayBuffer(absolutePath, i.offset);
                if (extname === '.kfpkg') {
                    const result = await decodeKfpkgFromArrayBuffer(info.data);
                    data.push(...result.items);
                } else {
                    data.push(info);
                }
            }
        }
    } catch (error) {
        statusBarTerminal.addValue(`\n[ERROR] ${error}\n`, true);
        BU.progressLayer.hide();
        statusBarTerminal.addValue(`==${Msg.Lang['shell.burnFailed']}==\n`);
        return;
    }
    let serial = null;
    try {
        serial = new Serial(portName);
        const kflash = new KFlash(serial);
        kflash.bind('message', (message) => {
            statusBarTerminal.addValue(message);
        });
        kflash.bind('replaceMessage', (lineNumber, message) => {
            statusBarTerminal.replaceLine(lineNumber, message);
        });
        await kflash.enter();
        for (let item of data) {
            await kflash.write(item.data, item.address, item.sha256Prefix ?? true, item?.filename ?? 'main.bin');
        }
        BU.progressLayer.hide();
        layer.msg(Msg.Lang['shell.burnSucc'], { time: 1000 });
        statusBarTerminal.appendLine(`==${Msg.Lang['shell.burnSucc']}==\n`);
    } catch (error) {
        statusBarTerminal.appendLine(`[ERROR] ${error.message}\n`);
        BU.progressLayer.hide();
        statusBarTerminal.appendLine(`==${Msg.Lang['shell.burnFailed']}==\n`);
    } finally {
        try {
            serial && await serial.close();
        } catch (error) {
            Debug.error(error);
        }
    }
}

BU.getImportModulesName = (code) => {
    // 正则表达式: 匹配 import 或 from 导入语句
    const importRegex = /(?:import\s+([a-zA-Z0-9_]+)|from\s+([a-zA-Z0-9_]+)\s+import)/g;

    let imports = [];
    let match;
    while ((match = importRegex.exec(code)) !== null) {
        if (match[1]) {
            imports.push(match[1]); // 'import module'
        }
        if (match[2]) {
            imports.push(match[2]); // 'from module import ...'
        }
    }
    return imports;
}

BU.getImportModules = (code) => {
    let importsMap = {};
    const libPath = SELECTED_BOARD.upload.libPath;
    for (let i = libPath.length - 1; i >= 0; i--) {
        const dirname = MString.tpl(libPath[i], { indexPath: Env.boardDirPath });
        const map = goog.readJsonSync(path.join(dirname, 'map.json'));
        if (!(map && map instanceof Object)) {
            continue;
        }
        for (let key in map) {
            importsMap[key] = structuredClone(map[key]);
            importsMap[key]['__path__'] = path.join(dirname, map[key]['__name__']);
        }
    }

    let usedMap = {};
    let currentImports = BU.getImportModulesName(code);
    while (currentImports.length) {
        let temp = [];
        for (let moduleName of currentImports) {
            let moduleInfo = importsMap[moduleName];
            if (!moduleInfo) {
                continue;
            }
            usedMap[moduleName] = moduleInfo;
            const moduleImports = moduleInfo['__require__'];
            if (!moduleImports) {
                continue;
            }
            for (let name of moduleImports) {
                if (usedMap[name] || !importsMap[name] || temp.includes(name)) {
                    continue;
                }
                temp.push(name);
            }
        }
        currentImports = temp;
    }
    return usedMap;
}

BU.initUpload = async () => {
    let portName = Serial.getSelectedPortName();
    if (!portName) {
        try {
            await BU.requestPort();
            portName = Serial.getSelectedPortName();
            if (!portName) {
                return;
            }
        } catch (error) {
            Debug.error(error);
            return;
        }
    }
    if (['BBC micro:bit', 'Mithon CC'].includes(BOARD.boardType)) {
        await BU.uploadWithDAP(portName);
    } else {
        await BU.uploadWithAmpy(portName);
    }
}

BU.uploadWithDAP = async (portName) => {
    const { mainStatusBarTabs } = Mixly;
    if (!portName) {
        try {
            await BU.requestPort();
            portName = Serial.getSelectedPortName();
            if (!portName) {
                return;
            }
        } catch (error) {
            Debug.error(error);
            return;
        }
    }
    let statusBarSerial = mainStatusBarTabs.getStatusBarById(portName);
    if (statusBarSerial) {
        await statusBarSerial.close();
    }

    const port = Serial.getPort(portName);
    const statusBarTerminal = mainStatusBarTabs.getStatusBarById('output');
    const dapWrapper = new DAPWrapper(port, {
        event: () => {},
        log: () => {}
    });
    const partialFlashing = new PartialFlashing(dapWrapper, {
        event: () => {}
    });

    let boardId = 0x9901;
    const boardKey = Boards.getSelectedBoardKey();
    if (boardKey === 'micropython:nrf51822:v2') {
        boardId = 0x9903;
    }

    BU.burning = false;
    BU.uploading = true;
    statusBarTerminal.setValue(Msg.Lang['shell.uploading'] + '...\n');
    mainStatusBarTabs.show();
    mainStatusBarTabs.changeTo('output');
    const mainWorkspace = Workspace.getMain();
    const editor = mainWorkspace.getEditorsManager().getActive();
    const code = editor.getCode();
    FSWrapper.writeFile('main.py', code);
    const importsMap = BU.getImportModules(code);
    for (let key in importsMap) {
        const filename = importsMap[key]['__name__'];
        const data = goog.readFileSync(importsMap[key]['__path__']);
        FSWrapper.writeFile(filename, data);
    }
    BU.progressLayer.title(`${Msg.Lang['shell.uploading']}...`);
    BU.progressLayer.show();
    try {
        let prevPercent = 0;
        await partialFlashing.flashAsync(new BoardId(0x9900), FSWrapper, progress => {
            const nowPercent = Math.floor(progress * 100);
            if (nowPercent > prevPercent) {
                prevPercent = nowPercent;
            } else {
                return;
            }
            const nowProgressLen = Math.floor(nowPercent / 2);
            const leftStr = new Array(nowProgressLen).fill('=').join('');
            const rightStr = (new Array(50 - nowProgressLen).fill('-')).join('');
            statusBarTerminal.addValue(`[${leftStr}${rightStr}] ${nowPercent}%\n`);
        });
        BU.progressLayer.hide();
        layer.msg(Msg.Lang['shell.uploadSucc'], { time: 1000 });
        statusBarTerminal.addValue(`==${Msg.Lang['shell.uploadSucc']}==\n`);
        if (!statusBarSerial) {
            mainStatusBarTabs.add('serial', portName);
            statusBarSerial = mainStatusBarTabs.getStatusBarById(portName);
        }
        statusBarSerial.setValue('');
        mainStatusBarTabs.changeTo(portName);
        await statusBarSerial.open();
    } catch (error) {
        await dapWrapper.disconnectAsync();
        Debug.error(error);
        BU.progressLayer.hide();
        statusBarTerminal.addValue(`${error}\n`);
        statusBarTerminal.addValue(`==${Msg.Lang['shell.uploadFailed']}==\n`);
    }
}

BU.uploadWithAmpy = async (portName) => {
    const { mainStatusBarTabs } = Mixly;
    const statusBarTerminal = mainStatusBarTabs.getStatusBarById('output');
    let statusBarSerial = mainStatusBarTabs.getStatusBarById(portName);
    BU.burning = false;
    BU.uploading = true;
    statusBarTerminal.setValue(`${Msg.Lang['shell.uploading']}...\n`);
    mainStatusBarTabs.show();
    mainStatusBarTabs.changeTo('output');
    const mainWorkspace = Workspace.getMain();
    const editor = mainWorkspace.getEditorsManager().getActive();
    const port = Serial.getPort(portName);
    BU.progressLayer.title(`${Msg.Lang['shell.uploading']}...`);
    BU.progressLayer.show();
    const serial = new Serial(portName);
    const ampy = new Ampy(serial);
    ampy.bind('message', (message) => {
        statusBarTerminal.addValue(message);
    });
    ampy.bind('replaceMessage', (lineNumber, message) => {
        statusBarTerminal.replaceLine(lineNumber, message);
    });
    const code = editor.getCode();
    let closePromise = Promise.resolve();
    if (statusBarSerial) {
        closePromise = statusBarSerial.close();
    }
    try {
        await closePromise;
        await ampy.enter();
        await ampy.put('main.py', code);
        /*const importsMap = BU.getImportModules(code);
        let libraries = {};
        for (let key in importsMap) {
            const filename = importsMap[key]['__name__'];
            const data = goog.readFileSync(importsMap[key]['__path__']);
            libraries[filename] = {
                data,
                size: importsMap[key]['__size__']
            };
        }
        let cwd = await ampy.cwd();
        const rootInfo = await ampy.ls(cwd);
        let rootMap = {};
        for (let item of rootInfo) {
            rootMap[item[0]] = item[1];
        }
        if (cwd === '/') {
            cwd = '';
        }
        if (libraries && libraries instanceof Object) {
            for (let key in libraries) {
                if (rootMap[`${cwd}/${key}`] !== undefined && rootMap[`${cwd}/${key}`] === libraries[key].size) {
                    statusBarTerminal.addValue(`Writing ${key} (Skipped)\n`);
                    continue;
                }
                await ampy.put(key, libraries[key].data);
            }
        }*/
        await ampy.exit();
        await ampy.dispose();
        BU.progressLayer.hide();
        layer.msg(Msg.Lang['shell.uploadSucc'], { time: 1000 });
        statusBarTerminal.appendLine(`==${Msg.Lang['shell.uploadSucc']}==\n`);
        if (!statusBarSerial) {
            mainStatusBarTabs.add('serial', portName);
            statusBarSerial = mainStatusBarTabs.getStatusBarById(portName);
        }
        statusBarSerial.setValue('');
        mainStatusBarTabs.changeTo(portName);
        await statusBarSerial.open();
    } catch (error) {
        ampy.dispose();
        BU.progressLayer.hide();
        Debug.error(error);
        statusBarTerminal.appendLine(`[ERROR] ${error.message}\n`);
        statusBarTerminal.appendLine(`==${Msg.Lang['shell.uploadFailed']}==\n`);
    }
}

/**
 * @function 特殊固件的烧录
 * @return {void}
 **/
BU.burnWithSpecialBin = () => {
    const { mainStatusBarTabs } = Mixly;
    const statusBarTerminal = mainStatusBarTabs.getStatusBarById('output');
    const firmwares = SELECTED_BOARD.web.burn.special;
    let menu = [];
    let firmwareMap = {};
    for (let firmware of firmwares) {
        if (!firmware?.name && !firmware?.binFile) continue;
        menu.push({
            id: firmware.name,
            text: firmware.name
        });
        firmwareMap[firmware.name] = firmware.binFile;
    }
    BU.firmwareLayer.setMap(firmwareMap);
    BU.firmwareLayer.setMenu(menu);
    BU.firmwareLayer.show();
}

});