// ==UserScript==
// @name         感知2D同源
// @namespace    http://118.196.97.105:8080
// @version      1.9.1
// @description  检测标注物归组规范：每组1人脸+5关键点(左眼/右眼/鼻尖/左嘴角/右嘴角)，并校验关键点坐标缺失/重合
// @author       CC
// @match        http://*:8080/*
// @grant        none
// @run-at       document-end
// @license CC
// ==/UserScript==

(function () {
    'use strict';

    const API_PATH = '/api/task/get-mark-data';

    const KEYPOINT_ORDER = ['left_eye', 'right_eye', 'nose', 'left_mouth', 'right_mouth'];
    const KEYPOINT_LABELS = {
        left_eye: '左眼中心',
        right_eye: '右眼中心',
        nose: '鼻尖',
        left_mouth: '左嘴角',
        right_mouth: '右嘴角'
    };
    const PSELECT_MAP = {
        '左眼中⼼': 'left_eye',
        '左眼中心': 'left_eye',
        '右眼中⼼': 'right_eye',
        '右眼中心': 'right_eye',
        '⿐尖': 'nose',
        '鼻尖': 'nose',
        '左嘴⻆': 'left_mouth',
        '左嘴角': 'left_mouth',
        '右嘴⻆': 'right_mouth',
        '右嘴角': 'right_mouth'
    };

    function normalizePname(m) {
        var pname = (m.class && m.class.pname) || '';
        if (pname === 'righ_mouth') return 'right_mouth';
        if (!pname || KEYPOINT_ORDER.indexOf(pname) === -1) {
            var mapped = PSELECT_MAP[m.pselect];
            if (mapped) return mapped;
        }
        return pname;
    }

    // ---- 关键点坐标几何校验配置 ----
    const GEOM_CFG = {
        MIN_EYE_DIST: 1       // 双眼距离小于该值视为坐标重合
    };

    function getPoint(m) {
        if (!m || !m.point) return null;
        var x = parseFloat(m.point.x);
        var y = parseFloat(m.point.y);
        if (isNaN(x) || isNaN(y)) return null;
        return { x: x, y: y };
    }

    // 读取标注物属性值（兼容多种存储形式：
    //   m.attrs 为对象（值可能是数组，如 {truncation:["clear"]}）/ m.attrs 为 [{pname,value}] 数组 /
    //   m.class.attrs 同上 / m.class[key]）
    function getMarkAttr(m, key) {
        if (!m) return undefined;
        function unwrap(v) {
            if (Array.isArray(v)) return v.length ? v[0] : undefined;
            return v;
        }
        var candidates = [];
        if (m.attrs != null) candidates.push(m.attrs);
        if (m.class && m.class.attrs != null) candidates.push(m.class.attrs);
        if (m.class && m.class[key] != null && typeof m.class[key] !== 'object') return m.class[key];
        for (var ci = 0; ci < candidates.length; ci++) {
            var a = candidates[ci];
            if (Array.isArray(a)) {
                for (var i = 0; i < a.length; i++) {
                    var it = a[i];
                    if (it && (it.pname === key || it.name === key)) {
                        if (it.value !== undefined) return it.value;
                        if (it.pname !== undefined) return it.pname;
                    }
                }
            } else if (a && typeof a === 'object') {
                if (key in a) return unwrap(a[key]);
            }
        }
        return undefined;
    }

    function fmtP(p) {
        return p ? p.x.toFixed(1) + ',' + p.y.toFixed(1) : '缺失';
    }

    // 口罩与关键点可见性一致性校验：
    // 人脸框 face_mask=1（有口罩）时，鼻尖及左右嘴角必须设为不可见（vis=1）。
    function validateMaskMouthConsistency(faceMark, kpMap, errs) {
        if (!faceMark) return;
        var mask = getMarkAttr(faceMark, 'face_mask');
        if (mask !== '1') return; // 仅“有口罩”时要求鼻尖/嘴角不可见
        ['nose', 'left_mouth', 'right_mouth'].forEach(function (k) {
            var mk = kpMap[k];
            if (!mk) return;
            var vis = getMarkAttr(mk, 'vis');
            if (vis !== '1') {
                errs.push('属性不一致：人脸框为“有口罩”，但' + (KEYPOINT_LABELS[k] || k) + '未标记为不可见（应设为不可见）');
            }
        });
    }

    // 关键点坐标几何校验（极宽松，不依赖头部姿态）：
    // 保留 坐标缺失 / 左右眼几乎重合 两项原有判定，
    // 新增：左眼x 必须大于 右眼x；左嘴角x 必须大于 右嘴角x；
    // 当人脸框截断程度为“无”（truncation=clear）时，5 个关键点坐标必须落在人脸框内。
    // 已去除方向/姿态类判定（R1 嘴角x方向 / R2 嘴角与眼同侧 / R3 四关键点自交 /
    // 鼻尖四边形 / R4 鼻尖y区间）：头部偏转、侧脸、抬头低头等姿态下不可靠，易误报。
    function validateKeypointGeometry(kpMap, members, errs, faceMark) {
        var eL = getPoint(kpMap['left_eye']);
        var eR = getPoint(kpMap['right_eye']);
        var nose = getPoint(kpMap['nose']);
        var mL = getPoint(kpMap['left_mouth']);
        var mR = getPoint(kpMap['right_mouth']);

        if (!eL || !eR || !nose || !mL || !mR) {
            var missing = [];
            if (!eL) missing.push('左眼');
            if (!eR) missing.push('右眼');
            if (!nose) missing.push('鼻尖');
            if (!mL) missing.push('左嘴角');
            if (!mR) missing.push('右嘴角');
            errs.push('关键点坐标异常：关键点坐标缺失（' + missing.join('、') + '）');
            return;
        }

        var eyeDist = Math.sqrt(Math.pow(eR.x - eL.x, 2) + Math.pow(eR.y - eL.y, 2));
        if (eyeDist < GEOM_CFG.MIN_EYE_DIST) {
            errs.push('关键点坐标异常：左右眼坐标几乎重合（' + fmtP(eL) + ' / ' + fmtP(eR) + '）');
            return;
        }

        // 左眼 x 必须大于 右眼 x
        if (!(eL.x > eR.x)) {
            errs.push('关键点坐标异常：左眼应在右眼右侧（左眼x=' + eL.x.toFixed(1) + '，右眼x=' + eR.x.toFixed(1) + '）');
        }

        // 左嘴角 x 必须大于 右嘴角 x
        if (!(mL.x > mR.x)) {
            errs.push('关键点坐标异常：左嘴角应在右嘴角右侧（左嘴角x=' + mL.x.toFixed(1) + '，右嘴角x=' + mR.x.toFixed(1) + '）');
        }

        // 人脸框截断程度为“无”时，关键点坐标不允许在框外
        if (faceMark) {
            var trunc = getMarkAttr(faceMark, 'truncation');
            if (trunc === 'clear') {
                var fb = faceMark.point;
                if (fb && fb.left !== undefined) {
                    var L = parseFloat(fb.left), T = parseFloat(fb.top),
                        Rt = parseFloat(fb.right), B = parseFloat(fb.bottom);
                    KEYPOINT_ORDER.forEach(function (k) {
                        var p = getPoint(kpMap[k]);
                        if (!p) return;
                        if (p.x < L || p.x > Rt || p.y < T || p.y > B) {
                            errs.push('关键点坐标异常：' + (KEYPOINT_LABELS[k] || k) + ' 坐标（' + fmtP(p) +
                                '）在人脸框外（截断程度为无，关键点必须在框内）');
                        }
                    });
                }
            }
        }
    }

    // ---- 悬浮窗 UI ----
    let panelContainer = null;
    let panelBody = null;
    let panelContent = null;
    let isMinimized = false;
    let isDragging = false;
    let dragOffsetX = 0;
    let dragOffsetY = 0;
    let panelX = 20;
    let panelY = 60;

    function createPanel() {
        if (panelContainer) return;

        panelContainer = document.createElement('div');
        panelContainer.id = '_gc_panel';
        panelContainer.style.cssText = 'position:fixed;z-index:999999;width:380px;background:#ffffff;border:1px solid #d1d5db;border-radius:10px;box-shadow:0 4px 20px rgba(0,0,0,0.15);font-family:"Microsoft YaHei","PingFang SC",Arial,sans-serif;font-size:13px;color:#1f2937;overflow:hidden;left:' + panelX + 'px;top:' + panelY + 'px;user-select:none;';

        // 标题栏
        const titleBar = document.createElement('div');
        titleBar.style.cssText = 'display:flex;align-items:center;justify-content:space-between;padding:8px 12px;background:#f3f4f6;cursor:move;border-bottom:1px solid #d1d5db;';
        titleBar.innerHTML = '<span style="font-weight:bold;font-size:14px;color:#374151;">感知2D同源</span>';
        titleBar.addEventListener('mousedown', startDrag);
        panelContainer.appendChild(titleBar);

        // 按钮组
        const btnGroup = document.createElement('div');
        btnGroup.style.cssText = 'display:flex;gap:6px;';

        const minBtn = createBtn('—', '#e5e7eb', '#d1d5db', function (e) { e.stopPropagation(); toggleMinimize(); });
        const closeBtn = createBtn('✕', '#fca5a5', '#f87171', function (e) { e.stopPropagation(); closePanel(); });
        btnGroup.appendChild(minBtn);
        btnGroup.appendChild(closeBtn);
        titleBar.appendChild(btnGroup);

        // 内容区域
        panelBody = document.createElement('div');
        panelBody.style.cssText = 'max-height:500px;overflow-y:auto;transition:max-height 0.25s ease;';
        panelContainer.appendChild(panelBody);

        panelContent = document.createElement('div');
        panelContent.style.cssText = 'padding:12px;background:#ffffff;';
        panelBody.appendChild(panelContent);

        document.body.appendChild(panelContainer);
    }

    function createBtn(text, color, hoverColor, onClick) {
        const btn = document.createElement('span');
        btn.textContent = text;
        btn.style.cssText = 'width:26px;height:26px;display:flex;align-items:center;justify-content:center;border-radius:6px;cursor:pointer;font-size:14px;font-weight:bold;color:#374151;background:' + color + ';';
        btn.addEventListener('mouseenter', function () { btn.style.background = hoverColor; });
        btn.addEventListener('mouseleave', function () { btn.style.background = color; });
        btn.addEventListener('click', onClick);
        return btn;
    }

    function toggleMinimize() {
        isMinimized = !isMinimized;
        if (isMinimized) {
            panelBody.style.maxHeight = '0';
            panelBody.style.padding = '0';
        } else {
            panelBody.style.maxHeight = '500px';
            panelBody.style.padding = '';
        }
    }

    function closePanel() {
        if (panelContainer) {
            panelContainer.remove();
            panelContainer = null;
        }
    }

    function startDrag(e) {
        if (e.button !== 0) return;
        isDragging = true;
        const rect = panelContainer.getBoundingClientRect();
        dragOffsetX = e.clientX - rect.left;
        dragOffsetY = e.clientY - rect.top;
        panelContainer.style.cursor = 'grabbing';
        panelContainer.style.transition = 'none';
        document.addEventListener('mousemove', onDrag);
        document.addEventListener('mouseup', stopDrag);
        e.preventDefault();
    }

    function onDrag(e) {
        if (!isDragging || !panelContainer) return;
        panelX = Math.max(0, e.clientX - dragOffsetX);
        panelY = Math.max(0, e.clientY - dragOffsetY);
        panelContainer.style.left = panelX + 'px';
        panelContainer.style.top = panelY + 'px';
    }

    function stopDrag() {
        isDragging = false;
        if (panelContainer) {
            panelContainer.style.cursor = '';
        }
        document.removeEventListener('mousemove', onDrag);
        document.removeEventListener('mouseup', stopDrag);
    }

    function renderPanel(result) {
        createPanel();
        if (!panelContent) return;

        const { groups, lonelyMarks, summary, markStatus, marks } = result;

        let html = '';

        // ---- 概要栏 ----
        const totalGroups = Object.keys(groups).length;
        const issueGroups = Object.values(groups).filter(g => !g.pass).length;
        const lonelyCount = lonelyMarks.length;
        const statusConflict = markStatus === 1 && marks && marks.length > 0;
        const ok = issueGroups === 0 && lonelyCount === 0 && !statusConflict;

        // mark_status 冲突提示
        if (statusConflict) {
            html += '<div style="display:flex;align-items:center;gap:8px;padding:8px 10px;margin-bottom:10px;border-radius:8px;background:#fef2f2;border:1px solid #fca5a5;">';
            html += '<span style="font-size:18px;">🚫</span>';
            html += '<div style="flex:1;font-size:12px;line-height:1.5;">';
            html += '<div style="font-weight:bold;font-size:13px;color:#dc2626;">标注状态异常</div>';
            html += '<span style="color:#6b7280;">mark_status=1（无需标注），但存在 ' + marks.length + ' 个标注数据</span>';
            html += '</div></div>';
        }

        html += '<div style="display:flex;align-items:center;gap:8px;padding:8px 10px;margin-bottom:10px;border-radius:8px;background:' + (ok ? '#ecfdf5' : '#fef2f2') + ';border:1px solid ' + (ok ? '#6ee7b7' : '#fca5a5') + ';">';
        html += '<span style="font-size:20px;">' + (ok ? '✅' : '⚠️') + '</span>';
        html += '<div style="flex:1;font-size:12px;line-height:1.5;">';
        html += '<div style="font-weight:bold;font-size:14px;color:' + (ok ? '#059669' : '#dc2626') + ';">' + (ok ? '所有归组正确' : '存在异常') + '</div>';
        html += '<span style="color:#6b7280;">' + totalGroups + ' 个组';
        if (issueGroups > 0) html += ' · <span style="color:#dc2626;">' + issueGroups + ' 个组异常</span>';
        if (lonelyCount > 0) html += ' · <span style="color:#dc2626;">' + lonelyCount + ' 个孤立标注</span>';
        html += '</span></div></div>';

        // ---- 孤立标注 ----
        if (lonelyCount > 0) {
            html += '<div style="margin-bottom:10px;">';
            html += '<div style="font-weight:bold;color:#dc2626;margin-bottom:4px;">⚠ 孤立标注（未归组）</div>';
            lonelyMarks.forEach(m => {
                const label = m.class?.pname || m.pselect || '?';
                html += '<div style="padding:4px 8px;margin:2px 0;background:#fef2f2;border-radius:4px;font-size:12px;">';
                html += '<div style="display:flex;justify-content:space-between;">';
                html += '<span>' + label + '</span>';
                html += '<span style="color:#6b7280;font-family:monospace;font-size:11px;">markId: ' + m.markId + '</span>';
                html += '</div>';
                if (m._boundErr) {
                    html += '<div style="color:#dc2626;font-size:11px;margin-top:2px;">• ' + m._boundErr + '</div>';
                }
                html += '</div>';
            });
            html += '</div>';
        }

        // ---- 各组详情 ----
        const sortedGroupIds = Object.keys(groups).sort(function (a, b) { return Number(a) - Number(b); });
        sortedGroupIds.forEach(function (gid) {
            const g = groups[gid];
            const pass = g.pass;
            const errs = g.errors || [];

            html += '<div style="margin-bottom:6px;border:1px solid ' + (pass ? '#6ee7b7' : '#fca5a5') + ';border-radius:8px;overflow:hidden;">';
            html += '<div style="display:flex;justify-content:space-between;align-items:center;padding:6px 10px;background:' + (pass ? '#ecfdf5' : '#fef2f2') + ';font-weight:bold;font-size:13px;">';
            html += '<span>组 ' + gid + ' <span style="font-weight:normal;font-size:11px;color:#6b7280;">(' + g.count + ' 个标注)</span></span>';
            html += '<span style="color:' + (pass ? '#059669' : '#dc2626') + ';font-size:12px;">' + (pass ? '✓ 正确' : errs.length + ' 个问题') + '</span>';
            html += '</div>';

            if (!pass) {
                html += '<div style="padding:6px 10px;font-size:12px;background:#fff;border-bottom:1px solid #f3f4f6;">';
                errs.forEach(function (err) {
                    html += '<div style="padding:2px 0;color:#92400e;">• ' + err + '</div>';
                });
                html += '</div>';
            }

            // 组内成员列表
            html += '<div style="padding:4px 10px 6px;font-size:11px;color:#6b7280;background:#f9fafb;">';
            g.members.forEach(function (m) {
                const label = m.class?.pname || m.pselect || '?';
                const idx = m._kpIdx !== undefined ? (' [' + (m._kpIdx + 1) + ']') : '';
                html += '<span style="display:inline-block;margin:2px 4px 2px 0;padding:1px 6px;background:#e5e7eb;border-radius:3px;color:#374151;">' + label + idx + '</span>';
            });
            html += '</div>';

            html += '</div>';
        });

        panelContent.innerHTML = html;
        // 滚动到顶部
        panelBody.scrollTop = 0;
    }

    // ---- 核心分析逻辑 ----
    let _lastMarkStatus = null;
    let _lastMarks = null;

    function analyzeMarks(marks, markStatus, imgWidth, imgHeight) {
        _lastMarkStatus = markStatus;
        _lastMarks = marks;
        if (!marks || marks.length === 0) return;

        // 统计 groupId -> marks
        const groupMap = {};
        const lonelyMap = {};

        marks.forEach(function (m) {
            let gid = m.groupId;
            if (gid === undefined || gid === null || gid === '' || gid === 0) {
                gid = '__lonely_' + m.markId;
                lonelyMap[gid] = true;
            }
            if (!groupMap[gid]) groupMap[gid] = [];
            groupMap[gid].push(m);
        });

        // 孤立标注：groupId 只出现一次 或 groupId=0/null/undefined
        const lonelyMarks = [];
        Object.keys(groupMap).forEach(function (gid) {
            if (lonelyMap[gid] || groupMap[gid].length === 1) {
                groupMap[gid].forEach(function (m) { lonelyMarks.push(m); });
                delete groupMap[gid];
            }
        });

        // 分析每个 group
        const groups = {};
        Object.keys(groupMap).forEach(function (gid) {
            const members = groupMap[gid];
            const g = { groupId: gid, count: members.length, members: members, errors: [], pass: true };
            groups[gid] = validateGroup(g, imgWidth, imgHeight);
        });

        // 对孤立标注也做越界检查
        lonelyMarks.forEach(function (m) {
            var err = checkBounds(m, imgWidth, imgHeight);
            if (err) m._boundErr = err;
        });

        const result = { groups: groups, lonelyMarks: lonelyMarks, summary: {}, markStatus: markStatus, marks: marks, imgWidth: imgWidth, imgHeight: imgHeight };
        renderPanel(result);
    }

    function getPname(m) {
        return normalizePname(m);
    }

    function checkBounds(m, imgWidth, imgHeight) {
        var pname = getPname(m);
        // 关键点允许在图像外
        if (KEYPOINT_ORDER.indexOf(pname) !== -1) return null;
        // 只对 rect/box 类型做检查
        if (m.type !== 'rect') return null;

        var pt = m.point;
        if (!pt) return null;

        var issues = [];
        if (pt.left !== undefined) {
            if (pt.left < 0) issues.push('left=' + pt.left.toFixed(1));
            if (pt.top < 0) issues.push('top=' + pt.top.toFixed(1));
            // 也可以检查 right/bottom 是否超出宽高
            if (imgWidth && pt.right > imgWidth) issues.push('right=' + pt.right.toFixed(1) + '>' + imgWidth);
            if (imgHeight && pt.bottom > imgHeight) issues.push('bottom=' + pt.bottom.toFixed(1) + '>' + imgHeight);
        }

        if (issues.length === 0) return null;
        return '标注超出图像边界: ' + issues.join(', ');
    }

    function validateGroup(g, imgWidth, imgHeight) {
        const members = g.members;
        const errs = g.errors;

        // 按类别统计
        const counts = {};
        const kpList = [];
        let faceMark = null;
        members.forEach(function (m) {
            const pname = getPname(m);
            counts[pname] = (counts[pname] || 0) + 1;
            if (pname === 'face') faceMark = m;
            if (KEYPOINT_ORDER.indexOf(pname) !== -1) {
                kpList.push({ mark: m, pname: pname, idx: KEYPOINT_ORDER.indexOf(pname) });
            }
        });

        // 1) face 校验
        const faceCount = counts['face'] || 0;
        if (faceCount === 0) {
            errs.push('缺少人脸框 (face)');
        } else if (faceCount > 1) {
            errs.push('人脸框超过 1 个 (' + faceCount + ')');
        }

        // 2) face_visible 校验（不应超过1个）
        const fvCount = counts['face_visible'] || 0;
        if (fvCount > 1) {
            errs.push('face_visible 超过 1 个 (' + fvCount + ')');
        }

        // 3) 关键点校验
        if (kpList.length !== 5) {
            errs.push('关键点数量错误：期望 5 个，实际 ' + kpList.length + ' 个');
        } else {
            // 检查顺序（按在 marks 数组中的原始顺序，不排序）
            var orderOk = true;
            var orderErrIdx = -1;
            for (var i = 0; i < 5; i++) {
                var expected = KEYPOINT_ORDER[i];
                var actual = kpList[i].pname;
                if (actual !== expected) {
                    orderOk = false;
                    orderErrIdx = i;
                    break;
                }
            }
            if (!orderOk) {
                var actualStr = kpList.map(function (k) { return KEYPOINT_LABELS[k.pname] || k.pname; }).join(' → ');
                var expectedStr = KEYPOINT_ORDER.map(function (k) { return KEYPOINT_LABELS[k]; }).join(' → ');
                errs.push('关键点顺序错误：期望 ' + expectedStr + '，实际 ' + actualStr);
            }

            // 标记顺序索引用于展示
            kpList.forEach(function (k, i) { k.mark._kpIdx = i + 1; });

            // 关键点坐标几何校验（坐标缺失 / 左右眼重合 / 左右x方向 / 无截断时框内约束）
            const kpMap = {};
            kpList.forEach(function (k) { kpMap[k.pname] = k.mark; });
            validateKeypointGeometry(kpMap, members, errs, faceMark);

            // 口罩 ↔ 嘴角可见性一致性
            validateMaskMouthConsistency(faceMark, kpMap, errs);
        }

        // 4) 检查边界越界（仅 rect 类型，关键点除外）
        members.forEach(function (m) {
            var boundErr = checkBounds(m, imgWidth, imgHeight);
            if (boundErr) errs.push(boundErr);
        });

        // 5) 检查多余的非标准标注物
        const standardClasses = ['face', 'face_visible'].concat(KEYPOINT_ORDER);
        members.forEach(function (m) {
            const pname = getPname(m);
            if (standardClasses.indexOf(pname) === -1 && pname) {
                errs.push('多余标注物: ' + pname);
            }
        });

        if (errs.length > 0) g.pass = false;
        return g;
    }

    // ---- 拦截 XHR ----
    var origOpen = XMLHttpRequest.prototype.open;
    XMLHttpRequest.prototype.open = function (method, url) {
        this._url = url;
        return origOpen.apply(this, arguments);
    };

    var origSend = XMLHttpRequest.prototype.send;
    XMLHttpRequest.prototype.send = function (body) {
        if (this._url && typeof this._url === 'string' && this._url.indexOf(API_PATH) !== -1) {
            this.addEventListener('load', function () {
                try {
                    var resp = JSON.parse(this.responseText);
                    if (resp.code === 0 && resp.data) {
                        var md = resp.data.markData;
                        analyzeMarks(md && md.marks, resp.data.mark_status, md && md.width, md && md.height);
                    }
                } catch (e) {}
            });
        }
        return origSend.apply(this, arguments);
    };

    // ---- 拦截 fetch ----
    var origFetch = window.fetch;
    if (origFetch) {
        window.fetch = function (input, init) {
            var url = typeof input === 'string' ? input : (input instanceof Request ? input.url : '');
            if (url.indexOf(API_PATH) !== -1) {
                return origFetch.apply(this, arguments).then(function (response) {
                    var clone = response.clone();
                    clone.json().then(function (data) {
                        if (data.code === 0 && data.data) {
                            var md = data.data.markData;
                            analyzeMarks(md && md.marks, data.data.mark_status, md && md.width, md && md.height);
                        }
                    }).catch(function () {});
                    return response;
                });
            }
            return origFetch.apply(this, arguments);
        };
    }

    console.log('[归组检查] 脚本已加载 v1.9.1');
})();