import assert from 'node:assert/strict'
import test from 'node:test'
import { readFileSync } from 'node:fs'
import { mkdtemp, readFile, rm } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join, resolve, basename } from 'node:path'
import { DISPATCH_BASE as BASE, dispatchEvidenceContext, dispatchIo } from './grouped-dispatch-acceptance.mjs'
import { run, createClientRelabelDispatch, createPdaRelabelDispatch, selectDispatchRouteFixture, dispatchRouteMatches, dispatchBusinessSnapshot, verifyDispatchRouteLifecycle } from './phase4-overseas-dispatch.mjs'

const clone = value => structuredClone(value)
const rows = () => [1, 2, 3].map(n => ({ selection: { sourceType: 'INBOUND_PLAN', planPalletId: `2${n}`, returnReceiptId: null, relabelNo: null, warehousePalletId: `3${n}`, sourceVersion: `${n}`.repeat(64) },
  sourceKey: `PLAN:2${n}`, sourceVersion: `${n}`.repeat(64), customerId: '55', warehouseId: '44', inboundCode: `IN-${n}`, palletNo: `P-${n}`,
  destination: { key: `FBA:A${n === 3 ? 1 : n}`, type: 'FBA', warehouseCode: `A${n === 3 ? 1 : n}` }, availablePackages: n + 1, appointmentBatches: [], blockReasons: [] }))
// All state here is offline test data. This server rejects missing versions and preserves original-key results.
function server(fault = '', initial = false) {
  const candidates = rows(), drafts = new Map(), orders = new Map(), ledger = new Map(), calls = [], checks = []
  let serial = 0, containerId = 60, itemId = 70
  const counts = o => ({ itemCount: o.items.length, palletCount: o.items.length, packageCount: o.items.reduce((n, i) => n + i.scheduledPackages, 0), pickedPackageCount: 0, shippedPackageCount: 0 })
  const item = c => ({ dispatchItemId: String(++itemId), sourceType: c.selection.sourceType, sourceKey: c.sourceKey, sourceVersion: c.sourceVersion, customerId: c.customerId,
    planPalletId: c.selection.planPalletId, warehousePalletId: c.selection.warehousePalletId, inboundCode: c.inboundCode, destination: clone(c.destination), scheduledPackages: c.availablePackages, pickedPackages: 0, remove: { allowed: true } })
  const syncRoute = o => { o.keys = [...new Set([...(fault === 'append-only-route' ? o.keys || [] : []), ...o.items.map(i => i.destination.key)])] }
  const create = cargo => { const o = { dispatchNo: `DS-${orders.size + 1}`, recordVersion: initial && orders.size === 0 ? 0 : 1, items: cargo.map(s => item(candidates.find(c => c.selection.planPalletId === s.planPalletId))) }; syncRoute(o); orders.set(o.dispatchNo, o); return o }
  const command = (o, action) => ({ dispatchNo: o.dispatchNo, action, recordVersion: o.recordVersion, status: 'ACTIVE', stage: 'BEFORE_LOADING', counts: counts(o), replayed: false })
  const view = o => ({ dispatchNo: o.dispatchNo, status: 'ACTIVE', stage: 'BEFORE_LOADING', recordVersion: o.recordVersion, counts: counts(o),
    dispatchInfo: { route: [...new Set(o.items.map(i => i.destination.warehouseCode))].join(',') },
    orderDetails: o.items.map(i => ({ sourceKey: i.sourceKey, customerId: i.customerId, inboundCode: i.inboundCode, destinationFbaWarehouse: i.destination.warehouseCode })) })
  const stops = o => [{ index: 0, name: 'Actual Origin', address: 'Warehouse 44', destinationKey: 'ORIGIN:44' }, ...o.keys.map((key, n) => ({ index: n + 1, name: key, destinationKey: key }))]
  const response = (data, code = '200') => ({ http: 200, body: { code, data: clone(data) }, requestId: 'OFFLINE-REQ', traceId: 'OFFLINE-TRACE' })
  const context = { marker: 'CURRENT', createdResources: { phase4OverseasPda: { marker: 'CURRENT', finalStatus: 'COMPLETED', customerId: '55', overseasWarehouseId: '44', palletIds: ['31', '32', '33'] } },
    checkpoint: async () => {}, // Explicit offline double; full-run test below removes it and verifies actual disk writes.
    assert: (_module, label, _response, passed) => checks.push({ label, passed }),
    async request(method, raw, body) {
      calls.push({ method, path: raw, body: clone(body) })
      const path = raw.split('?')[0], params = new URLSearchParams(raw.split('?')[1]), write = method !== 'GET'
      const key = `${method}:${path}:${body?.idempotencyKey}`
      if (write) {
        assert.ok(body?.idempotencyKey, raw)
        if (ledger.has(key)) {
          const old = ledger.get(key); assert.equal(JSON.stringify(body), old.body, 'replay must use original body and version')
          if (fault === 'replay-row-drift' && path.endsWith('/items')) orders.get('DS-1').items[0].dispatchItemId = '9999'
          const data = clone(old.data); if (data?.action || data?.vehicles) data.replayed = true; return response(data)
        }
      }
      const remember = data => { ledger.set(key, { body: JSON.stringify(body), data: clone(data) }); return response(data) }
      const draft = drafts.get(body?.draftToken)
      if (method === 'POST' && path === `${BASE}/drafts`) { const d = { draftToken: `SERVER-${++serial}`, recordVersion: 0, warehouseId: body.warehouseId, status: 'ACTIVE', sources: [], containers: [] }; drafts.set(d.draftToken, d); return remember(d) }
      if (method === 'GET' && path === `${BASE}/drafts`) return response([...drafts.values()].filter(d => d.status === 'ACTIVE'))
      if (path === `${BASE}/candidates`) {
        assert.equal(params.get('warehouseId'), '44')
        assert.equal(params.get('sourceStage'), params.get('orderNo') === 'RL-CLIENT' ? 'RELABEL' : 'RECEIVED')
        const claimed = new Set([...orders.values()].flatMap(o => o.items.map(i => i.sourceKey)))
        for (const d of drafts.values()) if (d.status === 'ACTIVE' && params.get('draftToken') && d.draftToken !== params.get('draftToken')) for (const c of d.sources) claimed.add(c.sourceKey)
        return response({ candidates: candidates.filter(c => !claimed.has(c.sourceKey)), complete: true, snapshotAt: '2026-10-19' })
      }
      if (path === `${BASE}/drafts/containers`) { assert.equal(body.recordVersion, draft.recordVersion); draft.containers.push({ draftContainerId: String(++containerId), sequenceNo: draft.containers.length + 1, capacity: body.capacity, sourceKeys: [] }); draft.recordVersion++; return remember(draft) }
      const deleteContainer = path.match(/\/drafts\/([^/]+)\/containers\/(\d+)$/)
      if (deleteContainer) { const d = drafts.get(deleteContainer[1]); assert.equal(body.recordVersion, d.recordVersion); const c = d.containers.find(c => c.draftContainerId === deleteContainer[2]); if (c.sourceKeys.length) return response(null, 'A0409'); d.containers = d.containers.filter(c => c.draftContainerId !== deleteContainer[2]); d.recordVersion++; return remember(d) }
      if (path === `${BASE}/draft-locks/lock` || path === `${BASE}/draft-locks/unlock`) {
        assert.equal(body.recordVersion, draft.recordVersion)
        const c = candidates.find(c => c.selection.planPalletId === body.source.planPalletId), container = draft.containers.find(g => g.draftContainerId === body.draftContainerId)
        assert.deepEqual(body.source, c.selection)
        if (path.endsWith('/lock')) {
          if ([...orders.values()].some(o => o.items.some(i => i.sourceKey === c.sourceKey))) return response(null, 'A0409')
          draft.sources.push(clone(c)); container.sourceKeys.push(c.sourceKey)
        } else { draft.sources = draft.sources.filter(s => s.sourceKey !== c.sourceKey); container.sourceKeys = container.sourceKeys.filter(k => k !== c.sourceKey) }
        draft.recordVersion++; return remember(draft)
      }
      if (path === `${BASE}/draft-locks/release`) { assert.equal(body.recordVersion, draft.recordVersion); assert.equal(draft.sources.length, 0); draft.status = 'RELEASED'; draft.recordVersion++; return remember(draft) }
      if (path === `${BASE}/drafts/snapshot`) { assert.equal(body.recordVersion, draft.recordVersion); assert.ok(Array.isArray(body.planIds)); assert.ok(Array.isArray(body.containers)); draft.containers = clone(body.containers); draft.recordVersion++; return remember(draft) }
      if (path === `${BASE}/drafts/pre-arrange`) {
        assert.equal(body.recordVersion, draft.recordVersion)
        if (!body.groups.every(g => JSON.stringify(g.dispatch.cargo.map(s => `PLAN:${s.planPalletId}`).sort()) === JSON.stringify([...draft.containers.find(c => c.draftContainerId === g.draftContainerId).sourceKeys].sort()))) return response(null, 'A0409')
        const vehicles = body.groups.map(g => ({ draftContainerId: g.draftContainerId, dispatch: command(create(g.dispatch.cargo), 'CREATE') })); draft.status = 'CONVERTED'
        return remember({ draftToken: draft.draftToken, vehicles, replayed: false })
      }
      if (path === BASE && method === 'POST') { assert.equal(body.vehicle, null); assert.equal(body.driver, null); return remember(command(create(body.cargo), 'CREATE')) }
      if (path === BASE && method === 'GET') return response({ records: [...orders.values()].filter(o => o.dispatchNo === params.get('dispatchNo')).map(o => ({ ...command(o, 'READ'), warehouseId: '44' })) })
      const match = path.slice(BASE.length).match(/^\/([^/]+)(?:\/(items|route)(?:\/([^/]+)\/remove)?)?$/), o = orders.get(match?.[1]); assert.ok(o, `${method} ${raw}`)
      if (write) {
        assert.equal(body.recordVersion, o.recordVersion, 'explicit server version, including zero')
        if (match[2] === 'route') { assert.equal(method, 'PUT'); assert.deepEqual([...body.destinationKeys].sort(), [...o.keys].sort()); o.keys = clone(body.destinationKeys); o.recordVersion++; return remember(command(o, 'UPDATE_ROUTE')) }
        if (match[3]) {
          if (!o.items.some(i => i.dispatchItemId === match[3])) { if (fault === 'rejected-remove-mutates') o.recordVersion++; return response(null, 'A0404') }
          o.items = o.items.filter(i => i.dispatchItemId !== match[3]); o.recordVersion++; syncRoute(o); return remember(command(o, 'REMOVE_CARGO'))
        }
        assert.equal(method, 'POST'); assert.equal(match[2], 'items')
        if (new Set(body.cargo.map(s => s.planPalletId)).size !== body.cargo.length) return response(null, 'A0400')
        o.items.push(...body.cargo.map(s => item(candidates.find(c => c.selection.planPalletId === s.planPalletId)))); o.recordVersion++; syncRoute(o)
        if (fault === 'unknown-add') return { http: 0, body: null }
        if (fault === 'route-drift') o.keys = ['FBA:FOREIGN']
        return remember(command(o, 'ADD_CARGO'))
      }
      if (match[2] === 'items') return response({ dispatchNo: o.dispatchNo, recordVersion: o.recordVersion, status: 'ACTIVE', stage: 'BEFORE_LOADING', items: o.items })
      if (match[2] === 'route') return response({ dispatchNo: o.dispatchNo, recordVersion: o.recordVersion, stops: stops(o), edit: { allowed: true } })
      return response(view(o))
    } }
  if (initial) { create(candidates.slice(0, 2).map(c => c.selection)); context.createdResources.phase4OverseasDispatch = {} }
  return { context, candidates, calls, checks, orders, bundle: () => { const o = orders.get('DS-1'); return { data: view(o), warehouseId: '44', items: { items: clone(o.items) }, route: { stops: stops(o) } } } }
}

function addClientRelabel(h) {
  const candidate = clone(rows()[0])
  Object.assign(candidate, { sourceKey: 'RELABEL:RL-CLIENT:91', availablePackages: 1 })
  candidate.selection = { sourceType: 'RELABEL', relabelNo: 'RL-CLIENT', warehousePalletId: '91', sourceVersion: candidate.sourceVersion }
  h.candidates.push(candidate)
  h.context.createdResources.phase4OverseasClientServices = { relabelFulfillment: { marker: 'CURRENT', relabelNo: 'RL-CLIENT',
    status: 'READY_FOR_OUTBOUND', execution: { status: 'HTTP_VERIFIED_READY_FOR_DISPATCH' }, customerId: '55', warehouseId: '44', targetPalletIds: ['91'] } }
}

test('client original relabel gets its own exact dispatch and refuses repeat execution', async () => {
  const h = server(); addClientRelabel(h)
  const proof = {}, io = dispatchIo(h.context, 'test', proof, 'CLIENT-RELABEL')
  await createClientRelabelDispatch(h.context, io, proof)
  assert.equal(proof.clientRelabel.status, 'CREATED_BEFORE_LOADING')
  assert.equal(h.context.createdResources.phase4OverseasClientServices.relabelFulfillment.dispatchNo, 'DS-1')
  assert.deepEqual(proof.clientRelabel.sourceKeys, ['RELABEL:RL-CLIENT:91'])
  const writes = h.calls.filter(c => c.method === 'POST').length
  await assert.rejects(createClientRelabelDispatch(h.context, io, proof))
  assert.equal(h.calls.filter(c => c.method === 'POST').length, writes)
})

test('PDA relabel candidates do not inherit original receiving plan filters and missing sources fail before writes', async () => {
  for (const missing of [false, true]) {
    const h = server(); addClientRelabel(h)
    const fixture = h.context.createdResources.phase4OverseasClientServices.relabelFulfillment
    h.context.createdResources.phase4OverseasRelabel = { ...fixture, overseasWarehouseId: fixture.warehouseId }
    if (missing) h.candidates.pop()
    const proof = {}, io = dispatchIo(h.context, 'test', proof, 'PDA-RELABEL'); io.planIds = ['old-plan']
    const original = io.command.bind(io)
    io.command = async (method, path, ...args) => {
      if (path.includes('/candidates?')) assert.equal(new URL(path, 'https://offline.invalid').searchParams.has('planIds'), false)
      return original(method, path, ...args)
    }
    if (missing) { await assert.rejects(createPdaRelabelDispatch(h.context, io, proof)); assert.equal(h.calls.some(c => c.method === 'POST'), false) }
    else { await createPdaRelabelDispatch(h.context, io, proof); assert.equal(h.context.createdResources.phase4OverseasRelabel.dispatchNo, 'DS-1') }
  }
})

for (const fault of ['customer', 'pallet', 'missing']) test(`client relabel excludes ${fault} candidates before writes`, async () => {
  const h = server(); addClientRelabel(h)
  if (fault === 'customer') h.candidates.at(-1).customerId = '99'
  if (fault === 'pallet') h.candidates.at(-1).selection.warehousePalletId = '99'
  if (fault === 'missing') h.candidates.pop()
  const proof = {}, io = dispatchIo(h.context, 'test', proof, 'CLIENT-RELABEL')
  await assert.rejects(createClientRelabelDispatch(h.context, io, proof))
  assert.equal(h.calls.some(c => c.method === 'POST'), false)
})

test('native route fixture uses real physical pallets and requires two destinations plus a repeated destination', () => {
  const c = rows(), selected = selectDispatchRouteFixture(c)
  assert.deepEqual(selected.selected.map(c => c.sourceKey), ['PLAN:21', 'PLAN:22']); assert.equal(selected.duplicate.sourceKey, 'PLAN:23')
  assert.equal(selectDispatchRouteFixture(c.slice(0, 2)), null)
  c[2].selection.warehousePalletId = c[0].selection.warehousePalletId; assert.equal(selectDispatchRouteFixture(c), null)
})

test('native route proof rejects drift in actual identity, physical scope, counts and destination keys', () => {
  const h = server('', true), original = h.bundle(), expected = h.candidates.slice(0, 2)
  assert.equal(dispatchRouteMatches(original, expected), true)
  for (const mutate of [b => { b.warehouseId = '999' }, b => { b.items.items[0].customerId = '999' }, b => { b.items.items[0].warehousePalletId = '999' }, b => { b.items.items[0].sourceVersion = '0'.repeat(64) }, b => { b.data.counts.packageCount++ }, b => { b.route.stops[1].destinationKey = 'FBA:OTHER' }, b => { b.data.dispatchInfo.route = 'A1,A1,A2' }, b => { b.items.items[1].dispatchItemId = b.items.items[0].dispatchItemId }, b => { b.data.orderDetails[0].customerId = '999' }, b => { b.data.orderDetails[0].sourceKey = 'PLAN:999' }, b => { b.data.orderDetails[0].destinationFbaWarehouse = 'OTHER' }]) { const bad = clone(original); mutate(bad); assert.equal(dispatchRouteMatches(bad, expected), false) }
  const changed = clone(original); changed.items.items[0].dispatchItemId = '9999'; assert.notEqual(dispatchBusinessSnapshot(changed), dispatchBusinessSnapshot(original))
})

test('C52 uses native versioned cargo commands, immutable replay, actual readback and route keys', async () => {
  const h = server('', true), current = await verifyDispatchRouteLifecycle(h.context, { dispatchNo: 'DS-1', candidates: h.candidates.slice(0, 2), duplicate: h.candidates[2] })
  assert.equal(h.context.createdResources.phase4OverseasDispatch.routeLifecycle.status, 'VERIFIED'); assert.ok(h.checks.every(c => c.passed))
  assert.equal(current.data.counts.packageCount, 5); assert.equal(current.data.recordVersion, 6)
  const firstAdd = h.calls.find(c => c.method === 'POST' && c.path.endsWith('/items')); assert.equal(firstAdd.body.recordVersion, 0)
  assert.deepEqual(h.calls.filter(c => c.method === 'PUT').map(c => c.body.destinationKeys), [['FBA:A2', 'FBA:A1'], ['FBA:A2', 'FBA:A1'], ['FBA:A1', 'FBA:A2'], ['FBA:A1', 'FBA:A2']])
  assert.equal(h.calls.some(c => c.method === 'DELETE'), false)
})

test('C52 rejects replay row drift, rejection side effects, wrong route and unknown writes without cleanup', async () => {
  for (const fault of ['replay-row-drift', 'rejected-remove-mutates', 'route-drift', 'unknown-add']) {
    const h = server(fault, true)
    await assert.rejects(verifyDispatchRouteLifecycle(h.context, { dispatchNo: 'DS-1', candidates: h.candidates.slice(0, 2), duplicate: h.candidates[2] }))
    assert.notEqual(h.context.createdResources.phase4OverseasDispatch.routeLifecycle.status, 'VERIFIED')
    assert.equal(h.calls.some(c => c.method === 'PUT' || c.method === 'DELETE'), false)
    if (fault === 'unknown-add') { assert.equal(h.context.createdResources.dispatchWriteBoundary.outcomeUnknown, true); assert.equal(h.calls.filter(c => c.method !== 'GET').length, 1); assert.equal(h.orders.get('DS-1').items.length, 3) }
  }
})

test('phase4 missing current marker or real multi-destination fixture is explicit NOT_RUN before writes', async () => {
  const h = server(); h.context.createdResources.phase4OverseasPda.marker = 'OLD'; assert.equal((await run(h.context)).status, 'NOT_RUN'); assert.equal(h.calls.length, 0)
  const other = server(); other.candidates.pop(); assert.equal((await run(other.context)).status, 'NOT_RUN'); assert.equal(other.calls.filter(c => c.method !== 'GET').length, 0)
  const ambiguous = server(); ambiguous.candidates[2].appointmentBatches = [{}, {}]; assert.equal((await run(ambiguous.context)).status, 'NOT_RUN'); assert.equal(ambiguous.calls.filter(c => c.method !== 'GET').length, 0)
})

test('complete offline phase4 hands off the actual native Detail and current source keys at BEFORE_LOADING', async () => {
  const directory = await mkdtemp(join(tmpdir(), 'phase4-dispatch-contract-'))
  try {
  const h = server(); addClientRelabel(h); delete h.context.checkpoint; h.context.options = { output: join(directory, 'report.json') }
  h.context.createdResources.dispatchWriteBoundary = { marker: 'CURRENT', stopped: false, password: 'PRIVATE_PASSWORD', token: 'PRIVATE_LOGIN_TOKEN' }
  const originalRequest = h.context.request
  h.context.request = async (method, path, body) => {
    if (method !== 'GET') {
      const evidence = JSON.parse(await readFile(join(directory, 'phase4-dispatch-checkpoints', 'CURRENT.json'), 'utf8'))
      const intents = [...(evidence.phase4OverseasDispatch.requests || []), ...(evidence.groupedDispatch?.requests || []), ...(evidence.phase4OverseasDispatch.routeLifecycle?.requests || [])]
      assert.ok(intents.some(r => r.status === 'SENDING' && r.method === method && r.path === path && JSON.stringify(r.body) === JSON.stringify(body)), 'original write must already exist on disk')
    }
    return originalRequest(method, path, body)
  }
  const proof = await run(h.context)
  assert.equal(proof.status, 'VERIFIED'); assert.equal(proof.finalStatus, 'ACTIVE'); assert.equal(proof.stage, 'BEFORE_LOADING'); assert.ok(h.checks.every(c => c.passed))
  assert.deepEqual(proof.sourceKeys, ['PLAN:21', 'PLAN:22']); assert.deepEqual(proof.destinationWarehouseCodes, ['A1', 'A2']); assert.equal(proof.warehouseId, '44')
  const actual = await h.context.request('GET', `${BASE}/${proof.dispatchNo}`); assert.deepEqual(proof.data, actual.body.data)
  assert.equal(Object.hasOwn(proof.data, 'items'), false); assert.equal(Object.hasOwn(proof.data, 'route'), false); assert.equal(Object.hasOwn(proof, 'dispatchId'), false)
  assert.equal(Object.hasOwn(proof, 'loadingMeasurements'), false); assert.equal(proof.loadingEvidenceStatus, 'NOT_RUN_MISSING_ACTUAL_MEASUREMENTS')
  assert.equal(h.calls.some(c => /\/review|\/pick|\/scan|\/loading|\/depart|\/transfer-delivery/.test(c.path)), false)
  assert.equal(h.calls.some(c => c.path === `${BASE}/pre-arrange` || c.body?.containersJson), false)
  const text = await readFile(proof.checkpointPath, 'utf8'), journal = JSON.parse(text)
  assert.equal(journal.phase4OverseasDispatch.status, 'VERIFIED'); assert.ok(journal.phase4OverseasDispatch.draftToken)
  assert.equal(text.includes('PRIVATE_PASSWORD'), false); assert.equal(text.includes('PRIVATE_LOGIN_TOKEN'), false)
  await assert.rejects(dispatchEvidenceContext({ marker: 'CURRENT', options: h.context.options, createdResources: { phase4OverseasDispatch: {} } }), /已存在本轮排车检查点/)
  const stale = server('append-only-route'); await assert.rejects(run(stale.context), /最后实物移出后真实数量归零/)
  assert.equal(stale.context.createdResources.phase4OverseasDispatch.status, 'UNPROVEN'); assert.equal(stale.orders.size, 1)
  assert.equal(stale.calls.some(c => c.path.endsWith('/drafts')), false)
  } finally {
    assert.ok(basename(directory).startsWith('phase4-dispatch-contract-')); assert.equal(resolve(directory, '..'), resolve(tmpdir()))
    await rm(directory, { recursive: true, force: true })
  }
})

test('relabel creation cannot prematurely settle fulfillment or fabricate loading measurements', () => {
  const source = readFileSync(new URL('./phase4-overseas-dispatch.mjs', import.meta.url), 'utf8')
  assert.equal(source.includes('settleRelabelFulfillment'), false)
  assert.equal(source.includes('vehicleAppointmentStatus'), false)
  assert.equal(source.includes('loadingMeasurements:'), false)
  assert.ok(source.includes('fixture.targetPalletIds')); assert.ok(source.includes('READY_FOR_OUTBOUND'))
})