// ==UserScript==
// @name         工单自动更新
// @namespace    http://tampermonkey.net/
// @license      MIT
// @version      2026-07-21-19
// @description  运盟工单的自动化操作，协助工作人员简单化操作
// @author       FNG666
// @match        https://gongdan.yonmen.com:17040/index.html*
// @match        https://dolphin.yonmen.com/web/
// @icon         https://www.google.com/s2/favicons?sz=64&domain=yonmen.com
// @grant        GM_addStyle
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        window.close
// ==/UserScript==

(function() {
    'use strict';

    // =========================================================================
    // CONFIG — all tunable values in one place
    // =========================================================================
    const CONFIG = {
        refresh: {
            minInterval: 3000,
            maxInterval: 5000,
        },
        toast: {
            defaultDuration: 4000,
            stickyDuration: 0,       // 0 = stays until replaced
        },
        monitor: {
            queryDelay: 500,
            retryBaseDelay: 2000,
            retryMaxDelay: 15000,
            dropdownPollInterval: 100,
            dropdownTimeout: 5000,
        },
        router: {
            fallbackPollMs: 5000,    // long-interval fallback if events fail
        },
        log: {
            level: 'info',           // 'debug' | 'info' | 'warn' | 'error' | 'none'
        },
        selectors: {
            // These are FALLBACKS — primary queries use text/label/placeholder matching
            searchButtonClass: 'search-button',
            queryButtonText: '查询',
            licensePlateLabel: '车头号牌：',
            licensePlateInput: '请输入车牌号',
            dropdownItem: '.k-select-item',
        },
        storage: {
            autoRefresh: 'autoRefreshActive',
            licensePlate: 'licensePlate',
            shouldAutoQuery: 'shouldAutoQuery',
        },
        hotkey: { ctrl: true, alt: true, key: 'e' },
    };

    // =========================================================================
    // LOGGER — level-based, can mute in production
    // =========================================================================
    const LOG = (() => {
        const levels = { debug: 0, info: 1, warn: 2, error: 3, none: 99 };
        const current = levels[CONFIG.log.level] ?? levels.info;
        const prefix = '[工单助手]';
        return {
            debug: (...a) => current <= 0 && console.debug(prefix, ...a),
            info:  (...a) => current <= 1 && console.log(prefix, ...a),
            warn:  (...a) => current <= 2 && console.warn(prefix, ...a),
            error: (...a) => current <= 3 && console.error(prefix, ...a),
        };
    })();

    // =========================================================================
    // DOM UTILITIES — semantic queries that survive UI-framework upgrades
    // =========================================================================

    /**
     * Find a button whose visible text matches `text` exactly or by inclusion.
     * Returns the `<button>` element or null.
     */
    function findButtonByText(text, { exact = false, container = document } = {}) {
        const buttons = container.querySelectorAll('button');
        for (const btn of buttons) {
            const content = btn.textContent.trim();
            if (exact ? content === text : content.includes(text)) {
                return btn;
            }
        }
        return null;
    }

    /**
     * Find a form-item value element by its label text.
     * e.g. findByLabel('车头号牌：') returns the text element next to that label.
     */
    function findByLabel(labelText, { container = document } = {}) {
        // Walk all elements that could be label containers
        const candidates = container.querySelectorAll('.k-form-item-label, label, .form-label, [class*="label"]');
        for (const el of candidates) {
            if (el.textContent.includes(labelText)) {
                // Climb to the row then find the value cell
                const row = el.closest('.k-form-item, .form-item, .form-row, tr');
                if (row) {
                    return row.querySelector('.form-item-text, .k-form-item-value, .form-value, td:last-child');
                }
            }
        }
        return null;
    }

    /**
     * Find an input by its placeholder text.
     */
    function findInputByPlaceholder(placeholder, { container = document } = {}) {
        return container.querySelector(`input[placeholder*="${placeholder}"]`)
            || container.querySelector(`input[placeholder="${placeholder}"]`);
    }

    /**
     * Find visible dropdown items. Returns a NodeList or empty array.
     */
    function findVisibleDropdownItems() {
        // Try Vue/Element-UI style dropdown
        const dropdowns = document.querySelectorAll('.k-select-dropdown, .el-select-dropdown, [class*="dropdown"]:not([class*="el-select-dropdown"])');
        for (const dd of dropdowns) {
            if (dd.offsetParent !== null) { // visible
                const items = dd.querySelectorAll('.k-select-item, .el-select-dropdown__item, li[class*="item"]');
                if (items.length > 0) return items;
            }
        }
        // Fallback: find any visible list with items
        return document.querySelectorAll('li:not([style*="display: none"])[class*="item"]');
    }

    /**
     * Trigger a full suite of DOM events on an element, used to wake up
     * Vue / React / framework bindings after programmatic value changes.
     */
    function triggerInputEvents(el) {
        // For React: use native input setter to trigger React's synthetic event
        const nativeInputValueSetter = Object.getOwnPropertyDescriptor(
            window.HTMLInputElement.prototype, 'value'
        ).set;
        nativeInputValueSetter.call(el, el.value);
        // For Vue 2/3 and vanilla: dispatch standard events
        for (const type of ['input', 'change', 'keydown', 'keyup', 'focus', 'blur']) {
            el.dispatchEvent(new Event(type, { bubbles: true }));
        }
        // Composition events for some frameworks
        el.dispatchEvent(new Event('compositionstart', { bubbles: true }));
        el.dispatchEvent(new Event('compositionend',   { bubbles: true }));
    }

    /**
     * Dynamically detect the Vue scoped-data attribute (data-v-xxxxxxxx)
     * from a search-button element. Returns the attribute name or null.
     * This eliminates the hardcoded `data-v-0258d9f9` that breaks on every build.
     */
    function detectVueScopeAttr() {
        const searchBtn = document.querySelector(`button.${CONFIG.selectors.searchButtonClass}`);
        if (!searchBtn) return null;
        // Walk up to find an ancestor (or self) with a data-v-* attribute
        let el = searchBtn;
        while (el && el !== document.body) {
            for (const attr of el.attributes) {
                if (/^data-v-[0-9a-f]+$/i.test(attr.name)) {
                    LOG.debug('检测到 Vue scope 属性:', attr.name);
                    return attr.name;
                }
            }
            el = el.parentElement;
        }
        return null;
    }

    // =========================================================================
    // TOAST — single-instance notification overlay
    // =========================================================================
    let activeToast = null;
    let toastTimer = null;

    function showToast(message, duration = CONFIG.toast.defaultDuration) {
        if (activeToast) {
            activeToast.remove();
            activeToast = null;
        }
        if (toastTimer) {
            clearTimeout(toastTimer);
            toastTimer = null;
        }

        const toast = document.createElement('div');
        toast.textContent = message;
        Object.assign(toast.style, {
            position: 'fixed',
            top: '20px',
            left: '50%',
            transform: 'translateX(-50%)',
            padding: '10px 20px',
            backgroundColor: 'rgba(0, 0, 0, 0.7)',
            color: 'white',
            borderRadius: '5px',
            fontSize: '24px',
            zIndex: '9999',
            pointerEvents: 'none',
            transition: 'opacity 0.3s',
        });
        document.body.appendChild(toast);
        activeToast = toast;

        if (duration > 0) {
            toastTimer = setTimeout(() => {
                if (activeToast === toast) {
                    toast.style.opacity = '0';
                    setTimeout(() => {
                        if (activeToast === toast) {
                            toast.remove();
                            activeToast = null;
                        }
                    }, 300);
                }
            }, duration);
        }
    }

    // =========================================================================
    // STATE — localStorage-backed persistence
    // =========================================================================
    const State = {
        get autoRefresh() {
            return localStorage.getItem(CONFIG.storage.autoRefresh) === 'true';
        },
        set autoRefresh(val) {
            localStorage.setItem(CONFIG.storage.autoRefresh, String(val));
        },
        get licensePlate() {
            return GM_getValue(CONFIG.storage.licensePlate, null);
        },
        set licensePlate(val) {
            GM_setValue(CONFIG.storage.licensePlate, val);
        },
        get shouldAutoQuery() {
            return GM_getValue(CONFIG.storage.shouldAutoQuery, false);
        },
        set shouldAutoQuery(val) {
            GM_setValue(CONFIG.storage.shouldAutoQuery, val);
        },
    };

    // =========================================================================
    // RETRY HELPER — exponential backoff
    // =========================================================================
    function createRetry(fn, {
        baseDelay = CONFIG.monitor.retryBaseDelay,
        maxDelay = CONFIG.monitor.retryMaxDelay,
        maxAttempts = 5,
        onRetry = null,
    } = {}) {
        let attempt = 0;
        let timer = null;

        function run() {
            attempt++;
            try {
                fn();
                attempt = 0; // success — reset
            } catch (e) {
                LOG.warn(`重试 ${attempt}/${maxAttempts}:`, e.message);
                if (attempt < maxAttempts) {
                    const delay = Math.min(baseDelay * Math.pow(2, attempt - 1), maxDelay);
                    if (onRetry) onRetry(attempt, delay);
                    timer = setTimeout(run, delay);
                } else {
                    LOG.error('达到最大重试次数，放弃');
                }
            }
        }

        return {
            start() { run(); },
            cancel() { if (timer) { clearTimeout(timer); timer = null; } },
        };
    }

    // =========================================================================
    // CLEANUP REGISTRY — centralised teardown
    // =========================================================================
    class CleanupRegistry {
        constructor() {
            this._fns = [];
        }
        add(fn) {
            if (typeof fn === 'function') this._fns.push(fn);
        }
        run() {
            const fns = this._fns.splice(0);
            for (const fn of fns) {
                try { fn(); } catch (e) { LOG.error('清理函数出错:', e); }
            }
        }
    }

    // =========================================================================
    // PAGE: WorkBill (工单列表) — auto-refresh
    // =========================================================================
    function initWorkBill(cleanup) {
        LOG.info('初始化工单列表页面');

        let timer = null;
        let refreshInterval = randomInterval();
        let vueScopeAttr = null; // detected at runtime

        function randomInterval() {
            return Math.floor(Math.random() *
                (CONFIG.refresh.maxInterval - CONFIG.refresh.minInterval + 1)) +
                CONFIG.refresh.minInterval;
        }

        function clickSearchButton() {
            // Strategy 1: detect & use the current Vue scope attribute
            if (!vueScopeAttr) {
                vueScopeAttr = detectVueScopeAttr();
            }
            if (vueScopeAttr) {
                const scoped = document.querySelectorAll(`[${vueScopeAttr}]`);
                for (const el of scoped) {
                    const btn = el.querySelector(`button.${CONFIG.selectors.searchButtonClass}`);
                    if (btn) { btn.click(); return; }
                }
            }
            // Strategy 2: fallback — find by class directly
            const btn = document.querySelector(`button.${CONFIG.selectors.searchButtonClass}`);
            if (btn) {
                btn.click();
                return;
            }
            // Strategy 3: find any button whose text suggests "search"
            const searchBtn = findButtonByText('搜索') || findButtonByText('查询');
            if (searchBtn && searchBtn.classList.contains(CONFIG.selectors.searchButtonClass)) {
                searchBtn.click();
                return;
            }
            LOG.warn('未找到搜索按钮，将在下一轮重试');
        }

        function resumeTimer() {
            if (timer) return;
            timer = setInterval(clickSearchButton, refreshInterval);
            LOG.debug('自动刷新已恢复，间隔:', refreshInterval, 'ms');
        }

        function pauseTimer() {
            if (timer) {
                clearInterval(timer);
                timer = null;
                LOG.debug('自动刷新已暂停');
            }
        }

        function start() {
            if (timer) return;
            refreshInterval = randomInterval();
            resumeTimer();
            State.autoRefresh = true;
            showToast('已开启自动更新工单，Ctrl+Alt+E 切换');
        }

        function stop() {
            pauseTimer();
            State.autoRefresh = false;
            showToast('已关闭自动更新工单，Ctrl+Alt+E 切换', CONFIG.toast.stickyDuration);
        }

        function toggle() {
            if (State.autoRefresh) {
                stop();
            } else {
                start();
            }
        }

        function onKeydown(e) {
            if (e.ctrlKey && e.altKey && e.key === CONFIG.hotkey.key) {
                toggle();
            }
        }

        function onVisibilityChange() {
            if (document.visibilityState === 'visible') {
                if (State.autoRefresh && !timer) {
                    LOG.info('页面恢复可见，重新启动自动刷新');
                    resumeTimer();
                }
            }
            // Note: we intentionally do NOT pause on hidden —
            // the interval is harmless and keeps the state simple.
            // If the user wants to save resources, they can toggle off.
        }

        // --- Init ---
        document.addEventListener('keydown', onKeydown);
        document.addEventListener('visibilitychange', onVisibilityChange);
        cleanup.add(() => {
            document.removeEventListener('keydown', onKeydown);
            document.removeEventListener('visibilitychange', onVisibilityChange);
            pauseTimer();
        });

        if (State.autoRefresh) {
            resumeTimer();
            showToast(`自动刷新运行中 (${refreshInterval / 1000}s)`, 2000);
        } else {
            showToast('未开启自动更新工单！Ctrl+Alt+E 开启', CONFIG.toast.stickyDuration);
        }
    }

    // =========================================================================
    // PAGE: WorkBillDetail (工单详情) — license-plate → monitor bridge
    // =========================================================================
    function initWorkBillDetail(cleanup) {
        LOG.info('初始化工单详情页面');

        function getLicensePlate() {
            const valueEl = findByLabel(CONFIG.selectors.licensePlateLabel);
            return valueEl?.textContent?.trim() || null;
        }

        const btn = document.createElement('button');
        btn.id = 'custom-dolphin-btn';
        btn.textContent = '跳转到监控查询';
        document.body.appendChild(btn);

        function onClick() {
            const plate = getLicensePlate();
            if (plate) {
                LOG.info('获取到车牌号:', plate);
                State.licensePlate = plate;
                State.shouldAutoQuery = true;
                window.open('https://dolphin.yonmen.com/web/#/entiremonitor');
            } else {
                alert('未能获取车牌号，请检查页面结构');
                LOG.error('车牌号元素未找到 — 查找标签:', CONFIG.selectors.licensePlateLabel);
            }
        }

        btn.addEventListener('click', onClick);
        cleanup.add(() => {
            if (btn && btn.parentNode) {
                btn.parentNode.removeChild(btn);
            }
        });
    }

    // =========================================================================
    // PAGE: Monitor (监控查询) — auto-query from stored plate
    // =========================================================================
    function initMonitor(cleanup) {
        LOG.info('初始化监控查询页面');

        let retryController = null;

        function handleAutoQuery() {
            const plate = State.licensePlate;
            if (!plate) {
                LOG.error('未获取到车牌号 (GM_getValue 为空)');
                return;
            }

            LOG.info('开始自动查询，车牌号:', plate);

            // Step 1: Find the plate input
            const plateInput = findInputByPlaceholder(CONFIG.selectors.licensePlateInput);
            if (!plateInput) {
                throw new Error('未找到车牌输入框 (placeholder: ' + CONFIG.selectors.licensePlateInput + ')');
            }

            // Step 2: Set value + trigger all framework events
            plateInput.value = plate;
            triggerInputEvents(plateInput);
            LOG.debug('已设置车牌号并触发事件');

            // Step 3: Wait for dropdown, click matching item, then click query
            waitForDropdownAndClick(plate);
        }

        function waitForDropdownAndClick(plate) {
            const start = Date.now();
            const interval = setInterval(() => {
                const items = findVisibleDropdownItems();
                let matched = null;

                for (const item of items) {
                    const text = item.textContent || '';
                    const title = item.getAttribute('title') || '';
                    if (text.includes(plate) || title.includes(plate) ||
                        item.querySelector(`[title="${plate}"]`)) {
                        matched = item;
                        break;
                    }
                }

                if (matched) {
                    LOG.info('找到匹配下拉项:', matched.textContent.trim());
                    matched.click();
                    clearInterval(interval);
                    setTimeout(clickQueryButton, 500);
                } else if (Date.now() - start > CONFIG.monitor.dropdownTimeout) {
                    LOG.warn('下拉选项未出现，尝试直接查询');
                    clearInterval(interval);
                    clickQueryButton();
                }
            }, CONFIG.monitor.dropdownPollInterval);
            cleanup.add(() => clearInterval(interval));
        }

        function clickQueryButton() {
            const btn = findButtonByText(CONFIG.selectors.queryButtonText);
            if (btn) {
                btn.click();
                LOG.info('已点击查询按钮');
                State.shouldAutoQuery = false;
            } else {
                LOG.warn('未找到查询按钮');
                throw new Error('未找到查询按钮');
            }
        }

        // --- Init ---
        if (State.shouldAutoQuery) {
            retryController = createRetry(handleAutoQuery, {
                onRetry: (attempt, delay) => {
                    LOG.debug(`自动查询将在 ${delay}ms 后第 ${attempt} 次重试`);
                },
            });
            setTimeout(() => retryController.start(), CONFIG.monitor.queryDelay);
            cleanup.add(() => { if (retryController) retryController.cancel(); });
        } else {
            LOG.info('未设置自动查询标记，保持初始状态');
        }
    }

    // =========================================================================
    // ROUTER — event-driven with MutationObserver + polling fallback
    // =========================================================================
    function createRouter() {
        const isDolphin = window.location.host.includes('dolphin.yonmen.com');
        const isGongdan  = window.location.host.includes('gongdan.yonmen.com');

        let currentPage = null;       // identifier for the active page module
        let currentCleanup = new CleanupRegistry();

        const PAGE_TYPES = {
            workBill:       'workBill',
            workBillDetail: 'workBillDetail',
            monitor:        'monitor',
            other:          'other',
        };

        function identifyPage() {
            const hash = window.location.hash;
            const href = window.location.href;

            if (isDolphin && href.includes('#/entiremonitor')) return PAGE_TYPES.monitor;
            if (isGongdan && (hash === '#/app/workBill' || hash === '#/welcome/index')) return PAGE_TYPES.workBill;
            if (isGongdan && href.includes('#/app/workBillDetail')) return PAGE_TYPES.workBillDetail;
            return PAGE_TYPES.other;
        }

        function navigate(page) {
            if (page === currentPage) return;
            LOG.info(`路由切换: ${currentPage || '(初始)'} → ${page}`);

            // Teardown previous
            currentCleanup.run();
            currentCleanup = new CleanupRegistry();
            currentPage = page;

            // Setup new
            try {
                switch (page) {
                    case PAGE_TYPES.workBill:
                        initWorkBill(currentCleanup);
                        break;
                    case PAGE_TYPES.workBillDetail:
                        initWorkBillDetail(currentCleanup);
                        break;
                    case PAGE_TYPES.monitor:
                        initMonitor(currentCleanup);
                        break;
                    default:
                        LOG.debug('非目标页面，保持空闲');
                        break;
                }
            } catch (e) {
                LOG.error('页面初始化失败:', page, e);
            }
        }

        // --- Event-driven routing ---
        function onHashChange() {
            navigate(identifyPage());
        }

        // --- Initial route ---
        navigate(identifyPage());

        if (isDolphin) {
            // Dolphin: single-page, less complex — hashchange is enough
            window.addEventListener('hashchange', onHashChange);
            return () => {
                window.removeEventListener('hashchange', onHashChange);
                currentCleanup.run();
            };
        }

        // --- Gongdan: SPA with complex routing — multi-layer detection ---
        window.addEventListener('hashchange', onHashChange);
        window.addEventListener('popstate', onHashChange);

        // MutationObserver: detect DOM mutations that indicate a page transition
        // (e.g. Vue Router replaces the <router-view> content without hashchange)
        const observer = new MutationObserver(() => {
            const newPage = identifyPage();
            if (newPage !== currentPage) {
                navigate(newPage);
            }
        });
        // Observe the body for major subtree changes, throttled by MutationObserver's built-in batching
        observer.observe(document.body, { childList: true, subtree: true });

        // Long-interval fallback poll — catches edge cases where no event fires
        const fallbackTimer = setInterval(() => {
            const newPage = identifyPage();
            if (newPage !== currentPage) {
                LOG.debug('兜底轮询检测到页面变化');
                navigate(newPage);
            }
        }, CONFIG.router.fallbackPollMs);

        return () => {
            window.removeEventListener('hashchange', onHashChange);
            window.removeEventListener('popstate', onHashChange);
            observer.disconnect();
            clearInterval(fallbackTimer);
            currentCleanup.run();
        };
    }

    // =========================================================================
    // GLOBAL INIT
    // =========================================================================
    function main() {
        // Inject button styles (kept at global scope for the detail-page button)
        GM_addStyle(`
            #custom-dolphin-btn {
                position: fixed;
                top: 38.2%;
                left: 1.5%;
                transform: translateY(-50%);
                z-index: 9999;
                padding: 10px 15px;
                background-color: #ec6133;
                color: white;
                border: none;
                border-radius: 4px;
                cursor: pointer;
                font-size: 14px;
                box-shadow: 0 10px 20px rgba(0, 0, 0, 0.15);
                transition: background-color 0.2s;
            }
            #custom-dolphin-btn:hover {
                background-color: #ff8355;
            }
        `);

        // Persist auto-refresh state on unload
        window.addEventListener('beforeunload', () => {
            localStorage.setItem(CONFIG.storage.autoRefresh, String(State.autoRefresh));
        });

        const routerCleanup = createRouter();

        // Expose cleanup for potential external use
        window.__gongdanCleanup = () => {
            routerCleanup();
            if (activeToast) {
                activeToast.remove();
                activeToast = null;
            }
            LOG.info('工单助手已完全清理');
        };
    }

    // --- Boot ---
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', main);
    } else {
        main();
    }

})();