import assert from 'node:assert/strict'
import { acceptWorkOrderDelta } from '../../../src/modules/cockpit/domain/workOrderPush.js'
import { abnormalCountRows } from '../../../src/modules/cockpit/domain/abnormalCounts.js'
import { toHandlingEfficiency, handlingRateView, handlingRateHint, responseEfficiencyPanel, toEventAnalysis, toEventHistory } from '../../../src/modules/cockpit/domain/warningResponsePanels.js'
import { toWorkOrder } from '../../../src/modules/cockpit/domain/workOrder.js'
import { workOrderRows } from '../../../src/modules/cockpit/domain/equipmentDetailView.js'
import { toWorkOrderDelta } from '../../../src/modules/cockpit/services/runtimeApi.js'
import { handleFrame, onDelta, onWorkOrderDelta, resetForTest } from '../../../src/modules/cockpit/services/runtimeSocket.js'
import { planModeLayers } from '../../../src/modules/cockpit/domain/modeLayerPlan.js'
import { toWorkOrderBrief, refreshedEventSelection } from '../../../src/modules/cockpit/domain/eventList.js'
import { eventDetailView } from '../../../src/modules/cockpit/domain/eventDetail.js'
import { fetchHandlingEfficiency } from '../../../src/modules/cockpit/services/warningResponseApi.js'

const history = toEventHistory({ rows: [{ timeBucket: '2026-10-09', eventCount: 3 }] })
assert.equal(history.trend[0].count, 3)
assert.equal(history.bucketed, true)
const analysis = toEventAnalysis({ dimensions: [{ dimensionCode: 'EVENT_TYPE', buckets: [{ bucketCode: 'GAS', bucketLabel: '燃气报警', count: 4 }] }, { dimensionCode: 'DISTRICT', buckets: [{ bucketCode: '0', bucketLabel: '城南', count: 2 }] }] })
assert.equal(analysis.types[0].count, 4)
assert.equal(analysis.regions[0].label, '城南')
assert.equal(toEventAnalysis({ dimensions: { types: [{ code: 'X', count: 7 }] } }).types[0].count, 7)
const raw = { summary: { totalEvents: 99, handlingEfficiency: { value: '0.6667', numerator: 2, denominator: 3, state: 'AVAILABLE', basis: 'CLOSED_WORK_ORDERS_OVER_ELIGIBLE_WORK_ORDERS' } }, workOrderStateCounts: [{ stateCode: 5, count: 2 }, { stateCode: 6, count: 1 }, { stateCode: 7, count: 4 }] }
const duration = responseEfficiencyPanel(toHandlingEfficiency({ summary: { averageDuration: { value: 2.4, unit: 'HOURS' } }, durationTrend: [{ timeBucket: 'day', averageDuration: { value: 30, unit: 'MINUTES' } }] }), { state: 'success' })
assert.equal(duration.blocks[0].items.find((row) => row.key === 'closeDuration').value, '2.4 小时')
assert.equal(duration.blocks[2].points[0].displayText, '30 分钟')
const rate = toHandlingEfficiency(raw)
assert.equal(handlingRateView(rate), '66.7%')
assert.equal(handlingRateView({ ...rate, denominator: 0 }), '不适用')
assert.equal(handlingRateHint({ ...rate, denominator: 0 }), '当前范围没有可计入工单，处置率不适用')
assert.doesNotMatch(JSON.stringify(responseEfficiencyPanel(rate, { state: 'success' })), /CLOSED_WORK_ORDERS/)
assert.equal(rate.workOrderStates.find((row) => row.code === '6').count, 1)
const result = await fetchHandlingEfficiency({ config: { dataSource: 'real', api: { baseUrl: 'http://test.invalid' } }, fetchImpl: async () => ({ ok: true, status: 200, json: async () => raw }) })
assert.equal(result.state, 'success')

assert.deepEqual(abnormalCountRows([{ status: 'WORK_ORDER', count: 100 }, { status: 'ALARM', count: 2 }], 'point').map((row) => row.count), [2, 0, 0, 0])
assert.deepEqual(abnormalCountRows([{ status: 'NORMAL', count: 100 }, { status: 'EXPIRED', count: 3 }], 'metric').map((row) => row.count), [0, 0, 3, 0, 0])
for (const [flag, text] of [[true, '已关联当前事件'], [false, '未关联当前事件'], [undefined, '当前事件关联关系未发布']]) {
    assert.equal(workOrderRows([toWorkOrder({ workOrderCode: 'WO', stateCode: 0, associatedWithCurrentEvent: flag })])[0].associationText, text)
}
for (let code = 0; code <= 7; code++) assert.ok(toWorkOrderBrief({ stateCode: code }).stateName)
assert.equal(eventDetailView({ workOrderCode: 'WO', workOrderStateName: '延期中' }).workOrderStateName, '延期中')

const selected = { code: 'EVENT', workOrderStateName: '处理中' }
assert.match(refreshedEventSelection(selected, null).refreshNotice, /上次读取/)
assert.match(refreshedEventSelection(selected, { sections: { events: { state: 'success', data: [] } } }).refreshNotice, /上次读取/)
const updated = refreshedEventSelection(selected, { sections: { events: { state: 'success', data: [{ code: 'EVENT', workOrder: { code: 'WO', stateName: '已结案' } }] } } })
assert.equal(updated.workOrderStateName, '已结案')
assert.equal(updated.refreshNotice, '')
resetForTest()
let deviceFrames = 0
let orderFrames = 0
onDelta(() => { deviceFrames++ })
const off = onWorkOrderDelta(() => { orderFrames++ })
const frame = { type: 'cockpitWorkOrderStateDelta', serverUpdatedAt: '2026-10-09T12:00:00+08:00', scanIntervalMs: 60000, data: { items: [{ workOrderCode: 'WO', deviceCode: null, stateCode: 0 }] } }
assert.equal(toWorkOrderDelta(frame).items[0].stateCode, 0)
assert.equal(toWorkOrderDelta(frame).scanIntervalMs, 60000)
const accepted = acceptWorkOrderDelta({}, toWorkOrderDelta(frame))
assert.equal(accepted.items.length, 1)
assert.equal(acceptWorkOrderDelta(accepted.seen, toWorkOrderDelta(frame)).items.length, 0)
assert.equal(acceptWorkOrderDelta(accepted.seen, { ...toWorkOrderDelta(frame), items: [{ code: 'WO-OTHER' }] }).items.length, 1)
assert.equal(acceptWorkOrderDelta(accepted.seen, { ...toWorkOrderDelta(frame), serverUpdatedAt: '2026-10-08T12:00:00+08:00' }).items.length, 0)
assert.equal(acceptWorkOrderDelta({}, null).items.length, 0)
handleFrame(JSON.stringify(frame))
assert.equal(orderFrames, 1)
assert.equal(deviceFrames, 0)
off()
handleFrame(frame)
assert.equal(orderFrames, 1)
assert.equal(handleFrame({ ...frame, serverUpdatedAt: 'invalid' }), null)
assert.equal(handleFrame({ type: 'unknown' }), null)
resetForTest()

const statuses = ['WARNING', 'ALARM', 'OFFLINE', 'EXPIRED']
const objects = statuses.map((status, index) => ({ kind: 'monitoring-point', code: `p${index}`, deviceCodes: [`d${index}`], status: 'NORMAL', longitude: 110, latitude: 28, coordinate: { renderable: true } }))
const plan = planModeLayers({ mode: 'warningResponse', objects, abnormalDevices: statuses.map((status, index) => ({ code: `d${index}`, status })), facilities: [], pipelines: [] })
assert.deepEqual(plan.markers.map((row) => row.code), ['p0', 'p1'])
console.log('T16 contract assertions passed: rate, zero denominator, buckets, association, 0-7 dictionary, order-frame isolation, narrow map.')