// ==UserScript==
// @name         2D车位线标注验收
// @namespace    http://tampermonkey.net/
// @version      1.2
// @description  拦截标注数据验收，根据业务规则精准校验，支持点击高亮定位、窗口拖动与参数自定义
// @author       CodeGeeX
// @match        http://113.207.49.80:8080/*
// @grant        none
// ==/UserScript==

(function() {
    'use strict';

    // 默认自定义配置参数
    const CONFIG = {
        lineMinWidth: 8,       // 车位线最小宽度(像素)
        lineMaxWidth: 12,      // 车位线最大宽度(像素)
        pointRectMaxDist: 100  // 角点距离车位框中心最大允许距离(像素)
    };

    // 保存最后一次拦截到的数据，方便修改配置后重新校验
    let lastMarkData = null;

    const originalOpen = XMLHttpRequest.prototype.open;
    const originalSend = XMLHttpRequest.prototype.send;

    XMLHttpRequest.prototype.open = function(method, url, ...args) {
        this._hookData = { method, url };
        return originalOpen.apply(this, [method, url, ...args]);
    };

    XMLHttpRequest.prototype.send = function(...args) {
        if (this._hookData && this._hookData.url.includes('/api/task/get-mark-data')) {
            this.addEventListener('load', function() {
                if (this.status === 200) {
                    try {
                        const responseData = JSON.parse(this.responseText);
                        if (responseData.code === 0 && responseData.data && responseData.data.markData) {
                            lastMarkData = responseData.data.markData; // 缓存数据
                            validateAndReport(lastMarkData);
                        }
                    } catch (e) {
                        console.error('[验收助手] 解析JSON失败:', e);
                    }
                }
            });
        }
        return originalSend.apply(this, args);
    }

    function validateAndReport(markData) {
        const marks = markData.marks || [];
        const errors = [];

        // 1. 数据预处理与分组 (不再依赖顺序，只要groupId相同即为一组)
        const groups = {};
        const pointList = [];
        let mainIndex = 1;
        
        marks.forEach((mark) => {
            const gid = mark.groupId;
            if (gid !== undefined) {
                if (!groups[gid]) {
                    groups[gid] = { mainIndex: mainIndex++, points: [], rect: null };
                }
                
                if (mark.type === 'point') {
                    const subIndex = groups[gid].points.length + 1;
                    mark._displayLabel = `#${groups[gid].mainIndex}-${subIndex}`;
                    mark._mainIndex = groups[gid].mainIndex;
                    groups[gid].points.push(mark);
                    pointList.push(mark);
                } else if (mark.type === 'rect' && mark.pselect === '车位') {
                    mark._mainIndex = groups[gid].mainIndex;
                    groups[gid].rect = mark;
                }
            } else {
                mark._displayLabel = `#${mainIndex}`;
                mark._mainIndex = mainIndex++;
            }
        });

        // 为车位框补充显示标签 (此时点已经全部归组完毕)
        for (const gid in groups) {
            const group = groups[gid];
            if (group.rect) {
                group.rect._displayLabel = `#${group.mainIndex}-${group.points.length + 1}`;
            }
        }

        // 2. 执行业务规则校验
        // 规则1：完整库位判定与反向校验
        for (const gid in groups) {
            const group = groups[gid];
            const hasRect = !!group.rect;
            const pointCount = group.points.length;

            if (hasRect) {
                const category = group.rect.attrs && group.rect.attrs.category && group.rect.attrs.category[0];
                // 仅当属性为完整库位(lots)时，才校验是否包含4个角点
                if (category === 'lots' && pointCount !== 4) {
                    errors.push({ type: '结构错误', label: `#${group.mainIndex}`, name: '车位组', markId: group.rect.markId, msg: `完整库位应含4个角点，实际包含 ${pointCount} 个` });
                }
            } else {
                // 反向校验：如果有4个角点但没有车位框，提醒补充
                if (pointCount === 4) {
                    errors.push({ type: '结构错误', label: `#${group.mainIndex}`, name: '车位组', markId: group.points[0].markId, msg: '已有4个角点，但缺少车位整体框' });
                }
            }
        }

        // 规则2：所有车位线属性中，车位线的宽度一定是自定义范围内的像素
        marks.forEach(mark => {
            if (mark.type === 'rect' && mark.pselect === '车位线') {
                const p = mark.point || {};
                const w = Math.abs((p.right || 0) - (p.left || 0));
                const h = Math.abs((p.bottom || 0) - (p.top || 0));
                const minSide = Math.min(w, h);
                
                if (minSide < CONFIG.lineMinWidth || minSide > CONFIG.lineMaxWidth) {
                    errors.push({ type: '属性错误', label: mark._displayLabel, name: '车位线', markId: mark.markId, msg: `车位线宽度应为${CONFIG.lineMinWidth}-${CONFIG.lineMaxWidth}px，当前为 ${minSide.toFixed(1)}px` });
                }
            }
        });

        // 规则3：车位整块框和1.2点的距离不会太远 (使用自定义阈值)
        for (const gid in groups) {
            const group = groups[gid];
            if (group.rect && group.points.length >= 2) {
                const rectP = group.rect.point || {};
                const rectCx = ((rectP.left || 0) + (rectP.right || 0)) / 2;
                const rectCy = ((rectP.top || 0) + (rectP.bottom || 0)) / 2;

                group.points.slice(0, 2).forEach(p => {
                    const pt = p.point || {};
                    const dist = Math.sqrt(Math.pow(rectCx - parseFloat(pt.x || 0), 2) + Math.pow(rectCy - parseFloat(pt.y || 0), 2));
                    if (dist > CONFIG.pointRectMaxDist) {
                        errors.push({ type: '逻辑错误', label: p._displayLabel, name: '角点', markId: p.markId, msg: `角点距离车位框中心过远 (${dist.toFixed(1)}px)，阈值${CONFIG.pointRectMaxDist}px` });
                    }
                });
            }
        }

        // 规则4：车位内1和2点任意一点属性为不可见时，车位整块框的类别必须为不可辨别
        for (const gid in groups) {
            const group = groups[gid];
            if (group.rect && group.points.length >= 2) {
                const p1Vis = group.points[0].attrs && group.points[0].attrs.visibility && group.points[0].attrs.visibility[0];
                const p2Vis = group.points[1].attrs && group.points[1].attrs.visibility && group.points[1].attrs.visibility[0];
                
                if (p1Vis === 'invisible_p' || p2Vis === 'invisible_p') {
                    const lotsType = group.rect.attrs && group.rect.attrs.lots_type && group.rect.attrs.lots_type[0];
                    const isUnknown = lotsType && (lotsType === 'vertical_unknown' || lotsType === 'oblique_unknown' || lotsType === 'horizontal_unknown');
                    if (!isUnknown) {
                        errors.push({ type: '逻辑错误', label: `#${group.mainIndex}`, name: '车位框', markId: group.rect.markId, msg: `入口点(1或2)不可见时，车位类别必须为不可辨别，当前为 ${lotsType || '空'}` });
                    }
                }
            }
        }

        // 规则5：点的属性中，不可见和其他一定是对应的
        pointList.forEach(p => {
            const vis = p.attrs && p.attrs.visibility && p.attrs.visibility[0];
            const pType = p.attrs && p.attrs.points_type && p.attrs.points_type[0];
            if (vis === 'invisible_p' && pType !== 'others_p') {
                errors.push({ type: '属性错误', label: p._displayLabel, name: '角点', markId: p.markId, msg: '点属性不可见时，点类别必须为其他(others_p)' });
            }
            if (vis === 'visible_p' && pType === 'others_p') {
                errors.push({ type: '属性错误', label: p._displayLabel, name: '角点', markId: p.markId, msg: '点属性可见时，点类别不能为其他(others_p)' });
            }
        });

        // 规则6：地砖线一定对应颜色是其它
        marks.forEach(mark => {
            if (mark.type === 'rect' && mark.pselect === '车位线') {
                const category = mark.attrs && mark.attrs.category && mark.attrs.category[0];
                const color = mark.attrs && mark.attrs.color && mark.attrs.color[0];
                if (category === 'floortileline' && color !== 'qita') {
                    errors.push({ type: '属性错误', label: mark._displayLabel, name: '车位线', markId: mark.markId, msg: `地砖线(floortileline)颜色必须为其它(qita)，当前为 ${color || '空'}` });
                }
            }
        });

        renderReport(errors);
    }

    function initPanel() {
        if (document.getElementById('val-panel')) return;

        const panel = document.createElement('div');
        panel.id = 'val-panel';
        panel.innerHTML = `
            <div id="val-header">
                <h3>🛑 验收报告</h3>
                <div>
                    <button class="val-btn" id="btn-fold">折叠</button>
                    <button class="val-btn" id="btn-close">关闭</button>
                </div>
            </div>
            <div id="val-config">
                <div style="display:flex;align-items:center;">
                    <div class="config-item">线宽: <input id="cfg-min" type="number" value="${CONFIG.lineMinWidth}">-<input id="cfg-max" type="number" value="${CONFIG.lineMaxWidth}">px</div>
                    <div class="config-item">距离阈值: <input id="cfg-dist" type="number" value="${CONFIG.pointRectMaxDist}">px</div>
                </div>
                <button class="config-apply" id="cfg-apply-btn">应用配置</button>
            </div>
            <div id="val-stats"></div>
            <div id="val-body"></div>
        `;
        document.body.appendChild(panel);

        // 初始化样式
        if (!document.getElementById('validate-css')) {
            const style = document.createElement('style');
            style.id = 'validate-css';
            style.textContent = `
                #val-panel { position: fixed; top: 10px; right: 10px; width: 450px; background: rgba(17, 24, 39, 0.95); color: #fff; border-radius: 8px; z-index: 99999; font-family: sans-serif; box-shadow: 0 4px 20px rgba(0,0,0,0.6); border: 1px solid #333; display: flex; flex-direction: column; max-height: 90vh; }
                #val-header { padding: 12px 15px; background: #1f2937; border-bottom: 1px solid #333; display: flex; justify-content: space-between; align-items: center; cursor: move; user-select: none; }
                #val-header h3 { margin: 0; font-size: 15px; color: #60a5fa; }
                .val-btn { background: transparent; border: 1px solid #4b5563; color: #9ca3af; padding: 2px 8px; border-radius: 4px; cursor: pointer; font-size: 12px; margin-left: 5px; }
                .val-btn:hover { background: #374151; color: #fff; }
                #val-config { padding: 10px 15px; background: #111827; border-bottom: 1px solid #333; font-size: 12px; display: flex; align-items: center; justify-content: space-between; }
                .config-item { display: flex; align-items: center; color: #9ca3af; margin-right: 10px; }
                .config-item input { width: 40px; background: #374151; border: 1px solid #4b5563; color: #fff; text-align: center; border-radius: 3px; margin: 0 4px; padding: 2px 0; }
                .config-apply { background: #2563eb; border: none; color: #fff; padding: 4px 10px; border-radius: 4px; cursor: pointer; font-size: 12px; }
                .config-apply:hover { background: #1d4ed8; }
                #val-stats { display: flex; padding: 10px 15px; background: #111827; border-bottom: 1px solid #333; font-size: 12px; }
                .stat-item { margin-right: 15px; color: #9ca3af; }
                .stat-num { font-weight: bold; margin-right: 4px; }
                .stat-struct .stat-num { color: #f87171; }
                .stat-attr .stat-num { color: #fbbf24; }
                .stat-logic .stat-num { color: #a78bfa; }
                #val-body { padding: 10px 15px; overflow-y: auto; max-height: 60vh; }
                .err-item { padding: 8px; margin-bottom: 6px; background: #1f2937; border-radius: 4px; font-size: 12px; border-left: 3px solid #ef4444; cursor: pointer; transition: 0.2s; display: flex; align-items: center; }
                .err-item:hover { background: #374151; }
                .err-item.attr-err { border-left-color: #f59e0b; }
                .err-item.logic-err { border-left-color: #8b5cf6; }
                .err-type { font-weight: bold; margin-right: 6px; flex-shrink: 0; }
                .struct-err .err-type { color: #f87171; }
                .attr-err .err-type { color: #fbbf24; }
                .logic-err .err-type { color: #a78bfa; }
                .err-name { color: #60a5fa; margin-right: 6px; flex-shrink: 0; }
                .err-label { color: #34d399; font-weight: bold; margin-right: 8px; background: rgba(52,211,153,0.1); padding: 1px 4px; border-radius: 2px; flex-shrink: 0; }
                .err-msg { color: #d1d5db; }
                .val-success { text-align: center; color: #34d399; padding: 30px 0; font-size: 16px; font-weight: bold; }
            `;
            document.head.appendChild(style);
        }

        // 绑定拖拽
        const header = panel.querySelector('#val-header');
        let isDragging = false;
        let startX, startY, initialLeft, initialTop;

        header.addEventListener('mousedown', (e) => {
            if (e.target.classList.contains('val-btn')) return;
            isDragging = true;
            startX = e.clientX;
            startY = e.clientY;
            const rect = panel.getBoundingClientRect();
            initialLeft = rect.left;
            initialTop = rect.top;
            panel.style.transition = 'none';
        });

        document.addEventListener('mousemove', (e) => {
            if (!isDragging) return;
            const dx = e.clientX - startX;
            const dy = e.clientY - startY;
            panel.style.left = `${initialLeft + dx}px`;
            panel.style.top = `${initialTop + dy}px`;
            panel.style.right = 'auto';
        });

        document.addEventListener('mouseup', () => {
            isDragging = false;
            panel.style.transition = '';
        });

        // 绑定按钮事件
        panel.querySelector('#btn-fold').addEventListener('click', () => {
            const body = document.getElementById('val-body');
            body.style.display = body.style.display === 'none' ? 'block' : 'none';
        });

        panel.querySelector('#btn-close').addEventListener('click', () => {
            panel.style.display = 'none';
        });

        panel.querySelector('#cfg-apply-btn').addEventListener('click', () => {
            const minW = parseInt(document.getElementById('cfg-min').value);
            const maxW = parseInt(document.getElementById('cfg-max').value);
            const dist = parseInt(document.getElementById('cfg-dist').value);
            
            if (!isNaN(minW)) CONFIG.lineMinWidth = minW;
            if (!isNaN(maxW)) CONFIG.lineMaxWidth = maxW;
            if (!isNaN(dist)) CONFIG.pointRectMaxDist = dist;
            
            if (lastMarkData) {
                validateAndReport(lastMarkData);
            } else {
                alert('暂无标注数据，请先切换图片加载');
            }
        });
    }

    function renderReport(errors) {
        initPanel(); // 确保面板已创建

        const statsDiv = document.getElementById('val-stats');
        const bodyDiv = document.getElementById('val-body');

        const structCount = errors.filter(e => e.type === '结构错误').length;
        const attrCount = errors.filter(e => e.type === '属性错误').length;
        const logicCount = errors.filter(e => e.type === '逻辑错误').length;

        statsDiv.innerHTML = `
            <div class="stat-item stat-struct">结构错误: <span class="stat-num">${structCount}</span></div>
            <div class="stat-item stat-attr">属性错误: <span class="stat-num">${attrCount}</span></div>
            <div class="stat-item stat-logic">逻辑错误: <span class="stat-num">${logicCount}</span></div>
        `;

        let bodyHtml = '';
        if (errors.length === 0) {
            bodyHtml = `<div class="val-success">✅ 验收通过，未发现异常！</div>`;
        } else {
            errors.forEach(err => {
                const cls = err.type === '属性错误' ? 'attr-err' : (err.type === '逻辑错误' ? 'logic-err' : 'struct-err');
                bodyHtml += `
                    <div class="err-item ${cls}" data-markid="${err.markId}" title="点击在侧栏中定位并高亮">
                        <span class="err-type">[${err.type}]</span>
                        <span class="err-label">${err.label}</span>
                        <span class="err-name">${err.name}</span>
                        <span class="err-msg">${err.msg}</span>
                    </div>
                `;
            });
        }
        
        bodyDiv.innerHTML = bodyHtml;
        
        // 重新绑定列表点击事件
        bodyDiv.querySelectorAll('.err-item').forEach(item => {
            item.addEventListener('click', () => {
                const markId = item.getAttribute('data-markid');
                locateInSidebar(markId);
            });
        });

        document.getElementById('val-panel').style.display = 'flex';
    }

    function locateInSidebar(markId) {
        if (!markId) return;
        const targetItem = document.querySelector(`li[data-markid="${markId}"]`);
        if (targetItem) {
            targetItem.scrollIntoView({ behavior: 'smooth', block: 'center' });
            targetItem.style.transition = 'background 0.3s';
            targetItem.style.background = 'rgba(239, 68, 68, 0.5)';
            setTimeout(() => { targetItem.style.background = ''; }, 3000);
        } else {
            alert(`无法定位到侧栏项，请检查页面是否已加载完全。`);
        }
    }

})();