import { portScheduleFieldGaps } from './fulfillment-list-field-contract.mjs'

const MODULE = 'phase3-port-schedules'
const OPTIONS = { scenario: 'port-schedule-source-lifecycle', deploymentBlocker: true }
const BASE = '/api/platform/v1/port-schedules'
const OCEAN = '/api/platform/v1/ocean-bookings'
const OUTBOUND = '/api/platform/v1/first-leg/outbound-dispatches'
import { resolveOceanBookingMaster, oceanBookingDraft } from './ocean-booking-fixture.mjs'
import { createHash } from 'node:crypto'

export function customsRetentionDigest(value) {
  const canonical = input => Array.isArray(input) ? input.map(canonical)
    : input && typeof input === 'object' ? Object.fromEntries(Object.keys(input).sort().map(key => [key, canonical(input[key])]))
      : input
  return createHash('sha256').update(JSON.stringify(canonical(value))).digest('hex')
}

export async function verifyTaxCustomsAfterShipEdit(context, fixture) {
  if (fixture?.marker !== context.marker || !fixture?.loadingPlanId || !fixture?.queryId || !fixture?.scheduleId) {
    throw new Error('requires current marker owned tax customs, query and schedule fixture')
  }
  const customsPath = `/api/platform/v1/customs/loading-plans/${fixture.loadingPlanId}`
  const queryPath = `/api/platform/v1/carrier-schedule-queries/${fixture.queryId}`
  async function read(path, name) {
    const response = await request(context, 'GET', path)
    const value = context.apiSuccess(MODULE, name, response, '', OPTIONS)
    if (!value) throw new Error(`${name} failed`)
    return value
  }
  const beforeCustoms = await read(customsPath, '改船前冻结同一退税柜完整资料回执确认事实')
  const completedTax = beforeCustoms.status === 'COMPLETED' && Number(beforeCustoms.taxRefundCount) > 0
    && id(beforeCustoms.loadingPlanId) === id(fixture.loadingPlanId)
    && id(beforeCustoms.containerBookingId) === id(fixture.containerBookingId)
    && beforeCustoms.documents?.length > 0
    && beforeCustoms.documents.every(document => document.source?.fileId && document.receipt?.fileId
      && document.receiptStatus === 'CONFIRMED' && document.finalDocument?.fileId)
  context.assert(MODULE, '改船样本为本轮已完成且含资料回执确认完成文件的退税柜', null,
    completedTax, `loadingPlanId=${fixture.loadingPlanId}, taxRefundCount=${beforeCustoms.taxRefundCount}`, OPTIONS)
  if (!completedTax) throw new Error('requires completed tax customs evidence')
  const beforeQuery = await read(queryPath, '改船前冻结原柜唯一船任务与正常节点')
  const beforeSchedule = await read(`${BASE}/${fixture.scheduleId}`, '改船前读取原柜船期')
  const schedule = beforeSchedule.portSchedule?.schedule
  const beforeTask = beforeQuery.query?.query
  if (!schedule || id(beforeTask?.id) !== id(fixture.queryId) || id(schedule.containerBookingId) !== id(fixture.containerBookingId)
    || id(beforeTask?.containerBookingId) !== id(fixture.containerBookingId)) throw new Error('ship fixture identity mismatch')
  const editedData = { ...Object.fromEntries(['customerId', 'oceanBookingId', 'containerBookingId',
    'sourceType', 'sourceName', 'sourceRef', 'departurePortCode', 'departurePortName',
    'destinationPortCode', 'destinationPortName', 'etdAt', 'etaAt', 'bookingCutoffAt',
    'customsCutoffAt', 'portCutoffAt', 'observedAt', 'expiresAt', 'remark']
    .map(key => [key, schedule[key]])), vesselName: `人工改船-${context.marker}`.slice(0, 128),
    voyageNo: `R-${context.marker}`.slice(0, 64) }
  const response = await request(context, 'PUT', `${BASE}/${fixture.scheduleId}`,
    { expectedVersion: Number(schedule.version), data: editedData, reason: `${context.marker} 原柜人工改船` },
    { 'Idempotency-Key': `${context.marker}-tax-ship-edit`.slice(0, 128) })
  const edited = context.apiSuccess(MODULE, '退税报关完成后在原柜人工改船', response, '', OPTIONS)
  if (!edited) throw new Error('ship edit failed')
  const afterCustoms = await read(customsPath, '改船后读取同一退税柜完整资料回执确认事实')
  const afterQuery = await read(queryPath, '改船后回查原唯一船任务与正常节点')
  const afterSchedule = await read(`${BASE}/${fixture.scheduleId}`, '改船后读取修改历史')
  const selector = new URLSearchParams({ containerBookingId: fixture.containerBookingId, page: '1', size: '200' })
  const page = await read(`/api/platform/v1/carrier-schedule-queries?${selector}`, '改船后按原柜核对船任务唯一')
  const customsBeforeDigest = customsRetentionDigest(beforeCustoms)
  const customsAfterDigest = customsRetentionDigest(afterCustoms)
  context.assert(MODULE, '原柜改船前后报关资料回执确认完成文件完整摘要零漂移', null,
    customsBeforeDigest === customsAfterDigest, `before=${customsBeforeDigest}, after=${customsAfterDigest}`, OPTIONS)
  const sameTask = ['id', 'containerBookingId', 'oceanBookingId', 'trackingNo', 'latestActualNode', 'latestActualAt']
    .every(key => id(beforeTask[key]) === id(afterQuery.query?.query?.[key]))
  context.assert(MODULE, '原柜改船保留唯一查询任务和全部已记录正常节点', null,
    sameTask && customsRetentionDigest(beforeQuery.nodes) === customsRetentionDigest(afterQuery.nodes)
      && Number(page.total) === 1 && id(page.records?.[0]?.query?.id) === id(fixture.queryId),
    `queryId=${fixture.queryId}, total=${page.total}`, OPTIONS)
  const latest = afterSchedule.portSchedule?.schedule
  const update = afterSchedule.histories?.at(-1)
  context.assert(MODULE, '人工改船保留原柜订舱及操作人原因版本历史', null,
    id(latest?.id) === id(schedule.id) && id(latest?.containerBookingId) === id(schedule.containerBookingId)
      && id(latest?.oceanBookingId) === id(schedule.oceanBookingId)
      && latest?.vesselName === editedData.vesselName && latest?.voyageNo === editedData.voyageNo
      && update?.action === 'UPDATE' && Boolean(update.operatorId && update.createdAt)
      && Number(update.toVersion) === Number(schedule.version) + 1,
    `scheduleId=${fixture.scheduleId}, historyId=${update?.id || 'missing'}`, OPTIONS)
  context.createdResources.taxCustomsShipRetention = { fixture, beforeCustoms, afterCustoms,
    customsBeforeDigest, customsAfterDigest, beforeQuery, afterQuery, beforeSchedule, afterSchedule }
}

function id(value) { return value == null ? '' : String(value) }
function codeOf(response) { return response?.body?.code == null ? 'missing' : String(response.body.code) }
function data(response) { return codeOf(response) === '200' ? response.body.data : null }
const SHANGHAI_TIME = new Intl.DateTimeFormat('en-CA', {
  timeZone: 'Asia/Shanghai', year: 'numeric', month: '2-digit', day: '2-digit',
  hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',
})
function localIso(value) {
  const parts = Object.fromEntries(SHANGHAI_TIME.formatToParts(value)
    .filter((part) => part.type !== 'literal').map((part) => [part.type, part.value]))
  return `${parts.year}-${parts.month}-${parts.day}T${parts.hour}:${parts.minute}:${parts.second}`
}
function at(offsetMinutes) { return localIso(new Date(Date.now() + offsetMinutes * 60_000)) }
function step(context, name, response, passed, evidence) {
  context.addStep(MODULE, name, response, passed, evidence, { ...OPTIONS, deploymentBlocker: !passed })
}
async function request(context, method, path, body, headers = {}) {
  try {
    const response = await fetch(`${context.options.gateway}${path}`, {
      method,
      headers: {
        Accept: 'application/json', Authorization: `Bearer ${context.token}`,
        ...(body === undefined ? {} : { 'Content-Type': 'application/json; charset=utf-8' }), ...headers,
      },
      body: body === undefined ? undefined : JSON.stringify(body), signal: AbortSignal.timeout(60_000),
    })
    const raw = await response.text(); let payload = null
    try { payload = raw ? JSON.parse(raw) : null } catch { /* bounded raw evidence */ }
    return { method, path, http: response.status, body: payload, raw: payload === null ? raw.slice(0, 500) : null, requestId: payload?.requestId || response.headers.get('x-request-id'), traceId: payload?.traceId || response.headers.get('x-trace-id') }
  } catch (error) {
    return { method, path, http: 0, body: null, raw: String(error), requestId: null, traceId: null }
  }
}

function oceanDraft(context, suffix, master) {
  return {
    ...oceanBookingDraft(context, suffix, master),
    departurePortCode: 'CNSZX',
    departurePortName: '深圳', destinationPortCode: 'USLAX', destinationPortName: '洛杉矶',
    placeOfDelivery: 'LAX',
    remark: context.marker,
    parties: [
      { partyType: 'SHIPPER', partyName: `发货方-${suffix}` },
      { partyType: 'CONSIGNEE', partyName: `收货方-${suffix}` },
      { partyType: 'NOTIFY_PARTY', partyName: `通知方-${suffix}` },
    ],
  }
}

export function portScheduleCustomerScope(bookingCustomerId) {
  if (bookingCustomerId == null) return '0'
  const value = String(bookingCustomerId)
  if (!/^[1-9][0-9]*$/.test(value)) throw new Error('ocean booking customer scope must be null or a positive ID')
  return value
}

async function ensureOceanBooking(context, suffix, master, preferredOceanBookingId = null) {
  const existingId = id(preferredOceanBookingId || context.createdResources?.oceanBooking?.id)
  if (existingId) {
    const response = await request(context, 'GET', `${OCEAN}/${existingId}`)
    const detail = context.apiSuccess(MODULE, '读取船期关联订舱真实柜次分配', response,
      `oceanBookingId=${existingId}`, OPTIONS)
    return detail?.oceanBooking ? {
      id: existingId,
      customerId: portScheduleCustomerScope(detail.oceanBooking.customerId),
      allocatedContainerBookingIds: (detail.containers || [])
        .map((item) => id(item?.containerBookingId)).filter(Boolean),
    } : null
  }
  const response = await request(context, 'POST', OCEAN, { expectedVersion: 0, data: oceanDraft(context, suffix, master) },
    { 'Idempotency-Key': `${context.marker}-port-ocean`.slice(0, 128) })
  const detail = context.apiSuccess(MODULE, '创建本轮隔离船期关联订舱', response, '', OPTIONS)
  const oceanBookingId = id(detail?.oceanBooking?.id)
  context.assert(MODULE, '船期关联订舱客户归属明确', response,
    Boolean(oceanBookingId) && id(detail?.oceanBooking?.customerId) === id(master.customerId),
    `oceanBookingId=${oceanBookingId || 'missing'}, customerId=${id(detail?.oceanBooking?.customerId) || 'missing'}`, OPTIONS)
  return oceanBookingId ? {
    id: oceanBookingId, customerId: portScheduleCustomerScope(detail.oceanBooking.customerId),
    allocatedContainerBookingIds: (detail.containers || [])
      .map((item) => id(item?.containerBookingId)).filter(Boolean),
  } : null
}

function scheduleData(context, suffix, oceanBookingId, containerBookingId, customerId, expired = false) {
  return {
    customerId, oceanBookingId, containerBookingId: containerBookingId || null,
    sourceType: 'CARRIER', sourceName: `验收船司-${suffix}`, sourceRef: `${context.marker}-SOURCE-${expired ? 'EXPIRED' : 'CURRENT'}`,
    vesselName: `港务船-${suffix}`, voyageNo: `PV${suffix}`, departurePortCode: 'CNSZX', departurePortName: '深圳',
    destinationPortCode: 'USLAX', destinationPortName: '洛杉矶', etdAt: at(10 * 24 * 60), etaAt: at(30 * 24 * 60),
    bookingCutoffAt: at(7 * 24 * 60), customsCutoffAt: at(8 * 24 * 60), portCutoffAt: at(9 * 24 * 60),
    observedAt: expired ? at(-120) : at(-1), expiresAt: expired ? at(-60) : at(60), remark: context.marker,
  }
}

export async function run(context) {
  // 官网船期查询任务、频率限制和 FAILED/EXPIRED 终态由
  // phase3-carrier-schedule-queries 模块通过真实 HTTP 契约验收；此处只保留
  // 仍受第三方交互能力限制的 ZIM/COSCO 外部缺口，避免重复报告已实现能力。
  context.addCoverageGap(MODULE, OPTIONS.scenario, 'ZIM 官网 hCaptcha 自动查询',
    'ZIM hCaptcha 需要第三方交互能力，仓库未公开 provider/task 契约；保留为外部依赖缺口',
    'external-third-party')
  context.addCoverageGap(MODULE, OPTIONS.scenario, 'COSCO 动态页面自动查询',
    'COSCO 动态页面没有已公开 provider/task 契约或稳定机器接口；保留为外部依赖缺口',
    'external-third-party')
  const suffix = context.marker.replace(/\D/g, '').slice(-10)
  const probe = await request(context, 'GET', `${BASE}?page=1&size=5&keyword=${encodeURIComponent(context.marker)}`)
  if (probe.http === 404 || probe.http === 405 || probe.http === 503 || probe.http === 0) {
    step(context, '港务船期真实平台契约已部署', probe, false,
      `入口 ${BASE} 不可用：HTTP=${probe.http}, code=${codeOf(probe)}`)
    return
  }
  const page = context.apiSuccess(MODULE, '港务船期分页入口可用', probe, '', OPTIONS)
  context.assert(MODULE, '港务船期分页结构稳定', probe,
    Array.isArray(page?.records) && Number.isFinite(Number(page?.total)),
    `records=${page?.records?.length ?? 'n/a'}, total=${page?.total ?? 'n/a'}`, OPTIONS)

  const publicResponse = await request(context, 'GET', `${BASE}?customerId=0&page=1&size=5`)
  const publicPage = context.apiSuccess(MODULE, '平台公共船期支持customerId=0查询', publicResponse, '', OPTIONS)
  context.assert(MODULE, '平台公共船期查询不混入其他客户', publicResponse,
    Array.isArray(publicPage?.records) && publicPage.records.every(row => id(row?.schedule?.customerId) === '0'),
    `records=${publicPage?.records?.length ?? 'missing'}`, OPTIONS)

  const master = await resolveOceanBookingMaster(context, MODULE)
  if (!master) return
  const flow = context.createdResources?.phase3Loading
    || context.createdResources?.phase3ContainerLoading
  const ocean = await ensureOceanBooking(context, suffix, master, flow?.oceanBookingId)
  if (!ocean?.id) return
  const containerBookingId = id(flow?.containerBookingId) || null
  const knownAllocation = containerBookingId
    && ocean.allocatedContainerBookingIds?.includes(containerBookingId) ? containerBookingId : null
  if (containerBookingId && !knownAllocation) {
    context.addStep(MODULE, '船期订舱真实分配包含本轮装货柜次', null, false,
      `oceanBookingId=${ocean.id}, containerBookingId=${containerBookingId}, allocations=${ocean.allocatedContainerBookingIds?.join(',') || 'none'}`,
      OPTIONS)
    return
  }
  const scheduleCustomerId = ocean.customerId
  const payload = { expectedVersion: 0, data: scheduleData(context, suffix, ocean.id, knownAllocation, scheduleCustomerId), reason: context.marker }
  const createKey = `${context.marker}-port-create`.slice(0, 128)
  const createResponse = await request(context, 'POST', BASE, payload, { 'Idempotency-Key': createKey })
  const created = context.apiSuccess(MODULE, '新增独立港务船期观测', createResponse, '', OPTIONS)
  const scheduleId = id(created?.portSchedule?.schedule?.id)
  const scheduleFieldGaps = portScheduleFieldGaps(created)
  context.assert(MODULE, '船期来源、时效、截单截关截港和关联字段完整', createResponse,
    Boolean(scheduleId) && created?.portSchedule?.expired === false
      && created?.portSchedule?.schedule?.sourceType === 'CARRIER'
      && id(created?.portSchedule?.schedule?.oceanBookingId) === ocean.id
      && Boolean(created?.portSchedule?.schedule?.observedAt)
      && Boolean(created?.portSchedule?.schedule?.updatedAt)
      && Boolean(created?.portSchedule?.schedule?.expiresAt)
      && Boolean(created?.portSchedule?.schedule?.bookingCutoffAt)
      && Boolean(created?.portSchedule?.schedule?.customsCutoffAt)
      && Boolean(created?.portSchedule?.schedule?.portCutoffAt),
    `scheduleId=${scheduleId || 'missing'}, expired=${created?.portSchedule?.expired ?? 'missing'}`, OPTIONS)
  context.assert(MODULE, '船期列表来源、船名航次、港口与关键时间字段格式完整', createResponse,
    scheduleFieldGaps.length === 0, `missing=${scheduleFieldGaps.join(',') || 'none'}`, OPTIONS)
  if (!scheduleId) return

  const replay = await request(context, 'POST', BASE, payload, { 'Idempotency-Key': createKey })
  context.assert(MODULE, '新增船期 Idempotency-Key 重放返回同一资源', replay,
    id(data(replay)?.portSchedule?.schedule?.id) === scheduleId,
    `first=${scheduleId}, replay=${id(data(replay)?.portSchedule?.schedule?.id) || 'missing'}`, OPTIONS)

  for (const [name, query] of [
    ['按客户查询船期', `customerId=${encodeURIComponent(ocean.customerId)}`],
    ['按订舱查询船期', `oceanBookingId=${ocean.id}`],
    ...(knownAllocation ? [['按柜次查询船期', `containerBookingId=${knownAllocation}`]] : []),
  ]) {
    const response = await request(context, 'GET', `${BASE}?page=1&size=20&${query}`)
    const records = data(response)?.records
    step(context, name, response, response.http === 200 && codeOf(response) === '200'
      && Array.isArray(records) && records.some((item) => id(item?.schedule?.id) === scheduleId),
    `records=${records?.length ?? 'n/a'}, scheduleId=${scheduleId}`)
  }

  const initialVersion = Number(created.portSchedule.schedule.version)
  const expiredData = scheduleData(context, suffix, ocean.id, knownAllocation, scheduleCustomerId, true)
  expiredData.sourceRef = payload.data.sourceRef
  // 甩柜只修改原柜的船信息；柜次、订舱关联和船期任务身份保持不变。
  expiredData.vesselName = `甩柜改配船-${suffix}`
  expiredData.voyageNo = `R${suffix}`
  const updateResponse = await request(context, 'PUT', `${BASE}/${scheduleId}`,
    { expectedVersion: initialVersion, data: expiredData, reason: '来源刷新并过期' },
    { 'Idempotency-Key': `${context.marker}-port-update`.slice(0, 128) })
  const updated = context.apiSuccess(MODULE, '更新船期并计算过期状态', updateResponse, '', OPTIONS)
  context.assert(MODULE, '过期标识由expiresAt服务端计算且版本递增', updateResponse,
    updated?.portSchedule?.expired === true
      && Number(updated?.portSchedule?.schedule?.version) === initialVersion + 1,
    `expired=${updated?.portSchedule?.expired ?? 'missing'}, version=${updated?.portSchedule?.schedule?.version ?? 'missing'}`, OPTIONS)
  context.assert(MODULE, '甩柜改船只更新原柜船信息且不改变柜次订舱关联', updateResponse,
    id(updated?.portSchedule?.schedule?.id) === scheduleId
      && id(updated?.portSchedule?.schedule?.oceanBookingId) === ocean.id
      && id(updated?.portSchedule?.schedule?.containerBookingId) === (knownAllocation || '')
      && updated?.portSchedule?.schedule?.vesselName === expiredData.vesselName
      && updated?.portSchedule?.schedule?.voyageNo === expiredData.voyageNo,
    `schedule=${id(updated?.portSchedule?.schedule?.id)}, ocean=${id(updated?.portSchedule?.schedule?.oceanBookingId)}, container=${id(updated?.portSchedule?.schedule?.containerBookingId)}, vessel=${updated?.portSchedule?.schedule?.vesselName || 'missing'}, voyage=${updated?.portSchedule?.schedule?.voyageNo || 'missing'}`, OPTIONS)

  const stale = await request(context, 'PUT', `${BASE}/${scheduleId}`,
    { expectedVersion: initialVersion, data: expiredData, reason: '旧版本覆盖' },
    { 'Idempotency-Key': `${context.marker}-port-stale`.slice(0, 128) })
  step(context, '旧版本更新船期返回乐观锁冲突', stale,
    stale.http === 200 && ['A0409', '409'].includes(codeOf(stale)),
    `HTTP=${stale.http}, code=${codeOf(stale)}`)

  const expiredQuery = await request(context, 'GET', `${BASE}?page=1&size=20&expired=true&oceanBookingId=${ocean.id}`)
  const expiredRecords = data(expiredQuery)?.records
  step(context, '按过期标识查询船期', expiredQuery,
    expiredQuery.http === 200 && codeOf(expiredQuery) === '200' && Array.isArray(expiredRecords)
      && expiredRecords.some((item) => id(item?.schedule?.id) === scheduleId && item?.expired === true),
    `records=${expiredRecords?.length ?? 'n/a'}`)

  const detailResponse = await request(context, 'GET', `${BASE}/${scheduleId}`)
  const detail = context.apiSuccess(MODULE, '回查港务船期详情与历史', detailResponse, '', OPTIONS)
  context.assert(MODULE, '船期详情保留来源更新时间和CREATE/UPDATE历史', detailResponse,
    detail?.portSchedule?.expired === true && detail?.histories?.length >= 2
      && detail.histories.some((item) => item.action === 'CREATE')
      && detail.histories.some((item) => item.action === 'UPDATE')
      && detail.histories.every((item) => item.operatorId && item.createdAt),
    `histories=${detail?.histories?.length ?? 'n/a'}`, OPTIONS)
  const historyResponse = await request(context, 'GET', `${BASE}/${scheduleId}/history`)
  const histories = context.apiSuccess(MODULE, '独立查询船期不可变历史', historyResponse, '', OPTIONS)
  context.assert(MODULE, '船期历史端点顺序和版本字段稳定', historyResponse,
    Array.isArray(histories) && histories.length >= 2
      && histories[0]?.action === 'CREATE' && histories.at(-1)?.toVersion === initialVersion + 1,
    `histories=${histories?.length ?? 'n/a'}`, OPTIONS)

  const inboundId = id(flow?.inboundId)
  if (knownAllocation && inboundId) {
    const expiredGateResponse = await request(context, 'GET', `${OUTBOUND}/${encodeURIComponent(containerBookingId)}/gate`)
    const expiredGate = context.apiSuccess(MODULE, '过期船期接入国内出仓统一门禁', expiredGateResponse, '', OPTIONS)
    const gateItems = (expiredGate?.inbounds || []).flatMap((item) => item?.gate?.items || [])
    context.assert(MODULE, '船期独立于当前国内离仓六项门禁', expiredGateResponse,
      Array.isArray(expiredGate?.inbounds) && !gateItems.some((item) => item?.code === 'SAILING_SCHEDULE'),
      `inbounds=${expiredGate?.inbounds?.length ?? 'missing'}, obsoleteScheduleGate=${gateItems.some((item) => item?.code === 'SAILING_SCHEDULE')}`, OPTIONS)
  }

  const currentData = scheduleData(context, suffix, ocean.id, knownAllocation, scheduleCustomerId, false)
  currentData.sourceRef = payload.data.sourceRef
  currentData.sourceType = 'MANUAL'
  currentData.sourceName = `平台人工兜底-${suffix}`
  const refreshResponse = await request(context, 'PUT', `${BASE}/${scheduleId}`,
    { expectedVersion: initialVersion + 1, data: currentData, reason: '刷新为当前有效船期' },
    { 'Idempotency-Key': `${context.marker}-port-refresh`.slice(0, 128) })
  const refreshed = context.apiSuccess(MODULE, '刷新船期为国内出仓可用终态', refreshResponse, '', OPTIONS)
  context.assert(MODULE, '刷新后船期有效且版本再次递增', refreshResponse,
    refreshed?.portSchedule?.expired === false
      && refreshed?.portSchedule?.schedule?.sourceType === 'MANUAL'
      && refreshed?.portSchedule?.schedule?.sourceName === currentData.sourceName
      && Number(refreshed?.portSchedule?.schedule?.version) === initialVersion + 2,
    `expired=${refreshed?.portSchedule?.expired ?? 'missing'}, sourceType=${refreshed?.portSchedule?.schedule?.sourceType || 'missing'}, version=${refreshed?.portSchedule?.schedule?.version ?? 'missing'}`, OPTIONS)

  if (knownAllocation && inboundId) {
    const readyGateResponse = await request(context, 'GET', `${OUTBOUND}/${encodeURIComponent(containerBookingId)}/gate`)
    const readyGate = context.apiSuccess(MODULE, '有效船期重新检查国内出仓统一门禁', readyGateResponse, '', OPTIONS)
    const gateItems = (readyGate?.inbounds || []).flatMap((item) => item?.gate?.items || [])
    context.assert(MODULE, '有效船期不改变当前国内离仓六项门禁集合', readyGateResponse,
      Array.isArray(readyGate?.inbounds) && !gateItems.some((item) => item?.code === 'SAILING_SCHEDULE'),
      `inbounds=${readyGate?.inbounds?.length ?? 'missing'}, obsoleteScheduleGate=${gateItems.some((item) => item?.code === 'SAILING_SCHEDULE')}`, OPTIONS)
  }

  const forged = await request(context, 'POST', BASE, {
    expectedVersion: 0,
    data: { ...scheduleData(context, `${suffix}X`, ocean.id, null, ocean.customerId), customerId: `${ocean.customerId}999` },
    reason: '伪造客户归属',
  }, { 'Idempotency-Key': `${context.marker}-port-forged-customer`.slice(0, 128) })
  step(context, '伪造船期客户归属被拒绝', forged,
    forged.http === 200 && ['A0400', '400'].includes(codeOf(forged)),
    `HTTP=${forged.http}, code=${codeOf(forged)}`)

  context.createdResources.portSchedule = {
    id: scheduleId, oceanBookingId: ocean.id, containerBookingId: knownAllocation,
    inboundId: inboundId || null, expired: false, gateReady: Boolean(knownAllocation && inboundId),
  }
}