!(function (e, t) {
    "object" == typeof exports && "undefined" != typeof module
        ? (module.exports = t(e))
        : "function" == typeof define && define.amd
            ? define(t, e)
            : ((e = "undefined" != typeof globalThis ? globalThis : e || self).http =
                t(e));
})(this,
    function (scope) {
        if (!scope.axios) {
            scope.require("/libs/axios/1.7.2/axios.min.js");
        }
        if (!scope.settings) {
            scope.require("/settings.js");
        }
        const _original = axios;
        const getToken = () => {
            return localStorage.getItem("token");
        }
        const _axios = _original.create({
            baseURL: settings.API_BASE, // url = base url + request url
            // withCredentials: true, // send cookies when cross-domain requests
            timeout: 1000 * 60 * 60 // request timeout
        })
        // request interceptor
        _axios.interceptors.request.use(
            config => {
                config.headers['Authorization'] = getToken();
                return config
            },
            error => {
                return Promise.reject(error)
            }
        )
        var absoluteUrlRegex = /^(http(s?):)?\/\//;
        _axios.download = function ({ url, fileName, validFileSize, params, row }) {
            if (!absoluteUrlRegex.test(url)) {
                if (url[0] == "/") url = url.substring(1);
                url = _axios.defaults.baseURL + url;
            }
            var target = new URL(url);
            Object.entries(params).forEach(([key, value]) => {
                target.searchParams.append(key, value)
            })
            Promise.resolve(0)
                .then(() => {
                    //第一下载xml
                    return generateXml();
                })
                .then(() => {
                    /// 第二下载dat
                    var downloadIFramesrc = target.toString();
                    return downloadFile(downloadIFramesrc, fileName, validFileSize, row);
                }).catch((error) => {
                    console.log(error.Message);
                })
            async function generateXml() {
                return new Promise((resolve) => {
                    const xmlData = createXml();
                    downloadXml(xmlData).then(() => {
                        resolve();
                    });
                })
            }
            function createXml() {
                let _iq = 'I';
                let _ptnSize = 2;
                let _FerdPnt = null;
                let _type = row.dataType;
                if (row.dataType == 1) {
                    _iq = 'IQ';
                    _ptnSize = 4;
                    _FerdPnt = 61440000;
                };
                if (row.dataType == 3) {
                    _FerdPnt = 32768;
                };
                if (row.dataType == 5) {
                    _FerdPnt = 26624;
                    _type = 4;
                };
                if (row.dataType == 6) {
                    _FerdPnt = 61440000;
                };
                const xmlString = `<?xml version='1.0' encoding='UTF-8'?>
                    <FileInfo>
                    <DevCode>07G1B1DBWB0001</DevCode >
                    <DataType>${_iq}</DataType >
                    <FileType>dat</FileType>
                    <StartTime>${formattedTime(row.taskTimeCreate)}</StartTime >
                    <EndTime>${formattedTime(row.taskTimeEnd)}</EndTime >
                    <FileID>${row.fileId}</FileID >
                    <FileName>${fileName.replace(".dat", "")}</FileName >
                    <DataClas>${_type}</DataClas>
                    <PntSize>${_ptnSize}</PntSize>
                    <Channel>1</Channel >
                    <CentFreq>${row.centerFreqHz}</CentFreq>
                    <SampFreq>${row.sampleFreqHz}</SampFreq>
                    <BandWid>${row.bandWidthHz}</BandWid>
                    <DataTime>${formateTimer(row)}</DataTime>
                    <FerdPnt>${_FerdPnt}</FerdPnt>
                    <FileSize>${row.validFileSize}</FileSize>
                    <FileNote>${row.remark}</FileNote>
                    </FileInfo >`
                return xmlString
            }
            function downloadXml(xml) {
                return new Promise((resolve) => {
                    const blob = new Blob([xml], { type: "text/xml" });
                    const link = document.createElement('a');
                    const url = window.URL.createObjectURL(blob);
                    link.href = url;
                    let newfilename = fileName.replace(/\.(txt|dat)/g, '');
                    link.download = newfilename + ".xml";
                    link.style.display = 'none';
                    document.body.appendChild(link);
                    link.addEventListener('click', () => {
                        setTimeout(() => {
                            document.body.removeChild(link);
                            window.URL.revokeObjectURL(url);
                            resolve();
                        }, 3000)
                    })
                    link.click();
                })
            }
            function toDate(_num, length) {
                let str = _num.toString();
                return str.length > length ? str.slice(0, length) : str.padStart(length, '0');
            }
            function formattedTime(_rowtime) {
                const date = new Date(_rowtime * 1000 - 8 * 3600 * 1000)
                const formattime = date.toLocaleString('zh-CN', {
                    year: "numeric",
                    month: '2-digit',
                    day: '2-digit',
                    hour: '2-digit',
                    minute: '2-digit',
                    second: '2-digit',
                    hour12: false
                });
                return formattime
            }
            function formateTimer(row) {
                let year = '20' + toDate(row.mapSataInfo.year, 2);
                let m = toDate(row.mapSataInfo.month, 2);
                let day = toDate(row.mapSataInfo.day, 2);
                let hour = toDate(row.mapSataInfo.hour, 2);
                let minute = toDate(row.mapSataInfo.minute, 2);
                let second = toDate(row.mapSataInfo.second, 2);
                let nanoSec = toDate(row.mapSataInfo.nanoSec, 9);
                let _time = year + m
                    + day + hour + minute + second + '.' + nanoSec;
                return _time
            }
        };
        async function downloadFile(url, filename, validFileSize, row) {
            const response = await fetch(url, { method: 'GET' });
            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            };
            let loaded = 0;
            let speedSum = 0;
            let timerId = null;
            //  设置初始状态
            vm.fileManager.storage.downloadSwitch = true;
            vm.fileManager.storage.speed = 0;
            vm.fileManager.storage.percentage = 0;
            vm.fileManager.storage.isfullfill = '正在下载';
            const reader = response.body.getReader();
            const stream = new ReadableStream({
                start(controller) {
                    async function push() {
                        const { done, value } = await reader.read();
                        if (done) {
                            controller.close();
                            clearInterval(timerId);
                            vm.fileManager.storage.isfullfill = "下载完成";
                            setTimeout(() => {
                                vm.onWorkSwitch(true);//打开开关
                                vm.currentDownload = null;
                                vm.fileManager.storage.downloadSwitch = false;
                            }, 1000);
                            return;
                        };
                        loaded += value.byteLength;
                        speedSum += value.byteLength;
                        controller.enqueue(value);
                        push();
                    };
                    push();
                    timerId = setInterval(() => {
                        //取消下载事件
                        if (vm.currentDownload == null) {
                            if (controller) {
                                controller.close();
                                clearInterval(timerId);
                                // 关闭可写流
                                setTimeout(() => {
                                    vm.onWorkSwitch(true);//打开开关
                                    vm.currentDownload = null;
                                    vm.fileManager.storage.downloadSwitch = false;
                                }, 500);
                                return;
                            }
                        };
                        //进度条以及下载速度更新
                        vm.fileManager.storage.speed = speedSum / 2;
                        speedSum = 0;
                        // 计算下载进度
                        vm.fileManager.storage.percentage = ((loaded / validFileSize) * 100).toFixed(2);

                    }, 1000)
                }
            });
            const blob = await new Response(stream).blob();
            const downloadUrl = window.URL.createObjectURL(blob);
            const anchor = document.createElement('a');
            anchor.href = downloadUrl;
            anchor.download = filename;
            document.body.appendChild(anchor);
            anchor.click();
            document.body.removeChild(anchor);
            window.URL.revokeObjectURL(downloadUrl);
        }
        _axios.sync = function (opts) {
            let { url, method, data } = opts;
            if (url.indexOf("http://") == -1) {
                if (url[0] == "/") url = url.substring(1);
                url = settings.API_BASE + url;
            }
            var xhr = new XMLHttpRequest();
            xhr.open(method, url, false);
            xhr.setRequestHeader("Content-type", "application/json;charset=utf-8");
            xhr.send(data);
            var response = JSON.parse(xhr.responseText);
            return response;
        }
        _axios.interceptors.response.use(
            response => {
                const res = response.data
                const statusCode = res.code || res.Code || response.status;
                if (statusCode !== 200) {
                    const message = res.message || res.Message;

                    false && console.log({
                        message: message || 'Error',
                        type: 'error',
                        duration: 5 * 1000
                    });
                    return Promise.reject(new Error(message || 'Error'))
                } else {
                    return res
                }
            },
            error => {
                false && console.log({
                    message: error.message,
                    type: 'error',
                    duration: 5 * 1000
                })
                return Promise.reject(error)
            }
        )

        _axios.socket = (function () {
            const core = function () {
                function SocketWorker(url, token) {
                    var _ctx = this.$ctx = { state: null };
                    this.socket = new WebSocket(url);
                    this.socket.onopen = function () {
                        postMessage({ "name": "onopen", "payload": null }, []);
                    }
                    this.socket.onclose = function (args) {
                        let { code, reason, type, target } = args;
                        let { url } = target;
                        postMessage({ "name": "onclose", "payload": { code, reason, type, url } });
                    }
                    this.socket.onerror = function () {
                        postMessage({ "name": "onerror", "payload": null });
                    }
                    this.socket.onmessage = function (e) {
                        if (e.data.size < 32) return;
                        e.data.arrayBuffer().then(function (buffer) {
                            postMessage({ "name": "onmessage", "payload": buffer }, [buffer]);
                        });
                    }
                }
                SocketWorker.prototype.state = function (state) {
                    this.$ctx.state = state;
                }
                SocketWorker.prototype.close = function () {
                    if (this.socket) this.socket.close();
                }
                SocketWorker.prototype.postMessage = function () {
                    this.socket.postMessage(...arguments);
                }
                let _websocket;
                addEventListener('message', function (e) {
                    let { name, payload } = e.data;
                    switch (name) {
                        case "create":
                            let { url, token, state } = payload;
                            _websocket = new SocketWorker(url, token);
                            break;
                        case "close":
                            _websocket?.close();
                            break;
                        default:
                            _websocket?.postMessage(e.data);
                        //?.取属性同时判断该属性是否存在
                    }
                });
            };
            var blob = new Blob([`(${core})()`]);
            var workurl = URL.createObjectURL(blob);
            const create = (function (opts) {
                let { url, callback, state } = opts;
                if (url.indexOf("ws://") == -1) {
                    if (url[0] == "/") url = url.substring(1);
                    url = settings.WEBSOCKET_BASE + url;
                };
                var worker = new Worker(workurl);
                URL.revokeObjectURL(workurl);
                var receive = function (e) {
                    const { name, payload } = e.data;
                    handles.forEach(handle => handle(name, payload))
                };
                var handles = new Set();
                if (callback) handles.add(callback);
                // worker.addEventListener('message', receive);
                worker.addEventListener('message', (e) => {
                    try {
                        const { name, payload } = e.data;
                        handles.forEach(handle => handle(name, payload))
                    } catch (error) {
                        console.log(error);
                    }
                })
                worker.addEventListener("error", (e) => {
                    console.error("worker发生错误", e.message, e.filename, e.lineno);
                })
                url = new URL(url);
                url.searchParams.append("token", getToken());
                worker.postMessage({ name: "create", payload: { url: url.href, state } });
                return {
                    onmessage(handle) {
                        handles.add(handle);
                    },
                    postMessage() {
                        worker.postMessage(...arguments);
                    },
                    close() {
                        worker.postMessage({ name: "close" });
                    }
                }
            });
            return create
        })();
        return _axios;
    }
);