import assert from 'node:assert/strict'
import test from 'node:test'

import {
  evaluateWorkerKeywordVerdict,
  matchesWorkerWorkOrderKeyword,
  patchWorkerWorkOrderInfiniteEnvelope,
  patchWorkerWorkOrderListEnvelope,
  resolveWorkerMyOrderRealtimeVerdict,
} from '../src/utils/worker-realtime-work-orders.ts'

function buildRow(overrides: Record<string, unknown> = {}) {
  return {
    workOrderId: 9001,
    workOrderNo: 'WO26093017345168',
    status: 'in_progress',
    productName: '某游戏代练',
    platformOrderId: '2609301734',
    material: { collect: { fields: { gameId: 'g-1', gameNickname: '小明' } } },
    ...overrides,
  }
}

function buildEnvelope(items: unknown[], total = items.length) {
  return { ok: true, data: { items, pagination: { page: 1, pageSize: 20, total } } }
}

function itemsOf(envelope: unknown): Array<{ workOrderId: number }> {
  return (envelope as { data: { items: Array<{ workOrderId: number }> } }).data.items
}

function totalOf(envelope: unknown): number {
  return (envelope as { data: { pagination: { total: number } } }).data.pagination.total
}

test('按工单号搜索必须能命中（后端搜索串第一项就是工单号，前端曾完全没比对它）', () => {
  assert.equal(matchesWorkerWorkOrderKeyword(buildRow(), 'WO26093017345168'), true)
  assert.equal(matchesWorkerWorkOrderKeyword(buildRow(), 'wo26093017'), true)
  // 原有字段仍然要能命中
  assert.equal(matchesWorkerWorkOrderKeyword(buildRow(), '小明'), true)
  assert.equal(matchesWorkerWorkOrderKeyword(buildRow(), '2609301734'), true)
})

test('关键词维度：找不到只能是 unknown，绝不能当成"不匹配"（这才是行被删空的根因）', () => {
  const row = buildRow()
  assert.equal(evaluateWorkerKeywordVerdict(row, 'WO26093017345168'), 'match')
  assert.equal(evaluateWorkerKeywordVerdict(row, ''), 'match')
  // 后端还能搜 material_json 里前端不知道的字段，所以找不到 ≠ 不匹配
  assert.equal(evaluateWorkerKeywordVerdict(row, '后端才知道的字段'), 'unknown')
})

test('按工单号搜到的行，实时事件来了也不能被删掉，并且总数要跟着走', () => {
  const row = buildRow({ status: 'pending_material' })
  const envelope = buildEnvelope([row])
  const snapshot = buildRow({ status: 'in_progress' })

  // 关键词命中 → upsert，原地更新，行数不变
  const updated = patchWorkerWorkOrderListEnvelope(
    envelope,
    { operation: 'upsert', data: snapshot },
    false,
  )
  assert.equal(itemsOf(updated).length, 1)
  assert.equal(totalOf(updated), 1)
  assert.equal((itemsOf(updated)[0] as { status?: string }).status, 'in_progress')
})

test('不可证真的关键词下，快照只能就地更新：不插入、不删除', () => {
  const envelope = buildEnvelope([buildRow()])
  // 关键词没命中前端已知字段（unknown）：既不该把它当"不匹配"删掉
  const patched = patchWorkerWorkOrderListEnvelope(
    envelope,
    { operation: 'upsert', data: buildRow({ status: 'accepted' }) },
    false,
  )
  assert.equal(itemsOf(patched).length, 1)
  // 也不该把不在列表里的行插进来（留着让后端说了算）
  const notInserted = patchWorkerWorkOrderListEnvelope(
    envelope,
    { operation: 'upsert', data: buildRow({ workOrderId: 8888 }) },
    false,
  )
  assert.equal(itemsOf(notInserted).length, 1)
})

test('真正移出可见范围时要删行，并同步分页总数（旧实现只删 items，分页器还显示有 N 条）', () => {
  const envelope = buildEnvelope([buildRow(), buildRow({ workOrderId: 9002 })], 2)
  const removed = patchWorkerWorkOrderListEnvelope(
    envelope,
    { operation: 'remove', data: buildRow() },
    false,
  )
  assert.deepEqual(
    itemsOf(removed).map((item) => item.workOrderId),
    [9002],
  )
  assert.equal(totalOf(removed), 1, '删行后总数必须减一')

  const inserted = patchWorkerWorkOrderListEnvelope(
    buildEnvelope([buildRow()], 1),
    { operation: 'upsert', data: buildRow({ workOrderId: 9003 }) },
    true,
  )
  assert.equal(itemsOf(inserted).length, 2)
  assert.equal(totalOf(inserted), 2, '插行后总数必须加一')
})

test('无限下拉：只有第 1 页允许插入，其余页只就地更新', () => {
  const page = (ids: number[]) =>
    buildEnvelope(ids.map((id) => buildRow({ workOrderId: id, status: 'open' })))
  const current = { pages: [page([1, 2]), page([3, 4])], pageParams: [1, 2] }
  const patched = patchWorkerWorkOrderInfiniteEnvelope(
    current,
    { operation: 'upsert', data: buildRow({ workOrderId: 99, status: 'open' }) },
    true,
  ) as { pages: unknown[] }
  assert.equal(itemsOf(patched.pages[0]).length, 3, '第 1 页应插入')
  assert.equal(itemsOf(patched.pages[1]).length, 2, '第 2 页不得插入')
})

/**
 * 「我的订单」状态页签的实时删行判定。
 *
 * 生产现象（与后台同源）：按工单号搜出来的那一单，状态一流转（代练中 → 待验收 / 已验收）
 * 就被实时补丁按"状态不匹配"删掉，列表变空、必须刷新整页。
 * 页签只是展示偏好：后端按单号查时已经忽略状态，前端不能再拿状态删行。
 */
test('显式单号检索：状态页签不匹配也不得删行（状态流转后仍要能搜到）', () => {
  const row = buildRow({ status: 'in_progress' })
  const verdict = resolveWorkerMyOrderRealtimeVerdict({
    item: buildRow({ status: 'pending_acceptance' }),
    statusFilter: 'in_progress',
    keyword: 'WO26093017345168',
    operation: 'upsert',
    page: 1,
    explicitOrderNo: true,
  })
  assert.equal(verdict.operation, 'upsert', '单号检索下状态不能证伪')
  assert.equal(verdict.shouldInsert, true, '命中的单号仍可插入第 1 页')

  const updated = patchWorkerWorkOrderListEnvelope(
    buildEnvelope([row]),
    { operation: verdict.operation, data: buildRow({ status: 'pending_acceptance' }) },
    verdict.shouldInsert,
  )
  assert.equal(itemsOf(updated).length, 1, '行不能被删掉')
  assert.equal(
    (itemsOf(updated)[0] as { status?: string }).status,
    'pending_acceptance',
    '应就地更新成最新状态',
  )
})

test('模糊关键词：状态页签不匹配仍按原设计移除行', () => {
  const verdict = resolveWorkerMyOrderRealtimeVerdict({
    item: buildRow({ status: 'accepted' }),
    statusFilter: 'in_progress',
    keyword: '暗潮',
    operation: 'upsert',
    page: 1,
    explicitOrderNo: false,
  })
  assert.equal(verdict.operation, 'remove')
  assert.equal(verdict.shouldInsert, false)
})

test('服务端 remove（打手已失去该单）仍然生效，单号护栏不误挡', () => {
  const verdict = resolveWorkerMyOrderRealtimeVerdict({
    item: buildRow({ status: 'in_progress' }),
    statusFilter: '',
    keyword: 'WO26093017345168',
    operation: 'remove',
    page: 1,
    explicitOrderNo: true,
  })
  assert.equal(verdict.operation, 'remove', '服务端明确说单子已不可见时必须移除')
})

test('非第 1 页不得插入，只做就地更新', () => {
  const verdict = resolveWorkerMyOrderRealtimeVerdict({
    item: buildRow({ workOrderId: 8888 }),
    statusFilter: '',
    keyword: 'WO26093017345168',
    operation: 'upsert',
    page: 2,
    explicitOrderNo: true,
  })
  assert.equal(verdict.operation, 'upsert')
  assert.equal(verdict.shouldInsert, false)
})