/// <reference path="echarts.js" />

const visTabCols = ['时间', '酒店名', '房间号', 'Mac地址', '主机编号', '内网IP', '外网IP', '外网Port', '间隔', '方向', '日志', '帧号', '命令',];
var app = new Vue({
    el: '#app',
    data() {

        return {
            testData: [

            ],
            isReady: false, // 页面加载状态
            tableHeight: '0',
            loading: null, // 加载flash
            openDialog: false, // 打开弹窗
            dialogw: '100%', // 弹窗宽度
            multipleSelection: [], // 选出的房间
            pickerOptions: {
                shortcuts: [{
                    text: '最近1天',
                    onClick(picker) {
                        const end = new Date();
                        const start = new Date();
                        //start.setTime(start.getTime() - 3600 * 1000 * 24);
                        picker.$emit('pick', [start, end]);
                    }
                },
                {
                    text: '最近3天',
                    onClick(picker) {
                        const end = new Date();
                        const start = new Date();
                        start.setTime(start.getTime() - 3600 * 1000 * 24 * 2);
                        picker.$emit('pick', [start, end]);
                    }
                },
                {
                    text: '最近7天',
                    onClick(picker) {
                        const end = new Date();
                        const start = new Date();
                        start.setTime(start.getTime() - 3600 * 1000 * 24 * 6);
                        picker.$emit('pick', [start, end]);
                    }
                },
                {
                    text: '全部',
                    onClick(picker) {
                        picker.$emit('pick', ['', '']);
                    }
                }]
            }, // 日期选择器
            allHotel: [], // 所有酒店列表
            hotels: [], // 酒店列表
            isTheRoomGet: false, // 是否获取了房间列表
            allRoom: [], // 所有房间列表
            rooms: [], // 房间列表
            pickerDate: [new Date(), new Date()], // 选择的日期范围
            logs: null, // 日志列表
            allLogs: null, // 初始日志列表
            roomDisable: true, // 房间选择框是否可选
            multipleBtn: true, // 批量查询或者批量删除按钮是否可用
            btnIntoDisable: true, // 加入监控按钮是否可选
            CreatDataTable: [
                hotel = [],
                room = [],
            ], // 筛选表
            visTabCol: ['时间', '日志', '方向', '间隔', '帧号', '命令'], // 设置默认表头
            //visTabCol: visTabCols, // 默认表头(全选测试)
            tabCols: visTabCols, // 表头筛选框
            checkAll: true, // 是否全选
            isIndeterminate: true, // 是否半选
            displayCheck: false, // 是否显示筛选框
            pageSize: 50, // 每页条数
            currentPage: 1, // 初始前往页
            allPageNum: 0, // 总条数
            cmdList: [], // 命令列表
            allCmdList: [], // 命令列表
            cmdCurrent: null, // 选中的命令
            mobileSelectedVis: true, // 移动设备搜索框下拉适配
            echartVis: false, // 是否显示图表
            stateVis: false, // 当前是否显示状态表
            states: null, // 状态列表
            logAnalysisList: [], // 日志分析列表
            resultCurrent: ['0', '1'], // 当前选中的日志分析
            checkUUID: false, // UUID是否去重
            drawerPic: false, // 是否显示抽屉
        };
    },
    watch: {
        multipleSelection: {
            handler: function (newVal, oldVal) {
                if (newVal.length > 0) {
                    this.multipleBtn = false;
                } else {
                    this.multipleBtn = true;
                }
            }
        },
        checkUUID: {
            handler: function (newVal, oldVal) {
                if (newVal) {
                    this.removeDuplicateUUIDs();
                } else if (this.logs.length > 0) {
                    this.logs = JSON.parse(JSON.stringify(this.allLogs));
                }
            }
        },
        logs: {
            handler: function (newVal, oldVal) {
                if (newVal.length > 0) {
                    this.allPageNum = newVal.length;
                }
            }
        },
    },
    methods: {
        logHome() {
            window.location.href = "/Home/Index";
        },
        refreshViewValue() { // 刷新页面数据
            if (this.isReady) {
                this.$message({
                    message: '刷新成功，重新加载中…',
                    type: 'success'
                });
            }

        },
        handleDelayed(row) { // 重置监控剩余时间
            let arr = [row];
            this.addOrRemoveSub(JSON.stringify(arr), "add");
        },
        handleRemove(row) { // 移除对象
            let arr = [row];
            this.addOrRemoveSub(JSON.stringify(arr), "remove");
        },
        showProdTestInfo() {
            var _this = this;
            $.ajax({
                url: '/api/Productionline/ProductionlineTestInfo',
                type: 'POST',
                contentType: 'application/x-www-form-urlencoded',
                data: {},
                success: function (res) {
                    //console.log(res);
                    //return;
                    if (res.isok) {
                        let cmds = []
                        _this.cmdList = res.response.map(function (item) {
                            return {
                                // 保持原有的属性...
                                ...item,
                                label: item.value
                            };
                        }).sort(function (a, b) {
                            return a.value.localeCompare(b.value, 'zh-CN');
                        });
                        res.response.map((item) => {
                            cmds.push(item.value);
                        })
                        _this.cmdCurrent = cmds.sort((a, b) => a.localeCompare(b, 'zh-CN'));
                        _this.allCmdList = JSON.parse(JSON.stringify(_this.cmdCurrent));

                        //console.log(cmds);
                    } else {
                        _this.$message.error(res.message + '！');
                    }
                    app.loading.close();
                    app.isReady = true;
                },
                error: function (error) {
                    _this.$message.error('失败，请稍后再试');
                    app.loading.close();
                    app.isReady = true;
                }
            });
        },
        showSelectedLogs(type) { // 显示日志
            if (this.cmdCurrent.length == 0) {
                this.$message.error('请选择测试信息！');
                return;
            }
            if (this.resultCurrent.length == 0) {
                this.$message.error('请选择测试结果！');
                return;
            }
            if (this.echartVis) {
                this.echartShow();
            }
            if (type == 1) { this.currentPage = 1 }
            this.logs = [];
            this.checkUUID = false;
            //console.log(this.cmdCurrent);
            var _this = this;
            let getdata = {
                testrange_start: !this.pickerDate[0] ? "2000-01-01 00:00:00" : this.formatDate(this.pickerDate[0], true),
                testrange_end: !this.pickerDate[0] ? "2099-01-01 00:00:00" : this.formatDate(this.pickerDate[1], false),
                testresult: this.resultCurrent.length >= 2 ? '' : this.resultCurrent[0],
                testinfo: this.cmdCurrent,
            };
            this.LoadingPic();
            $.ajax({
                url: '/api/Productionline/ProductionlineSelect',
                type: 'POST',
                contentType: 'application/json',
                data: JSON.stringify(getdata),
                success: function (res) {
                    console.log(res);
                    //return;
                    if (res.isok) {
                        _this.logs = res.response.sort((a, b) => {
                            const dateA = new Date(a.TestTime);
                            const dateB = new Date(b.TestTime);
                            return dateB - dateA;
                        });
                        _this.allLogs = JSON.parse(JSON.stringify(_this.logs));
                        _this.loading.close();

                        _this.$message({
                            message: '操作成功！',
                            type: 'success'
                        });
                        _this.openDialog = false;

                    } else {
                        _this.$message.error(res.message + '！');
                        app.loading.close();
                    }
                },
                error: function (error) {
                    _this.$message.error('失败，请稍后再试');
                    app.loading.close();
                }
            });

        },
        removeDuplicateUUIDs() { // 去重   UUID
            // 首先根据 UUID 相同且 TestTime 降序排序
            let lgs = JSON.parse(JSON.stringify(this.logs));
            console.log(lgs)
            lgs.sort((a, b) => {
                if (a.UUID === b.UUID) {
                    // 如果 UUID 相同，则根据 TestTime 降序排序
                    return new Date(b.TestTime) - new Date(a.TestTime);
                }
                // 否则，保持原顺序（这里假设 UUID 本身是有序的，或者不需要按 UUID 排序）
                return 0;
            });

            // 用于存储最终结果的数组
            const uniqueLogs = [];
            // 用于跟踪已处理 UUID 的对象
            const seenUUIDs = {};

            // 遍历排序后的数组，只保留每个 UUID 的最新记录
            lgs.forEach(log => {
                if (!seenUUIDs[log.UUID] || log.UUID == "") {
                    // 如果这个 UUID 还没被处理过，添加到结果数组
                    uniqueLogs.push(log);
                    // 标记这个 UUID 为已处理
                    if (log.UUID != "") {
                        seenUUIDs[log.UUID] = true;
                    }
                }
            });

            // 返回处理后的数组
            //return
            console.log(uniqueLogs)
            this.logs = uniqueLogs;
        },
        handleCheckAllChange(val) { // 是否全选
            this.visTabCol = val ? visTabCols : [];
            this.isIndeterminate = false;
        },
        remoteCmd(query) { // 搜索cmdlist
            //console.log(query);
            if (query != "") {
                this.cmdList = [];
                const nc = this.allCmdList.filter(item => item.value.includes(query));
                //console.log(nc);
                if (nc.length > 0) {
                    this.cmdList = nc;
                } else {
                    this.cmdList = JSON.parse(JSON.stringify(this.allCmdList));
                }

            } else {
                this.cmdList = JSON.parse(JSON.stringify(this.allCmdList));
            }

        },
        allInfoBtn() { // 全选所有
            //console.log(this.allCmdList);
            this.resultCurrent = ['0', '1'];
        },
        allCmdBtn() { // 全选所有CMD
            //console.log(this.allCmdList);
            this.cmdCurrent = [];
            this.cmdCurrent = JSON.parse(JSON.stringify(this.allCmdList));
        },
        filterHandler(value, row, column) { // 筛选
            //console.log(value, row, column);
            const property = column['property'];
            return row[property] === value;
        },
        filterHandlerMobile(value, row, column) { // 筛选(移动端)
            //console.log(value, row, column);
            return row.hotelNameAndCode == value;
        },
        cmdFilterChange(key, value) { // cmd筛选
            //console.log(key, value);

        },
        dateMobile(date) { // 手机端日期选择
            if (date == 0) {
                this.pickerDate = ['', '']
                return
            }
            const end = new Date();
            const start = new Date();
            start.setTime(start.getTime() - 3600 * 1000 * 24 * date);
            this.pickerDate = [start, end];
            //picker.$emit('pick', [start, end]);
        },
        saveObjectToLocalStorage(key, object) { // 保存对象到localStorage
            // 从localStorage获取旧的数组
            const oldArrayString = localStorage.getItem(key);
            let oldArray;

            // 检查是否已经有旧的数组存在
            if (oldArrayString) {
                // 如果存在，则解析为对象数组
                oldArray = JSON.parse(oldArrayString);
            } else {
                // 如果不存在，初始化为空数组
                oldArray = [];
            }

            // 添加新对象到数组
            oldArray.push(object);
            const uniqueArray = this.removeDuplicatesById(oldArray);
            // 将更新后的数组转换回字符串并保存到localStorage
            localStorage.setItem(key, JSON.stringify(uniqueArray));
        },
        visibleChangeHotel(e) {
            if (e) {
                this.hotels = JSON.parse(localStorage.getItem('hotels'));
            } else {
                this.hotels = [];
            }
        },
        paginate(data, pageNumber, pageSize) { // 分页函数
            // 计算起始索引
            const startIndex = (pageNumber - 1) * pageSize;
            // 截取当前页的数据
            const paginatedData = data.slice(startIndex, startIndex + pageSize);
            // 返回当前页的数据
            return paginatedData;
        },
        handleSizeChange(val) { // 每页显示条数变化时触发
            this.pageSize = val;
            this.showSelectedLogs(0);
            //console.log(`每页 ${val} 条`);
        },
        handleCurrentChange(val) { // 当前页变化时触发
            //console.log(`当前页: ${val}`);
            this.currentPage = val;
            this.showSelectedLogs(0);
        },
        formatDate(date, se) { // 格式化日期, se为true时返回开始时间，false时返回结束时间
            const y = date.getFullYear();
            const M = (date.getMonth() + 1).toString().padStart(2, '0');
            const d = date.getDate().toString().padStart(2, '0');
            if (se) {
                return `${y}-${M}-${d} 00:00:00`;
            } else {
                return `${y}-${M}-${d} 23:59:59`;
            }

        },
        LoadingPic() { // 加载时遮罩层
            this.loading = this.$loading({
                lock: true,
                text: '加载中...',
                spinner: 'el-icon-loading',
                background: 'rgba(255, 255, 255, 1)'
            });
        },
        getCharsFromString(str, x, y) { // 截取data字符串
            x = x * 2;
            y = y * 2;
            // 移除所有空格
            const stringWithoutSpaces = str.replace(/\s+/g, '');
            // 截取指定数量的字符
            const extractedChars = stringWithoutSpaces.substring(x, x + y);
            // 将提取的字符按照原始字符串中的空格重新格式化
            const formattedChars = extractedChars.match(/.{1,2}/g).join(' ');
            return formattedChars;
        },
        removeDuplicatesById(array) { // 根据id去重
            //console.log(array);
            const uniqueArray = array.reduce((acc, current) => {
                // 检查累加器数组中是否已经存在具有相同id的对象
                const exists = acc.some(item => item.id === current.id);
                // 如果不存在，则添加到累加器数组中
                if (!exists) {
                    acc.push(current);
                }
                return acc;
            }, []);
            return uniqueArray.sort((a, b) => a.id - b.id);;
        },
        timeDifference(targetTimeStr) { // 计算时间差
            // 获取当前时间
            const currentTime = new Date();
            // 计算当前时间前推30天的时间
            const time30DaysAgo = new Date(currentTime);
            time30DaysAgo.setDate(currentTime.getDate() - 30);

            // 将目标时间字符串转换为Date对象
            const targetTime = new Date(targetTimeStr);

            // 计算时间差（以毫秒为单位）
            const differenceInMilliseconds = targetTime - time30DaysAgo;

            // 将时间差转换为天数
            const days = Math.floor(differenceInMilliseconds / (1000 * 60 * 60 * 24));
            // 将剩余的毫秒数转换为小时数
            const hours = Math.floor((differenceInMilliseconds % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));

            // 返回格式化的字符串
            return `${days}天${hours}小时`;
        },
        showPic() { // 显示统计图
            this.drawerPic = true;
        },
    },
    created: function () { // 页面创建时执行

    },
    mounted: function () {
        this.LoadingPic();
        this.showProdTestInfo();

    },
    beforeDestroy: function () {

    },
});

// 页面加载时
window.onload = function () {
    AdjustWindow();
};

function AdjustWindow() { /* 调整窗口大小 */
    return
    // 监听窗口大小变化事件
    if (window.innerWidth <= 888) {
        app.dialogw = "100%";
        document.getElementById('appleft').style.width = '100%';
        app.tableHeight = window.innerHeight - 10;
    } else {
        app.dialogw = "70%";
        document.getElementById('appleft').style.width = '50%';
        app.tableHeight = window.innerHeight - 177;
    }



}




window.addEventListener('resize', function () { AdjustWindow() });

function generateHourlyIntervals(startDateStr, endDateStr) { /* 生成小时区间 */
    // 将日期字符串转换为Date对象
    const d1 = new Date(startDateStr);
    const d2 = new Date(endDateStr);

    // 计算两个日期的毫秒差
    const diffInMilliseconds = Math.abs(d2 - d1);
    let intervals = [];
    // 将毫秒差转换为天数
    const diffInDays = Math.round(diffInMilliseconds / (1000 * 60 * 60 * 24));


    for (let i = 0; i <= diffInDays; i++) {
        const resultDate = new Date(d1);
        resultDate.setDate(d1.getDate() + i);
        const d11 = formatDate(resultDate);
        for (let j = 1; j <= 24; j++) {
            intervals.push(`${d11}${j}时`);
        }

    }
    return intervals;
}
function formatDate(date) { // 格式化日期为mm月DD日
    const mm = (date.getMonth() + 1).toString(); // 获取月份
    const dd = date.getDate().toString(); // 获取日期
    return `${mm}月${dd}日`;
}


function processNumber(num) { // 处理数字，使其为整数
    // 将数字转换为字符串
    const numStr = num.toString();
    // 检查是否已经是除首位外其余所有位都为0的数
    if (/^\d0*$/.test(numStr)) {
        return num;
    }
    // 获取最高位
    const firstDigit = numStr[0];
    // 将最高位转换为数字并加1
    const newFirstDigit = parseInt(firstDigit, 10) + 1;
    // 获取最高位之后的数字长度
    const restLength = numStr.length - 1;
    // 构造新的数字字符串
    const newNumStr = newFirstDigit.toString() + '0'.repeat(restLength);
    // 将新的数字字符串转换回数字并返回
    return parseInt(newNumStr, 10);
}


