const MODULE = 'manual-state-loading-pda'
const OPTIONS = { scenario: 'manual-loading-pda-state-matrix', deploymentBlocker: true }
const CONTAINERS = '/api/platform/v1/containers'
const SMART = '/api/platform/v1/first-leg/smart-loading'
const LOADING = '/api/platform/v1/first-leg'
const PDA = `${LOADING}/pda-loading`
const CONTAINER_STATUSES = ['WAIT_LOADING', 'EDITING', 'LOADING', 'COMPLETED']
const PRELOAD_STATUSES = ['EDITING', 'LOADING']
const PDA_STATUSES = ['UNASSIGNED', 'IN_PROGRESS', 'AWAITING_REVIEW', 'COMPLETED']

import { resolveOceanBookingAgent } from './ocean-booking-fixture.mjs'

function id(value) { return value == null ? '' : String(value) }
function records(value) { return Array.isArray(value?.records) ? value.records : [] }
function suffix(context, label) {
  return `${String(context.marker).replace(/[^A-Za-z0-9]/g, '').slice(-10)}${label}`.slice(-20)
}
function operationId(context, label) {
  return `${context.marker}-manual-loading-${label}-${crypto.randomUUID()}`.slice(0, 128)
}

async function post(context, path, body, label) {
  return context.request('POST', path, body, context.token,
    { 'Idempotency-Key': operationId(context, label) })
}

async function uploadDocument(context, path, expectedVersion, operationReason, label) {
  const form = new FormData()
  form.append('file', new Blob([`${context.marker}-${label}`], { type: 'text/plain' }), `${label}.txt`)
  form.append('expectedVersion', String(expectedVersion))
  if (operationReason) form.append('operationReason', operationReason)
  try {
    const response = await fetch(`${context.options.gateway}${path}`, {
      method: 'POST',
      headers: {
        Accept: 'application/json', Authorization: `Bearer ${context.token}`,
        'Idempotency-Key': operationId(context, `${label}-upload`),
      },
      body: form,
      signal: AbortSignal.timeout(60_000),
    })
    const raw = await response.text()
    let body = null
    try { body = raw ? JSON.parse(raw) : null } catch { /* bounded raw evidence */ }
    return { method: 'POST', path, http: response.status, body, raw: body ? null : raw.slice(0, 500),
      requestId: body?.requestId || response.headers.get('x-request-id'),
      traceId: body?.traceId || response.headers.get('x-trace-id') }
  } catch (error) {
    return { method: 'POST', path, http: 0, body: null, raw: String(error), requestId: null, traceId: null }
  }
}

async function ensureCompletionEvidence(context, chain, label) {
  const taskId = id(chain.task?.id)
  const warehouseId = id(chain.source?.warehouseId)
  const png = Uint8Array.from([137,80,78,71,13,10,26,10,0,0,0,13,73,72,68,82,0,0,0,1,0,0,0,1,8,6,0,0,0,31,21,196,137,0,0,0,13,73,68,65,84,8,215,99,248,207,192,240,31,0,5,0,1,255,137,153,61,29,0,0,0,0,73,69,78,68,174,66,96,130])
  for (const evidenceType of ['PHOTO_STEP_1', 'PHOTO_STEP_2', 'PHOTO_STEP_3', 'PHOTO_STEP_4', 'SEAL']) {
    const query = new URLSearchParams({ warehouseId, expectedVersion: '0', evidenceType,
      remark: context.marker })
    if (evidenceType === 'SEAL') query.set('sealNo', `SEAL-${suffix(context, label)}`.slice(0, 64))
    const uploadPath = `${PDA}/tasks/${taskId}/evidence?${query}`
    const form = new FormData()
    form.append('file', new Blob([png], { type: 'image/png' }), `${label}-${evidenceType}.png`)
    const rawUpload = await fetch(`${context.options.gateway}${uploadPath}`, {
      method: 'POST', headers: { Accept: 'application/json', Authorization: `Bearer ${context.token}`,
        'Idempotency-Key': operationId(context, `${label}-evidence-${evidenceType}`) },
      body: form, signal: AbortSignal.timeout(60_000),
    })
    const uploadBody = await rawUpload.json()
    const upload = { method: 'POST', path: uploadPath, http: rawUpload.status, body: uploadBody,
      requestId: uploadBody?.requestId || rawUpload.headers.get('x-request-id'),
      traceId: uploadBody?.traceId || rawUpload.headers.get('x-trace-id') }
    const evidence = context.apiSuccess(MODULE, `${label} 上传并绑定 ${evidenceType} 装柜证据`, upload, '', OPTIONS)
    const active = evidence?.evidences?.find?.((item) => item.evidenceType === evidenceType
      && item.status !== 'VOID')
    if (!active?.evidenceId || id(evidence?.taskId) !== taskId) {
      throw new Error(`${label} ${evidenceType} 未返回任务证据ID`)
    }
  }
}

async function prepareInbound(context, label) {
  const originalMarker = context.marker
  const fixtureMarker = `${originalMarker}-MAN-${label}`
  const createdKeys = ['orders', 'ocrInbound', 'testInbound', 'inboundMeasurement', 'inboundWarehouseResources']
  const contextKeys = ['inboundWeightOcr', 'ocrInbound', 'testInbound', 'createdInbound']
  const createdSnapshot = new Map(createdKeys.map((key) => [key,
    { present: Object.hasOwn(context.createdResources, key), value: context.createdResources[key] }]))
  const contextSnapshot = new Map(contextKeys.map((key) => [key,
    { present: Object.hasOwn(context.context, key), value: context.context[key] }]))

  try {
    context.marker = fixtureMarker
    const orders = await import(new URL('./orders.mjs', import.meta.url))
    await orders.run(context)
    const measurement = await import(new URL('./inbound-measurement.mjs', import.meta.url))
    await measurement.run(context)
    const measured = context.createdResources.inboundMeasurement
    const order = context.createdResources.orders
    if (!measured?.inboundId || !measured?.tenantId) throw new Error(`${label} 未生成独立 WAIT_SPLIT 入库单`)
    return { marker: fixtureMarker, tenantId: id(measured.tenantId), inboundId: id(measured.inboundId),
      orderId: id(order?.orderId) }
  } finally {
    context.marker = originalMarker
    for (const [key, snapshot] of createdSnapshot) {
      if (snapshot.present) context.createdResources[key] = snapshot.value
      else delete context.createdResources[key]
    }
    for (const [key, snapshot] of contextSnapshot) {
      if (snapshot.present) context.context[key] = snapshot.value
      else delete context.context[key]
    }
  }
}

async function readInbound(context, fixture) {
  const response = await context.request('GET',
    `/api/platform/inbounds/${fixture.inboundId}?tenantId=${encodeURIComponent(fixture.tenantId)}`)
  const value = context.apiSuccess(MODULE, '读取人工装柜独立入库单', response, '', OPTIONS)
  const warehouseId = id(value?.summary?.warehouseId)
  context.assert(MODULE, '人工装柜来源入库单可独立排柜', response,
    value?.summary?.processStatus === 'WAIT_SPLIT'
      && value?.summary?.measureReviewStatus === 'APPROVED'
      && Boolean(warehouseId),
    `inboundId=${fixture.inboundId}, status=${value?.summary?.processStatus || 'missing'}`, OPTIONS)
  return { ...fixture, detail: value, warehouseId }
}

async function createConfirmedContainer(context, source, label) {
  const value = suffix(context, label)
  const containerNo = iso6346ContainerNumber(`${context.marker}-manual-${label}`)
  const summary = source.detail.summary
  const { ensureMatsonCarrierPartner } = await import('./carrier-partner-fixture.mjs')
  const carrier = await ensureMatsonCarrierPartner(context, MODULE, OPTIONS)
  if (!carrier?.id) throw new Error(`${label} 未取得 ACTIVE 船公司`)
  const agent = await resolveOceanBookingAgent(context, MODULE, carrier.carrierCode, OPTIONS)
  if (!agent) throw new Error(`${label} 未取得当前船公司关联的 ACTIVE 订舱代理`)
  const draft = {
    customerId: source.tenantId, customerName: summary.customerName || 'IT 测试客户',
    channelCode: summary.channelCode, warehouseId: source.warehouseId,
    billOfLadingNo: `BL-${value}`.slice(0, 128),
    shippingCompanyId: id(carrier.id), shippingCompanyName: carrier.name, carrierCode: carrier.carrierCode,
    bookingAgentId: id(agent.id), bookingAgentName: agent.name, departurePortCode: 'CNSZX',
    vesselName: `人工船-${value}`.slice(0, 128), voyageNo: `V-${value}`.slice(0, 64),
    departurePortName: '深圳', destinationPortCode: 'USLAX', destinationPortName: '洛杉矶',
    placeOfDelivery: 'LAX', serviceTerm: 'CY-CY', freightTerm: 'NINGBO',
    estimatedSailingAt: '2026-09-01T08:00:00', estimatedArrivalAt: '2026-09-20T08:00:00',
    remark: `${context.marker}-${label}`,
    parties: [{ partyType: 'SHIPPER', partyName: `发货方-${value}` },
      { partyType: 'CONSIGNEE', partyName: `收货方-${value}` },
      { partyType: 'NOTIFY_PARTY', partyName: `通知方-${value}` }],
    containerRequirements: [{ containerType: '40HC', containerKind: 'FCL', quantity: 1, capacityCbm: 76,
      maxWeightKg: 28000 }],
  }
  const simulationResponse = await context.request('POST', CONTAINERS, {
    channelCode: summary.channelCode, warehouseId: source.warehouseId, containerType: '40HC',
    capacityCbm: 76, maxWeightKg: 28000,
  })
  const simulation = context.apiSuccess(MODULE, `${label} 新增内部模拟柜`, simulationResponse, '', OPTIONS)
  const containerId = id(simulation?.id)
  if (!containerId) throw new Error(`${label} 未生成内部模拟柜`)
  const createdResponse = await post(context, '/api/platform/v1/ocean-bookings',
    { expectedVersion: 0, data: draft }, `${label}-booking-create`)
  const created = context.apiSuccess(MODULE, `${label} 创建订舱`, createdResponse, '', OPTIONS)
  const bookingId = id(created?.oceanBooking?.id)
  if (!bookingId) throw new Error(`${label} 创建订舱未返回订舱ID`)
  const documentForm = new FormData()
  documentForm.append('expectedVersion', String(Number(created?.oceanBooking?.version)))
  documentForm.append('documentType', 'BOOKING_CONFIRMATION')
  documentForm.append('file', new Blob([`${context.marker}-${label}-BOOKING_CONFIRMATION`],
    { type: 'text/plain' }), `booking-confirmation-${value}.txt`)
  const documentResponse = await context.requestMultipart('POST',
    `/api/platform/v1/ocean-bookings/${bookingId}/documents/upload`, documentForm, context.token,
    { 'Idempotency-Key': operationId(context, `${label}-booking-document`) })
  const document = context.apiSuccess(MODULE, `${label} 上传订舱确认文件`, documentResponse, '', OPTIONS)
  const releaseVersion = Number(document?.bookingVersion)
  if (!Number.isInteger(releaseVersion)) throw new Error(`${label} 订舱确认文件未返回有效版本`)
  const releasedResponse = await post(context, `/api/platform/v1/ocean-bookings/${bookingId}/release`, {
    expectedVersion: releaseVersion, reason: context.marker,
  }, `${label}-booking-release`)
  const confirmed = context.apiSuccess(MODULE, `${label} 放舱订舱`, releasedResponse, '', OPTIONS)
  context.assert(MODULE, `${label} 订舱为 RELEASED 且不预生成真实柜`, releasedResponse,
    confirmed?.oceanBooking?.status === 'RELEASED' && (!confirmed?.containers || confirmed.containers.length === 0),
    `status=${confirmed?.oceanBooking?.status || 'missing'}`, OPTIONS)
  const requirement = confirmed?.containerRequirements?.find?.((item) => item.containerType === '40HC')
  if (!requirement?.id) throw new Error(`${label} 放舱订舱未返回柜型需求`)
  const linkedResponse = await context.request('POST', `${CONTAINERS}/${containerId}/ocean-booking-link`, {
    oceanBookingId: bookingId, requirementId: id(requirement.id), containerNo,
    expectedVersion: Number(simulation.version),
  })
  const linked = context.apiSuccess(MODULE, `${label} 关联模拟柜与真实订舱`, linkedResponse, '', OPTIONS)
  if (id(linked?.id) !== containerId || linked?.cabinetNo !== simulation.cabinetNo) {
    throw new Error(`${label} 关联真实订舱后内部柜次身份漂移`)
  }
  context.apiSuccess(MODULE, `${label} 放舱后关联真实柜号`, linkedResponse, '', OPTIONS)
  return { containerId, containerNo }
}

async function createPlanTask(context, label) {
  const source = await readInbound(context, await prepareInbound(context, label))
  const container = await createConfirmedContainer(context, source, label)
  const { containerId, containerNo } = container
  const candidateResponse = await context.request('GET',
    `${SMART}/candidates?bookingId=${containerId}&warehouseId=${source.warehouseId}`)
  const candidates = context.apiSuccess(MODULE, `${label} 查询同渠道候选货物`, candidateResponse, '', OPTIONS)
  const candidate = Array.isArray(candidates)
    ? candidates.find((item) => id(item.inboundId) === source.inboundId && Number(item.availablePackageCount) > 0)
    : null
  if (!candidate?.inboundDetailId) throw new Error(`${label} 独立入库单未进入同渠道排柜候选`)

  const planResponse = await context.request('GET', `${SMART}/plans/by-booking/${containerId}`)
  let plan = context.apiSuccess(MODULE, `${label} 读取模拟柜自动创建的智能排柜计划`, planResponse, '', OPTIONS)
  const assignResponse = await context.request('POST', `${SMART}/plans/${plan.id}/assignments`, {
    inboundId: source.inboundId, inboundDetailId: id(candidate.inboundDetailId), packageCount: 1,
    expectedVersion: Number(plan.version), operationId: operationId(context, `${label}-assign`),
  })
  plan = context.apiSuccess(MODULE, `${label} 分配独立候选货物`, assignResponse, '', OPTIONS)
  const pushResponse = await context.request('GET', `${SMART}/plans/${plan.id}`)
  plan = context.apiSuccess(MODULE, `${label} 分配后自动建立预装关联`, pushResponse, '', OPTIONS)
  const planId = id(plan?.id)
  const unconfirmedTaskResponse = await context.request('GET',
    `${PDA}/tasks?loadingPlanId=${planId}&warehouseId=${source.warehouseId}`)
  context.addStep(MODULE, `${label} 计划确认前不生成 PDA 任务`, unconfirmedTaskResponse,
    unconfirmedTaskResponse.http === 200 && String(unconfirmedTaskResponse?.body?.code) === 'A0404',
    `HTTP=${unconfirmedTaskResponse.http}, code=${unconfirmedTaskResponse?.body?.code ?? 'missing'}, requestId=${unconfirmedTaskResponse.requestId || 'missing'}, traceId=${unconfirmedTaskResponse.traceId || 'missing'}`, OPTIONS)

  const confirmableResponse = await context.request('GET',
    `${LOADING}/loading-plans/${planId}?warehouseId=${source.warehouseId}`)
  const confirmable = context.apiSuccess(MODULE, `${label} 读取计划级确认即时版本`, confirmableResponse, '', OPTIONS)
  const confirmableVersion = Number(confirmable?.summary?.version)
  context.assert(MODULE, `${label} 整计划允许确认且 PDA 尚未就绪`, confirmableResponse,
    Number.isInteger(confirmableVersion) && confirmable?.summary?.status === 'EDITING'
      && confirmable?.summary?.readiness?.canConfirm === true
      && confirmable?.summary?.readiness?.readyForPda === false
      && confirmable?.summary?.readiness?.pdaTaskId == null,
    `version=${confirmable?.summary?.version ?? 'missing'}, canConfirm=${confirmable?.summary?.readiness?.canConfirm}, pdaTaskId=${id(confirmable?.summary?.readiness?.pdaTaskId) || 'none'}`, OPTIONS)
  if (!Number.isInteger(confirmableVersion) || confirmable?.summary?.readiness?.canConfirm !== true) {
    throw new Error(`${label} 计划尚未满足整计划确认门禁`)
  }

  const confirmPath = `${LOADING}/loading-plans/${planId}/confirm`
  const confirmBody = Object.freeze({ expectedVersion: confirmableVersion })
  const confirmHeaders = Object.freeze({
    'Idempotency-Key': operationId(context, `${label}-plan-confirm`),
  })
  const confirmResponse = await context.request('POST', confirmPath, confirmBody, context.token, confirmHeaders)
  const confirmed = context.apiSuccess(MODULE, `${label} 计划级确认并生成唯一 PDA 任务`, confirmResponse, '', OPTIONS)
  const confirmedTaskId = id(confirmed?.readiness?.pdaTaskId)
  context.assert(MODULE, `${label} 计划确认返回 CONFIRMED 与 readyForPda`, confirmResponse,
    id(confirmed?.planId) === planId && id(confirmed?.containerBookingId) === containerId
      && confirmed?.confirmationStatus === 'CONFIRMED'
      && confirmed?.readiness?.confirmationStatus === 'CONFIRMED'
      && confirmed?.readiness?.readyForPda === true && Boolean(confirmedTaskId)
      && Number(confirmed?.version) > confirmableVersion,
    `confirmationStatus=${confirmed?.confirmationStatus || 'missing'}, readyForPda=${confirmed?.readiness?.readyForPda}, pdaTaskId=${confirmedTaskId || 'missing'}`, OPTIONS)
  if (!confirmedTaskId || confirmed?.confirmationStatus !== 'CONFIRMED') {
    throw new Error(`${label} 计划确认未生成唯一 PDA 任务`)
  }

  const confirmReplay = await context.request('POST', confirmPath, confirmBody, context.token, confirmHeaders)
  context.assert(MODULE, `${label} 计划确认同键同参精确重放`, confirmReplay,
    confirmReplay.http === 200 && String(confirmReplay?.body?.code) === '200'
      && id(confirmReplay?.body?.data?.readiness?.pdaTaskId) === confirmedTaskId
      && Number(confirmReplay?.body?.data?.version) === Number(confirmed.version),
    `HTTP=${confirmReplay.http}, code=${confirmReplay?.body?.code ?? 'missing'}, requestId=${confirmReplay.requestId || 'missing'}, traceId=${confirmReplay.traceId || 'missing'}`, OPTIONS)

  const taskResponse = await context.request('GET',
    `${PDA}/tasks?loadingPlanId=${planId}&warehouseId=${source.warehouseId}`)
  const task = context.apiSuccess(MODULE, `${label} 读取 PDA 任务`, taskResponse, '', OPTIONS)
  if (id(task?.id) !== confirmedTaskId || !task?.items?.[0]?.id) throw new Error(`${label} PDA 任务未生成或身份漂移`)
  return { source, containerId, containerNo, plan, task }
}

async function claim(context, chain, label) {
  const response = await context.request('POST', `${PDA}/tasks/${chain.task.id}/claim`, {
    expectedAssignmentVersion: Number(chain.task?.assignment?.version || 0),
    operationId: operationId(context, `${label}-claim`),
  })
  chain.task = context.apiSuccess(MODULE, `${label} 领取 PDA 任务`, response, '', OPTIONS)
  return chain
}

async function pickAll(context, chain, label) {
  const snapshotResponse = await context.request('GET',
    `${PDA}/tasks/${chain.task.id}/inventory-snapshot?warehouseId=${chain.source.warehouseId}`)
  const snapshot = context.apiSuccess(MODULE, `${label} 获取 PDA 库存快照`, snapshotResponse, '', OPTIONS)
  const response = await post(context, `${PDA}/tasks/${chain.task.id}/batch`, {
    warehouseId: chain.source.warehouseId, loadingPlanId: id(chain.task.loadingPlanId),
    containerBookingId: chain.containerId,
    expectedVersion: Number(chain.task.version), inventorySnapshotToken: snapshot.snapshotToken,
    items: chain.task.items.map((item) => ({ itemId: id(item.id), action: 'PICK',
      pickedPackageCount: Number(item.plannedPackageCount), finalPickedPackageCount: null,
      releaseMode: 'MANUAL', locationIds: [], version: Number(item.version), reason: null })),
  }, `${label}-batch`)
  chain.task = context.apiSuccess(MODULE, `${label} 完成 PDA 拣货`, response, '', OPTIONS)
  return chain
}

async function complete(context, chain, label) {
  await ensureCompletionEvidence(context, chain, label)
  const response = await context.request('POST', `${PDA}/tasks/${chain.task.id}/complete`, {
    expectedTaskVersion: Number(chain.task.version), operationId: operationId(context, `${label}-complete`),
    remark: `${context.marker} 人工完成状态样本`,
  })
  chain.task = context.apiSuccess(MODULE, `${label} 人工确认装柜完成`, response, '', OPTIONS)
  for (let attempt = 0; attempt < 90 && chain.task?.taskStatus !== 'COMPLETED'
      && chain.task?.taskStatus !== 'COMPLETION_FAILED'; attempt += 1) {
    await new Promise((resolve) => setTimeout(resolve, 1_000))
    const detailResponse = await context.request('GET',
      `${PDA}/tasks/${chain.task.id}?warehouseId=${encodeURIComponent(chain.source.warehouseId)}`)
    if (detailResponse.http === 200 && String(detailResponse?.body?.code) === '200') {
      chain.task = detailResponse.body?.data
    }
  }
  return chain
}

async function verifyContainer(context, status, fixture) {
  const response = await context.request('GET', `${CONTAINERS}?status=${status}&page=1&size=100`)
  const page = context.apiSuccess(MODULE, `${status} 货柜可按列表状态筛选`, response, '', OPTIONS)
  context.assert(MODULE, `${status} 货柜样本保留`, response,
    records(page).some((item) => id(item.id) === fixture.id && item.planStatus === status),
    `id=${fixture.id}`, OPTIONS)
}

async function verifyPlan(context, status, fixture) {
  const response = await context.request('GET',
    `${LOADING}/loading-plans?status=${status}&warehouseId=${fixture.warehouseId}&page=1&size=100`)
  const page = context.apiSuccess(MODULE, `${status} 预装清单可筛选`, response, '', OPTIONS)
  context.assert(MODULE, `${status} 预装清单样本保留`, response,
    records(page).some((item) => id(item.planId) === fixture.id && item.status === status),
    `planId=${fixture.id}`, OPTIONS)
  const detailResponse = await context.request('GET',
    `${LOADING}/loading-plans/${fixture.id}?warehouseId=${fixture.warehouseId}`)
  const detail = context.apiSuccess(MODULE, `${status} 预装清单详情可打开`, detailResponse, '', OPTIONS)
  context.assert(MODULE, `${status} 预装清单详情身份正确`, detailResponse,
    id(detail?.summary?.planId) === fixture.id && detail?.summary?.status === status,
    `planId=${fixture.id}, actual=${detail?.summary?.status || 'missing'}`, OPTIONS)
}

async function verifyTask(context, status, fixture) {
  const response = await context.request('GET',
    `${PDA}/tasks/${fixture.id}?warehouseId=${fixture.warehouseId}`)
  const task = context.apiSuccess(MODULE, `${status} PDA 任务可打开`, response, '', OPTIONS)
  context.assert(MODULE, `${status} PDA 任务样本保留`, response,
    id(task?.id) === fixture.id && task?.workflowStatus === status,
    `taskId=${fixture.id}, actual=${task?.workflowStatus || 'missing'}`, OPTIONS)
}

function fixture(value, status, detailPath, extra = {}) {
  return { id: id(value), status, detailPath, ...extra }
}

async function completeSimpleDocuments(context, chain, matrix) {
  const reason = `${context.marker} 人工页面动作验收`
  const clearancePath = `${CONTAINERS}/${chain.containerId}/clearance`
  const clearanceUpload = await uploadDocument(context, `${clearancePath}/document/upload`, 0,
    reason, 'container-clearance')
  const clearanceDocument = context.apiSuccess(MODULE, '货柜公开接口上传目的港清关资料',
    clearanceUpload, '', OPTIONS)
  context.assert(MODULE, '货柜清关上传返回真实文件事实', clearanceUpload,
    Boolean(clearanceDocument?.id) && Boolean(clearanceDocument?.fileId)
      && clearanceDocument?.documentType === 'DESTINATION_CLEARANCE'
      && /^[0-9a-f]{64}$/i.test(String(clearanceDocument?.fileHash || ''))
      && !clearanceDocument?.completedAt,
    `documentId=${id(clearanceDocument?.id) || 'missing'}, version=${clearanceDocument?.version ?? 'missing'}`, OPTIONS)
  if (!clearanceDocument?.id || !clearanceDocument?.fileId || !Number.isInteger(Number(clearanceDocument?.version))) return
  const clearanceCompleteResponse = await post(context, `${clearancePath}/complete`, {
    expectedVersion: Number(clearanceDocument?.version), operationReason: reason,
  }, 'container-clearance-complete')
  const clearanceCompleted = context.apiSuccess(MODULE, '货柜点击完成目的港清关',
    clearanceCompleteResponse, '', OPTIONS)
  context.assert(MODULE, '货柜清关完成事实可回读', clearanceCompleteResponse,
    id(clearanceCompleted?.id) === id(clearanceDocument?.id) && Boolean(clearanceCompleted?.completedAt)
      && Number(clearanceCompleted?.version) === Number(clearanceDocument?.version) + 1,
    `documentId=${id(clearanceCompleted?.id) || 'missing'}, completedAt=${clearanceCompleted?.completedAt || 'missing'}`, OPTIONS)

  matrix.pages.containerLoading.actions = { clearance: fixture(chain.containerId, 'COMPLETED',
    `/container-loading/${chain.containerId}/smart-loading`, {
      documentId: id(clearanceCompleted?.id), documentVersion: Number(clearanceCompleted?.version),
      completedAt: clearanceCompleted?.completedAt || null,
    }) }
}

export async function run(context, matrix = context.createdResources.manualStateMatrix) {
  if (!matrix?.pages) {
    context.addStep(MODULE, '人工装柜状态模块由人工矩阵统一编排', null, false,
      'missing=manualStateMatrix.pages；请通过 manual-state-matrix 入口执行', OPTIONS)
    return
  }
  matrix.pages.containerLoading = { requiredStatuses: CONTAINER_STATUSES,
    requiredActions: ['clearance'], fixtures: {}, actions: {} }
  matrix.pages.preloadPlans = { requiredStatuses: PRELOAD_STATUSES, fixtures: {} }
  matrix.pages.loadingLists = { requiredStatuses: ['COMPLETED'],
    requiredActions: [], fixtures: {}, actions: {} }
  matrix.pages.pdaTasks = { requiredStatuses: PDA_STATUSES, fixtures: {} }

  const waitingSource = await readInbound(context, await prepareInbound(context, 'WAIT'))
  const waitingContainer = await createConfirmedContainer(context, waitingSource, 'WAIT')
  matrix.pages.containerLoading.fixtures.WAIT_LOADING = fixture(waitingContainer.containerId, 'WAIT_LOADING',
    `/container-loading?containerId=${waitingContainer.containerId}`)

  const editing = await createPlanTask(context, 'EDIT')
  const inProgress = await claim(context, await createPlanTask(context, 'PROGRESS'), 'PROGRESS')
  const awaiting = await pickAll(context,
    await claim(context, await createPlanTask(context, 'REVIEW'), 'REVIEW'), 'REVIEW')
  const completed = await complete(context, await pickAll(context,
    await claim(context, await createPlanTask(context, 'DONE'), 'DONE'), 'DONE'), 'DONE')

  const loadingOrderId = id(inProgress.source?.detail?.summary?.orderId)
  const loadingTenantId = id(inProgress.source?.tenantId)
  const loadingOrderResponse = await context.request('GET',
    `/api/platform/v1/orders/${encodeURIComponent(loadingOrderId)}?tenantId=${encodeURIComponent(loadingTenantId)}`)
  const loadingOrder = context.apiSuccess(MODULE, '读取人工 PROGRESS 对应 LOADING 统一订单', loadingOrderResponse, '', OPTIONS)
  context.assert(MODULE, '人工 PROGRESS 稳定提供统一订单 LOADING 样本', loadingOrderResponse,
    id(loadingOrder?.summary?.orderId) === loadingOrderId && loadingOrder?.summary?.mainStatus === 'LOADING',
    `orderId=${loadingOrderId || 'missing'}, status=${loadingOrder?.summary?.mainStatus || 'missing'}`, OPTIONS)
  if (loadingOrderId && loadingOrder?.summary?.mainStatus === 'LOADING') {
    matrix.pages.unifiedOrders.fixtures.LOADING = {
      id: loadingOrderId, status: 'LOADING', inboundId: inProgress.source.inboundId,
      detailPath: `/orders/${loadingOrderId}`,
    }
  }

  const chains = { EDITING: editing, LOADING: inProgress, COMPLETED: completed }
  for (const [status, chain] of Object.entries(chains)) {
    matrix.pages.containerLoading.fixtures[status] = fixture(chain.containerId, status,
      `/container-loading/${chain.containerId}/smart-loading`, { planId: id(chain.plan.id) })
  }
  for (const [status, chain] of Object.entries({ EDITING: editing, LOADING: inProgress })) {
    matrix.pages.preloadPlans.fixtures[status] = fixture(chain.plan.id, status,
      `/loading-plans/${chain.plan.id}?warehouseId=${chain.source.warehouseId}`,
      { warehouseId: chain.source.warehouseId })
  }
  matrix.pages.loadingLists.fixtures.COMPLETED = fixture(completed.plan.id, 'COMPLETED',
    `/loading-lists?planId=${completed.plan.id}&warehouseId=${completed.source.warehouseId}`,
    { warehouseId: completed.source.warehouseId })

  const taskChains = { UNASSIGNED: editing, IN_PROGRESS: inProgress, AWAITING_REVIEW: awaiting, COMPLETED: completed }
  for (const [status, chain] of Object.entries(taskChains)) {
    matrix.pages.pdaTasks.fixtures[status] = fixture(chain.task.id, status,
      `/pages/picking/picking?taskId=${chain.task.id}&warehouseId=${chain.source.warehouseId}`,
      { warehouseId: chain.source.warehouseId, loadingPlanId: id(chain.plan.id) })
  }

  for (const [status, value] of Object.entries(matrix.pages.containerLoading.fixtures))
    await verifyContainer(context, status, value)
  for (const [status, value] of Object.entries(matrix.pages.preloadPlans.fixtures))
    await verifyPlan(context, status, value)
  for (const [status, value] of Object.entries(matrix.pages.pdaTasks.fixtures))
    await verifyTask(context, status, value)

  const listFixture = matrix.pages.loadingLists.fixtures.COMPLETED
  const listResponse = await context.request('GET',
    `${LOADING}/loading-lists?warehouseId=${listFixture.warehouseId}&page=1&size=100`)
  const list = context.apiSuccess(MODULE, 'COMPLETED 装柜清单可从列表打开', listResponse, '', OPTIONS)
  context.assert(MODULE, 'COMPLETED 装柜清单样本保留', listResponse,
    records(list).some((item) => id(item.planId) === listFixture.id && item.status === 'COMPLETED'),
    `planId=${listFixture.id}`, OPTIONS)
  const listDetailResponse = await context.request('GET',
    `${LOADING}/loading-lists/${listFixture.id}?warehouseId=${listFixture.warehouseId}`)
  const listDetail = context.apiSuccess(MODULE, 'COMPLETED 装柜清单详情可打开', listDetailResponse, '', OPTIONS)
  context.assert(MODULE, 'COMPLETED 装柜清单详情身份正确', listDetailResponse,
    id(listDetail?.summary?.planId) === listFixture.id && listDetail?.summary?.status === 'COMPLETED',
    `planId=${listFixture.id}, actual=${listDetail?.summary?.status || 'missing'}`, OPTIONS)

  await completeSimpleDocuments(context, completed, matrix)
}
import { iso6346ContainerNumber } from './iso6346-container-number.mjs'