/**
 * 预警处置模式的「事件 + 预警/报警切换」状态（票 13）。
 *
 * 职责边界，沿用票 05/11/17/18 已定的分工：
 *   · 本 store 只做三件事：持有切换状态（`mode` 当前是预警还是报警）、
 *     调 `services/eventApi.js` 取跨设备当前事件（当 mode 变了就换族重取）、
 *     把结果收成一个 `currentEvents` 分区；
 *   · 事件怎么画归 `domain/eventList.js`（纯函数，本文件不做字段改名）；
 *   · 路径拼接、凭据、mock/real 切换归 `services/`（本文件不出现 fetched、裸字段名）。
 *
 * 为什么「切换」在 store 而不是组件里：票 19 要求「四个面板均支持预警/报警切换」——
 * 切换是**共享**状态（当前预警/历史分析/预警效率/预警分析四块面板读同一个当前族），
 * 放组件里每块各存一份，切了一块其它三块不会跟着变。本票先把 store 状态落好，
 * 组件（`EventListPane.vue`）只消费它，票 19 的四块面板直接复用同一份。
 *
 * 竞态收口沿用票 10/11 的 token 纪律：快速连续切 预警→报警→预警 时，
 * 只让最后一次请求落进分区（迟到的响应丢弃），不会出现"显示报警却把预警数据挂上去"。
 *
 * 票 61（统一分页批次三）新增**服务端页码状态**：当前事件表与历史事件单窗范围都按
 * `page`+`pageSize=10` 发请求，页码是本 store 的视图状态（`currentPage`/`historyPage`）。
 * 纪律有三条：① 条件（mode/range/industry/level/status）变化 → 页码回第 1 页；
 * ② 定时刷新/同条件重取**不复位**（条文 6 的反面），越界由回显夹回最后一页；
 * ③ 翻一页只重取该分区（不牵连另外三块面板），并用同一 token 作废迟到的页响应。
 */
import { computed, ref } from 'vue'
import { defineStore } from 'pinia'
import { SECTION_STATE, section } from '../domain/sectionState.js'
import { REQUEST_REASON } from '../domain/requestReason.js'
import { EVENT_FAMILY } from '../domain/events.js'
import { currentEventsView, isKnownEventMode, refreshedEventSelection } from '../domain/eventList.js'
import { fetchCurrentEvents } from '../services/eventApi.js'
import { EVENT_DETAIL_RESULT, eventDetailView, planEventLocate } from '../domain/eventDetail.js'
import { getCameraState, getAssociatedDeviceState, highlightMapObject, setCameraFocus } from '../services/mapService.js'
import { useMapStore } from './mapStore.js'
import { EVENT_RANGES } from '../domain/warningResponsePanels.js'
import { eventTimeWindow, historyWindows } from '../domain/eventRange.js'
import { fetchEventAnalysis, fetchEventHistory, fetchHandlingEfficiency, fetchIncidentTrend } from '../services/warningResponseApi.js'
import { fetchWorkOrderList } from '../services/detailApi.js'
import { PAGE_SIZE, serverPageView } from '../domain/pagination.js'

/**
 * 会触发「回第 1 页」的条件键（条文 5/6；定时刷新不经过这里）。
 *
 * 票 67 补 `scope`（当前范围）。它必须进这张表：片区现在真的会下发给预警分析端点
 * （`warningResponseApi.js` 的 `acceptsDistrict`），换片区就是换了一批数据，
 * 页码留在第 3 页会翻到一个在新范围里根本不存在的页。
 */
const CONDITION_KEYS = ['mode', 'range', 'industry', 'level', 'status', 'scope']

/**
 * 报警效率面板「当前工单列表」的页大小（票 65）。
 *
 * 与事件表的 `PAGE_SIZE`（10）**刻意分开**：两者是不同端点、不同翻页语义，
 * 共用一个常量会让「改事件页大小」意外改掉工单列表（票 61 变异 M1 记过同类教训）。
 */
const WORK_ORDER_LIST_PAGE_SIZE = 5

/**
 * 效率面板「报警列表 / 预警列表」每页条数（票 71）。
 *
 * 与事件表 `PAGE_SIZE`（10）分开、也与工单列表的 5 分开：三者是**不同块**、
 * 不同翻页语义，共用一个常量会让「调事件页大小」意外改掉另外两块（票 61 变异 M1 同款教训）。
 * 取 5 是因为这块与趋势图同屏，行数是可读性约束而不是数据约束。
 */
const EFFICIENCY_EVENT_PAGE_SIZE = 5

/**
 * 「当前预警/报警」列表的**取数上限**（维护者 2026-10-29 第 4 条）。
 *
 * 为什么改成一次取全、而不是服务端逐页：这张表**本地过滤掉了已终态事件**
 * （只留还在进行中的），而服务端分页的 `total`/`totalPages` 含已终态 ——
 * 两边口径不一致时就会画出「只有 1 行却显示 10 页、且能翻到空页」。
 * 一次取全（上限取后端 pageSize 上限 1000）后按**可见行**前端分页，页码与内容必然一致。
 * 超过上限时 `currentEventsView` 会置 `truncated`，界面如实标注「已加载 N / 共 M」。
 */
const CURRENT_EVENTS_FETCH_SIZE = 1000

/** 未取数时的分区（与其它 store 同形，`loaded:false` 表示"还没请求过"）。 */
function pending() {
    return { state: SECTION_STATE.EMPTY, reason: '', mode: '', data: null, missing: [], freshness: '', retained: false, loaded: false }
}

function initialSections() {
    return {
        currentEvents: pending(),
        historyAnalysis: pending(),
        responseEfficiency: pending(),
        eventAnalysis: pending(),
        // 票 65：报警效率面板的「当前工单列表」（全量工单端点，与上面四块各自成败）。
        // 分区名刻意叫 `workOrderList`：store 只说领域词汇，不照抄后端字段名
        // （照抄会被 t13 的 I1 守卫判红，票 05 纪律）。
        workOrderList: pending(),
    }
}

export const useEventStore = defineStore('eventStore', () => {
    /** 当前切换状态：`WARNING`（预警）或 `ALARM`（报警）。默认预警（`/events/current` 的 mode 必填）。 */
    const mode = ref(EVENT_FAMILY.WARNING)

    /**
     * 「预警类型」本地筛选（G11，票 07 的落点），`{ code, label }`；空 code ＝ 未筛选。
     *
     * 为什么是**本地**筛选：`/events/current` 不收 type 参数（后端未冻结），而且当前列表
     * 本身只含"可解析设备"的子集。所以这里只在**已加载行**上做减法，不冒充服务端筛选，
     * 覆盖范围由 `currentEventsView` 的 `filterView` 如实回显（票 07 的缺口说明）。
     * 切族/重置时清空：类型码是预警族的词汇，挂到报警列表上只会在另一个族里静默漏筛。
     */
    const warningTypeFilter = ref({ code: '', label: '' })

    /** 当前事件分区（`/events/current` 的整体响应；成败由内部事件分区状态表达）。 */
    const sections = ref(initialSections())

    /** 预警处置三块聚合面板共享的时间范围，默认近 7 天。 */
    const range = ref('7d')

    /** 正在取数（界面只做轻提示；分区成败仍由分区自己说）。 */
    const loading = ref(false)

    /** 当前事件表的服务端页码（1 起，`pageSize=PAGE_SIZE`）。 */
    const currentPage = ref(1)

    /** 历史事件**单窗范围**的服务端页码（多窗合并范围无全局页，渲染层自持页码）。 */
    const historyPage = ref(1)

    /**
     * 「当前工单列表」的服务端页码（票 65）。
     *
     * 与上面两个页码**互不牵连**：翻工单页只重取工单分区，不动事件表/历史/效率/分析
     * （与「翻一页只重取该分区」同一条纪律）。
     */
    const workOrderPage = ref(1)

    /**
     * 效率面板「报警列表 / 预警列表」的服务端页码（票 71）。
     *
     * 与上面三个页码**互不牵连**：翻列表页只重取效率分区（那一块的行由该端点下发），
     * 不动事件表/历史/分析/工单列表。
     */
    const efficiencyPage = ref(1)

    /** 最后一个「当前事件分区的领域对象」（视图层读它，避免每次都重解构 section）。 */
    const currentDomain = ref(null)

    /** 当前打开的事件详情与地图定位结果；返回时不重取列表，保留 mode/筛选/分页上下文。 */
    const selectedEvent = ref(null)
    const locate = ref({ result: '', deviceCode: '', pointCode: '', reasonText: '' })

    /** 请求序号：翻页/切族/切范围共用一个令牌，迟到的页响应整批丢弃（token 纪律）。 */
    let token = 0

    /**
     * 工单列表专用的令牌（票 65）。
     *
     * 为什么不共用 `token`：那份是全局面板的令牌，翻一个工单页就把它 +1，会把在途的
     * 四块面板响应整批作废（用户只是翻了个工单页，另外三块却停在旧数据上）。
     * 工单列表是**独立分区**，竞态也该独立收口。
     */
    let workOrderToken = 0

    /**
     * 效率面板事件列表的令牌（票 71）。
     *
     * 理由与 `workOrderToken` 一字不差：效率块是**独立分区**，翻它一页不该把在途的
     * 另外四块响应整批作废（`token` 是全局面板令牌）。
     */
    let efficiencyToken = 0

    /**
     * 效率面板列表翻页时**钉住**的请求条件（票 71）。
     *
     * 与 `workOrderWindow` 同一理由：翻页期间窗口必须一个字节都不变。若每次翻页都重算
     * `eventTimeWindow()`，`endTime` 会毫秒级后移 —— 边界事件就会在页与页之间重复或消失。
     * 存整份条件（mode/range/industry/scope/窗口）而不只是窗口：列表是**同一端点**的分页，
     * 任何一项漂移都会让「第 2 页」不再属于「第 1 页」那批事件。
     */
    let efficiencyConditions = null

    /**
     * 工单列表当前钉住的时间窗（票 65，2026-10-22）。
     *
     * 由 `loadPanels` 在每次取数时写入，`setWorkOrderPage` 直接复用 —— 翻页期间窗口必须
     * 一个字节都不变。若每次翻页都重算 `eventTimeWindow()`，`endTime` 会毫秒级后移，
     * 边界工单就会在页与页之间重复或消失（P10 断言钉住这件事）。
     */
    let workOrderWindow = null

    /** 请求注入（config / fetchImpl / industry…）：取一次让后续所有取数共用。 */
    let requestOptions = {}

    function configure(options = {}) {
        requestOptions = { ...requestOptions, ...options }
    }

    /** 直接写入分区（走查与单测注入用）。 */
    function setSection(name, value) {
        sections.value = { ...sections.value, [name]: { ...value, loaded: true } }
    }

    /** 条件的可比较快照（只取值，不按对象身份——视图计划每次重算都是新对象）。 */
    function conditionSnapshot() {
        return {
            mode: mode.value,
            range: range.value,
            industry: requestOptions.industry,
            level: requestOptions.level,
            status: requestOptions.status,
            scope: requestOptions.scope,
        }
    }

    function selectedRange() {
        return EVENT_RANGES.find((item) => item.key === range.value) || EVENT_RANGES[0]
    }

    /** 四块面板共享的请求条件（`/events/current` 与三块聚合接口同一份）。 */
    function activeConditions() {
        const active = selectedRange()
        return { ...requestOptions, ...eventTimeWindow(active.type), mode: mode.value, rangeType: active.type }
    }

    /** 该范围是否存在「全局页」（单窗才有；多窗合并范围只能对已加载集合分页）。 */
    function singleHistoryWindow() {
        const active = selectedRange()
        const window = eventTimeWindow(active.type)
        return historyWindows(window.startTime, window.endTime).length <= 1
    }

    /** 当前事件页的后端回显 → 控件视图（失败/无回显回 null，不夹、不猜）。 */


    /** 历史事件页的后端回显 → 控件视图（只有服务端分页形态才有全局页）。 */
    function historyPageView(result) {
        const paging = result && result.data && result.data.paging
        if (!paging || paging.mode !== 'server') return null
        return serverPageView(paging, Array.isArray(result.data.events) ? result.data.events.length : 0)
    }

    async function fetchCurrentAt(page, pageSize = PAGE_SIZE) {
        try {
            return await fetchCurrentEvents({ ...activeConditions(), page, pageSize })
        } catch (error) {
            return section(SECTION_STATE.FAILED, { reason: REQUEST_REASON.UNREACHABLE, data: null })
        }
    }

    async function fetchHistoryAt(page) {
        try {
            return await fetchEventHistory({ ...activeConditions(), page, pageSize: PAGE_SIZE })
        } catch (error) {
            return section(SECTION_STATE.FAILED, { reason: REQUEST_REASON.UNREACHABLE, data: null })
        }
    }

    /**
     * 取一页并做越界夹回（条文 6：数据变少时页码越界 ⇒ 夹回最后一页再取一次）。
     * 只在「后端回显的分页视图说当前页超过了最后一页」时补一次请求，不递归。
     * @returns {Promise<object|null>} `null` ＝ 期间又发生了更新的请求（token 已变），调用方应放弃
     */
    async function loadPage(request, pageRef, pageViewOf, mine) {
        let result = await request(pageRef.value)
        if (mine !== token) return null
        const view = pageViewOf(result)
        if (view && view.page !== pageRef.value) {
            pageRef.value = view.page
            result = await request(pageRef.value)
            if (mine !== token) return null
            const clamped = pageViewOf(result)
            if (clamped) pageRef.value = clamped.page
        }
        return result
    }

    /** 当前「事件 + 切换」视图（领域层现算；组件与走查都读它）。 */
    const view = computed(() => {
        // G11：类型筛选只在预警族生效（报警列表没有这套类型码）。
        const filter = mode.value === EVENT_FAMILY.WARNING ? warningTypeFilter.value : { code: '', label: '' }
        // 页码是**前端**状态（取全后按可见行分页），所以这里要把它交给视图。
        const options = { warningType: filter.code, warningTypeLabel: filter.label, page: currentPage.value }
        // 已取到数据：从领域对象读事件分区（行 + 内部状态）。
        if (currentDomain.value) return currentEventsView(currentDomain.value, undefined, options)
        // 还没取过 / 整体失败：用整个分区驱动占位措辞（pending → 正在取数；failed → 加载失败）。
        return currentEventsView(null, sections.value.currentEvents, options)
    })

    /**
     * 设置/清除预警类型本地筛选（G11）。**不发请求**：只是换一份已加载行的视图。
     * @param {string} code warning_type 码（空串 = 清除）
     * @param {string} [label] 展示名（缺省回 code）
     */
    function setWarningTypeFilter(code, label = '') {
        const next = typeof code === 'string' ? code.trim() : ''
        warningTypeFilter.value = next ? { code: next, label: label || next } : { code: '', label: '' }
        return warningTypeFilter.value
    }

    function clearWarningTypeFilter() {
        warningTypeFilter.value = { code: '', label: '' }
        return warningTypeFilter.value
    }

    /**
     * 取预警处置四块面板。切换 mode/range/筛选时四块共享一次条件，迟到响应整批丢弃；
     * 条件变化同时把两个服务端页码回第 1 页（**定时刷新不带条件 ⇒ 页码保持**）。
     */
    async function loadPanels(options = {}) {
        const before = conditionSnapshot()
        if (options.mode !== undefined && isKnownEventMode(options.mode)) mode.value = options.mode
        if (options.range !== undefined && EVENT_RANGES.some((item) => item.key === options.range)) range.value = options.range
        if (Object.keys(options).some((key) => !['mode', 'range'].includes(key))) configure(options)
        const after = conditionSnapshot()
        if (CONDITION_KEYS.some((key) => before[key] !== after[key])) {
            currentPage.value = 1
            historyPage.value = 1
            // 票 65：条件变了，工单列表也回第 1 页（条文 5；定时刷新不带条件 ⇒ 页码保持）。
            workOrderPage.value = 1
            // 票 71：效率面板的两族列表同理（换族/换范围/换筛选 = 换了一批事件）。
            efficiencyPage.value = 1
        }

        const active = activeConditions()
        // 票 65：把窗口**钉**在这一次取数上。`eventTimeWindow()` 每次调用都按 `Date.now()`
        // 重算，首屏与翻页各算一次就会毫秒级漂移 —— 翻页时窗口在动，边界工单会重复或漏掉。
        workOrderWindow = { startTime: active.startTime, endTime: active.endTime }
        // 票 71：效率列表翻页复用**整份**条件（含刚钉下的窗口），不只存窗口 ——
        // 列表是该端点的分页，任何一项条件漂移都会让第 2 页不再属于第 1 页那批事件。
        efficiencyConditions = { ...active }
        token += 1
        const mine = token
        loading.value = true
        const requests = await Promise.all([
            // 维护者 2026-10-29 第 4 条：当前事件**一次取全**，页码交给视图按可见行算。
            // 逐页取会让服务端 total（含已终态）与屏上可见行两套口径打架。
            fetchCurrentEvents({ ...active, page: 1, pageSize: CURRENT_EVENTS_FETCH_SIZE }),
            fetchEventHistory({ ...active, page: historyPage.value, pageSize: PAGE_SIZE }),
            // 票 71：效率端点同时供出两族的事件列表，页码取 `efficiencyPage`
            // （定时刷新保持当前页；条件变化已在上方复位成第 1 页）。
            fetchHandlingEfficiency({ ...active, page: efficiencyPage.value, pageSize: EFFICIENCY_EVENT_PAGE_SIZE }),
            fetchEventAnalysis(active),
            // 票 65：报警效率面板的「当前工单列表」走**全量工单**端点（另一个粒度：
            // handling-efficiency 只给状态计数、不返回工单实体）。预警族不画工单列表，
            // 但这里照取不误——切族时不必等一次新往返，且失败只影响那一块分区。
            // 页码取 `workOrderPage`（定时刷新保持当前页），时间窗用刚钉下的那一份。
            fetchWorkOrderList(
                { page: workOrderPage.value, pageSize: WORK_ORDER_LIST_PAGE_SIZE, startTime: workOrderWindow.startTime, endTime: workOrderWindow.endTime },
                requestOptions,
            ),
            // 票 71 返工：逐日 新增/处置/累计 三条线要**带 status 的事件行**，而效率端点不返回
            // status（实测），所以另取一次 history-analysis（同一时间窗、总数实测一致）。
            // **必须放在数组末尾**：下面的解构按位置取值，插在中间会让后面每一项整体错位
            // （返工第二版正是这样把 analysis/workOrderList/incidentTrend 全错拿了一格）。
            // 失败只影响趋势那一块（分区独立纪律），不拖垮效率读数。
            fetchIncidentTrend(active).catch(() => null),
        ].map(async (request) => {
            try {
                return await request
            } catch (error) {
                return section(SECTION_STATE.FAILED, { reason: REQUEST_REASON.UNREACHABLE, data: null })
            }
        }))
        if (mine !== token) return sections.value

        const [current, history, efficiency, analysis, workOrderList, incidentTrend] = requests
        // 票 71 返工：把逐日趋势挂进效率分区（domain 只读 `incidentTrend` 字段）。
        // 取失败（null）时保持缺失 ⇒ 界面说「不画」的原因，不画假线。
        // **同时**用这批带 status 的行替换列表数据源：效率端点不返回 status，
        // 用它画列表会把每条都写成「状态未发布」（维护者 2026-10-29 第 1 条反馈）。
        const trend = incidentTrend && incidentTrend.days ? incidentTrend : null
        const trendRows = trend && Array.isArray(incidentTrend.rows) ? incidentTrend.rows : null
        const efficiencyWithTrend = efficiency && efficiency.data
            ? {
                  ...efficiency,
                  data: {
                      ...efficiency.data,
                      ...(trend ? { incidentTrend: { days: trend.days, reason: trend.reason } } : {}),
                      // 事件行取自 history-analysis：条数与效率端点同源（实测同窗一致），
                      // 且带 status / updatedTime，列表与趋势因此看同一批事件。
                      ...(trendRows && trendRows.length ? { events: trendRows } : {}),
                      // **分页形态必须跟着换**：行是 history 的**全量集合**（每窗取到 1000 条上限），
                      // 不再是效率端点那一页。若保留效率端点的 `pagination`，列表会画出
                      // 「共 N 条 · 第 1/1 页」却把全量行都铺出来 —— 页码与内容对不上。
                      // 所以换成前端集合分页（`paging.merged`），并在页脚如实说明取数方式。
                      ...(trendRows && trendRows.length
                          ? {
                                pagination: null,
                                paging: {
                                    mode: "merged",
                                    // 真实窗口数（7 天 1 / 30 天 2 / 90 天 4）—— 页脚要照实说合并了几个窗。
                                    windowCount: incidentTrend && incidentTrend.windowCount ? incidentTrend.windowCount : 1,
                                    loaded: trendRows.length,
                                    rangeKey: String(active.rangeType || ""),
                                },
                            }
                          : {}),
                  },
              }
            : efficiency
        // 当前事件一次取全、页码由视图算 ⇒ 不再做「越界补取」（那套只对服务端分页有意义）。
        const safeCurrent = current
        if (mine !== token) return sections.value
        const safeHistory = await clampSettled(history, historyPage, historyPageView, fetchHistoryAt, mine)
        if (mine !== token) return sections.value

        sections.value = {
            currentEvents: { ...safeCurrent, loaded: true },
            historyAnalysis: { ...safeHistory, loaded: true },
            responseEfficiency: { ...efficiencyWithTrend, loaded: true },
            eventAnalysis: { ...analysis, loaded: true },
            workOrderList: { ...workOrderList, loaded: true },
        }
        currentDomain.value = safeCurrent.data || null
        selectedEvent.value = refreshedEventSelection(selectedEvent.value, currentDomain.value)
        loading.value = false
        return sections.value
    }

    /**
     * 已落定的一页若越界则夹回并补取一次（与 `loadPage` 同一判据）。
     * 并发批次取数时不能在 `Promise.all` 里改页码，所以夹回发生在整批回包之后。
     */
    async function clampSettled(result, pageRef, pageViewOf, request, mine) {
        if (mine !== token) return result
        const view = pageViewOf(result)
        if (!view || view.page === pageRef.value) {
            if (view) pageRef.value = view.page
            return result
        }
        pageRef.value = view.page
        const clamped = await request(pageRef.value)
        if (mine !== token) return result
        const clampedView = pageViewOf(clamped)
        if (clampedView) pageRef.value = clampedView.page
        return clamped
    }

    function setRange(next) {
        if (!EVENT_RANGES.some((item) => item.key === next) || next === range.value) return sections.value
        return loadPanels({ range: next })
    }

    /**
     * 当前事件表翻页（服务端页码分页）：只重取当前事件分区，其余三块不动。
     * 迟到的页响应由 token 作废；越界页码按回显夹回最后一页。
     * @param {number} next 目标页码（1 起）
     * @returns {Promise<object>} `sections.currentEvents`
     */
    async function setCurrentPage(next) {
        // 维护者 2026-10-29 第 4 条：当前事件已在 `loadPanels` 一次取全，
        // 翻页纯属**视图状态**（对可见行前端分页）—— 不发请求、不动分区。
        // 这样页码/总页数恒等于用户真的能看到的内容，不会出现「翻到空页」。
        const page = Math.max(1, Math.trunc(Number(next) || 1))
        currentPage.value = page
        return sections.value.currentEvents
    }

    /**
     * 历史事件单窗范围翻页（服务端页码分页）：只重取历史分析分区。
     * 多窗合并范围没有全局页，本入口不适用（渲染层对已加载集合分页）。
     * @param {number} next 目标页码（1 起）
     * @returns {Promise<object>} `sections.historyAnalysis`
     */
    async function setHistoryPage(next) {
        const page = Math.max(1, Math.trunc(Number(next) || 1))
        if (!singleHistoryWindow() || page === historyPage.value) return sections.value.historyAnalysis
        historyPage.value = page
        token += 1
        const mine = token
        // 与当前事件表同一条纪律：翻页保持旧内容，不闪空白（条文 8）。
        const result = await loadPage(fetchHistoryAt, historyPage, historyPageView, mine)
        if (!result) return sections.value.historyAnalysis
        sections.value = { ...sections.value, historyAnalysis: { ...result, loaded: true } }
        return sections.value.historyAnalysis
    }

    /**
     * 「当前工单列表」翻页（服务端页码分页；票 65）：只重取工单分区。
     *
     * 三条纪律与事件表翻页一致，只是竞态用**独立令牌**：
     *   · 翻页保持旧内容、不闪空白（条文 8）；
     *   · 页码越界由后端回显夹回（`serverPageView` 同一判据），夹回后同步到 `workOrderPage`；
     *   · 迟到的页响应整体丢弃（`workOrderToken` 变了就放弃）。
     *
     * @param {number} next 目标页码（1 起）
     * @returns {Promise<object>} `sections.workOrderList`
     */
    async function setWorkOrderPage(next) {
        const page = Math.max(1, Math.trunc(Number(next) || 1))
        if (page === workOrderPage.value) return sections.value.workOrderList
        workOrderPage.value = page
        workOrderToken += 1
        const mine = workOrderToken
        // 翻页必须用**首屏钉下的同一份时间窗**（不是现在重算一份）：
        // 少了窗口，第 2 页会悄悄变回全库口径；每次重算窗口，`endTime` 会毫秒级后移，
        // 边界工单就会在页与页之间重复或消失。两种情况都是「看不出来」的错。
        const window = workOrderWindow || activeConditions()
        let result
        try {
            result = await fetchWorkOrderList(
                { page, pageSize: WORK_ORDER_LIST_PAGE_SIZE, startTime: window.startTime, endTime: window.endTime },
                requestOptions,
            )
        } catch (error) {
            result = section(SECTION_STATE.FAILED, { reason: REQUEST_REASON.UNREACHABLE, data: null })
        }
        // 迟到响应丢弃：期间又翻过页/切过条件，这一页不落分区。
        if (mine !== workOrderToken) return sections.value.workOrderList
        const view = serverPageView(
            result && result.data && result.data.pagination,
            result && result.data && Array.isArray(result.data.orders) ? result.data.orders.length : 0,
        )
        // 后端夹回（如数据变少后第 3 页不存在）：以回显为准，不再补一次请求。
        if (view) workOrderPage.value = view.page
        sections.value = { ...sections.value, workOrderList: { ...result, loaded: true } }
        return sections.value.workOrderList
    }

    /**
     * 效率面板「报警列表 / 预警列表」翻页（服务端页码分页；票 71）：只重取效率分区。
     *
     * 三条纪律与事件表/工单列表翻页一致，竞态用**独立令牌**：
     *   · 翻页保持旧内容、不闪空白（条文 8）；
     *   · 页码越界由后端回显夹回（`serverPageView` 同一判据）并同步回 `efficiencyPage`；
     *   · 迟到的页响应整体丢弃（`efficiencyToken` 变了就放弃）。
     *
     * 请求条件必须用 `loadPanels` 钉下的那一份（`efficiencyConditions`）：重算窗口会让
     * `endTime` 毫秒级后移，边界事件在页与页之间重复或消失。
     *
     * @param {number} next 目标页码（1 起）
     * @returns {Promise<object>} `sections.responseEfficiency`
     */
    async function setEfficiencyPage(next) {
        const page = Math.max(1, Math.trunc(Number(next) || 1))
        if (page === efficiencyPage.value) return sections.value.responseEfficiency
        efficiencyPage.value = page
        efficiencyToken += 1
        const mine = efficiencyToken
        // 条件缺失（还没 loadPanels 过）时退回当前条件——那是首屏之前的情况，页码本就该是第 1 页。
        const active = efficiencyConditions || activeConditions()
        let result
        try {
            result = await fetchHandlingEfficiency({ ...active, page, pageSize: EFFICIENCY_EVENT_PAGE_SIZE })
        } catch (error) {
            result = section(SECTION_STATE.FAILED, { reason: REQUEST_REASON.UNREACHABLE, data: null })
        }
        // 迟到响应丢弃：期间又翻过页/切过条件，这一页不落分区。
        if (mine !== efficiencyToken) return sections.value.responseEfficiency
        const view = serverPageView(
            result && result.data && result.data.pagination,
            result && result.data && Array.isArray(result.data.events) ? result.data.events.length : 0,
        )
        // 后端夹回（数据变少后第 3 页不存在）：以回显为准，不再补一次请求。
        if (result && result.data && result.data.pagination) efficiencyPage.value = view.page
        sections.value = { ...sections.value, responseEfficiency: { ...result, loaded: true } }
        return sections.value.responseEfficiency
    }

    /**
     * 取当前事件列表（跨设备的 `/events/current`；票 13 的预警处置面板数据源）。
     *
     * `options.mode` 显式给（菜单面板里点别的族）时更新切换状态；没给就沿用当前族。
     * token 纪律：换族后旧的在途响应作废（迟到的预警不落进报警表）。
     * 票 61：`page`/`pageSize` 进请求；`page` 缺省回第 1 页（这是一次完整重取）。
     * @param {object} [options] `{ mode, industry, level, status, page, pageSize, config, fetchImpl }`
     * @returns {Promise<object>} `sections.currentEvents`
     */
    async function loadCurrentEvents(options = {}) {
        if (options.mode !== undefined && isKnownEventMode(options.mode)) mode.value = options.mode
        if (Object.keys(options).some((key) => !['mode', 'page', 'pageSize'].includes(key))) configure(options)
        // 维护者 2026-10-29 第 4 条：一次取全，页码是前端视图状态（见 CURRENT_EVENTS_FETCH_SIZE）。
        currentPage.value = Number.isInteger(options.page) && options.page > 0 ? options.page : 1
        token += 1
        const mine = token
        loading.value = true
        const result = await fetchCurrentAt(1, CURRENT_EVENTS_FETCH_SIZE)
        // 竞态令牌：这里不再经过 `loadPage`（那个函数内部做丢弃），所以必须**自己判**。
        // 少了这两行，快速切族时迟到的旧族响应会覆盖新族数据（t13 的 G4 实测抓到过）。
        if (mine !== token) return sections.value.currentEvents
        // 迟到的响应丢弃：mode/页码换过之后，旧请求的结果不得写进新分区。
        if (!result) return sections.value.currentEvents

        const next = { ...result, loaded: true }
        sections.value = { ...sections.value, currentEvents: next }
        currentDomain.value = result.data || null
        selectedEvent.value = refreshedEventSelection(selectedEvent.value, currentDomain.value)
        loading.value = false
        return next
    }

    /** 从当前列表打开详情；不改变当前列表数据或筛选上下文。 */
    function openEvent(event) {
        selectedEvent.value = event || null
        // 定位结果先清空：位置（设备码/点位码）由 `locateEvent` 按事件所在行的编码现算，
        // 这里只留一个"还没定位过"的空态，不预先冒充结果。
        locate.value = { result: '', code: (event && event.code) || '', deviceCode: '', pointCode: '', reasonText: '' }
        return selectedEvent.value
    }

    function closeEvent() {
        selectedEvent.value = null
        locate.value = { result: '', code: '', deviceCode: '', pointCode: '', reasonText: '' }
        // 收起详情时把强调还原（传空 = 全部回到常态），地图上不留上一轮的高亮。
        highlightMapObject([])
    }

    async function locateEvent(event = selectedEvent.value, deps = {}) {
        if (event) selectedEvent.value = event
        const current = selectedEvent.value
        const mapStore = useMapStore()
        const objects = deps.objects || [
            ...getAssociatedDeviceState().plan.filter((row) => row.placement === 'drawn').map((row) => ({ ...row, kind: 'monitoring-device' })),
            ...mapStore.summary.objects,
        ]
        const mapReady = deps.mapReady === undefined ? !!getCameraState() : !!deps.mapReady
        const plan = planEventLocate(current, objects, mapReady)
        locate.value = { result: plan.result, deviceCode: plan.deviceCode, pointCode: plan.pointCode, reasonText: plan.reasonText }
        if (plan.result !== EVENT_DETAIL_RESULT.OK) return locate.value
        const focus = deps.focus || setCameraFocus
        const highlight = deps.highlight || highlightMapObject
        if (!plan.target || focus(plan.target) !== true) {
            locate.value = { result: EVENT_DETAIL_RESULT.UNAVAILABLE, deviceCode: plan.deviceCode, pointCode: plan.pointCode, reasonText: '地图尚未就绪，稍后重试' }
            return locate.value
        }
        // 设备与关联管线一起高亮；一个都没高亮到 = 目标还没上图（如实说，不假装成功）。
        const matched = highlight(plan.codes)
        if (!matched) {
            locate.value = { result: EVENT_DETAIL_RESULT.UNAVAILABLE, deviceCode: plan.deviceCode, pointCode: plan.pointCode, reasonText: '关联设备尚未出现在地图上' }
        }
        return locate.value
    }

    /**
     * 切换预警/报警。唯一入口（组件与票 19 的面板都走它）：
     * 改切换状态 + 换族重取 —— 切换与字段/状态标签同步是 `domain/eventList.js` 的
     * `eventListSwitchView` 结构保证的，这里只管状态与取数。
     * @param {string} next `WARNING`/`ALARM`；认不出不改
     * @returns {Promise<object>} 分区
     */
    async function setMode(next) {
        if (!isKnownEventMode(next) || next === mode.value) return sections.value.currentEvents
        // 类型筛选是预警族的词汇，切族即失效（避免报警列表被一条预警类型静默筛空）。
        clearWarningTypeFilter()
        return loadPanels({ mode: next })
    }

    /** 仅测试用：回到未加载状态。 */
    function reset() {
        token += 1
        mode.value = EVENT_FAMILY.WARNING
        sections.value = initialSections()
        currentDomain.value = null
        range.value = '7d'
        warningTypeFilter.value = { code: '', label: '' }
        currentPage.value = 1
        historyPage.value = 1
        // 票 71：效率列表的页码与钉住的条件一并回零（reset 是「回到未加载状态」，
        // 留下旧页码/旧条件会让下一轮首屏取到第 3 页或旧窗口）。
        workOrderPage.value = 1
        efficiencyPage.value = 1
        workOrderWindow = null
        efficiencyConditions = null
        selectedEvent.value = null
        locate.value = { result: '', code: '', deviceCode: '', pointCode: '', reasonText: '' }
        loading.value = false
        requestOptions = {}
    }

    return {
        mode,
        range,
        sections,
        loading,
        currentPage,
        historyPage,
        workOrderPage,
        currentDomain,
        selectedEvent,
        locate,
        view,
        configure,
        setRange,
        loadPanels,
        openEvent,
        closeEvent,
        locateEvent,
        setSection,
        loadCurrentEvents,
        setCurrentPage,
        setHistoryPage,
        setWorkOrderPage,
        efficiencyPage,
        setEfficiencyPage,
        setMode,
        warningTypeFilter,
        setWarningTypeFilter,
        clearWarningTypeFilter,
        reset,
    }
})