const MODULE = 'service-center-flow'
const OPTIONS = { scenario: 'service-center-cross-flow', deploymentBlocker: true }
const OCEAN = '/api/platform/v1/ocean-bookings'
const TRUCK = '/api/platform/v1/truck-appointments'

function id(value) { return value == null ? '' : String(value) }
const FORBIDDEN_TRUCK_FIELDS = ['customerId', 'customerName', 'containerBookingId', 'loadingPlanId',
  'cabinetNo', 'containerNo']
function bookingLevel(value) { return value != null && FORBIDDEN_TRUCK_FIELDS.every((field) => !Object.hasOwn(value, field)) }

async function actionRequest(context, path, endpoint, version) {
  try {
    const response = await fetch(`${context.options.gateway}${path}/${endpoint}`, {
      method: 'POST',
      headers: {
        Accept: 'application/json', Authorization: `Bearer ${context.token}`,
        'Content-Type': 'application/json; charset=utf-8',
        'Idempotency-Key': `${context.marker}-flow-${endpoint}`.slice(0, 128),
      },
      body: JSON.stringify({ expectedVersion: version, reason: context.marker }),
      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: 'POST', path: `${path}/${endpoint}`, 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: 'POST', path: `${path}/${endpoint}`, http: 0, body: null,
      raw: String(error), requestId: null, traceId: null }
  }
}

export async function run(context) {
  const containerFlow = context.createdResources?.phase3Loading
    || context.createdResources?.phase3ContainerLoading
  const ocean = containerFlow?.oceanBookingId
    ? { id: id(containerFlow.oceanBookingId), finalStatus: 'RELEASED' }
    : context.createdResources?.oceanBooking
  if (!ocean?.id || ocean.finalStatus !== 'RELEASED') {
    context.addStep(MODULE, '跨服务链路前置订舱终态可用', null, false,
      '本轮海运订舱模块未返回 RELEASED 隔离记录，未伪造关联拖车预约', OPTIONS)
    return
  }

  const suffix = context.marker.replace(/\D/g, '').slice(-10)
  const oceanResponse = await context.request('GET', `${OCEAN}/${ocean.id}`)
  const oceanDetail = context.apiSuccess(MODULE, '读取跨服务链路已放舱订舱', oceanResponse, `oceanBookingId=${ocean.id}`, OPTIONS)
  const allocationMatches = oceanDetail?.containers?.some?.((item) =>
    id(item?.containerBookingId) === id(containerFlow.containerBookingId))
  context.assert(MODULE, '已放舱订舱保留本轮柜次分配', oceanResponse, allocationMatches,
    `containerBookingId=${id(containerFlow.containerBookingId)}, containers=${oceanDetail?.containers?.length ?? 'n/a'}`, OPTIONS)
  if (!allocationMatches) return
  const carrierResponse = await context.request('GET',
    '/api/platform/v1/suppliers?tenantId=0&category=TRUCKING&status=ACTIVE&page=1&size=20')
  const carrierPage = context.apiSuccess(MODULE, '读取 ACTIVE TRUCKING 承运商事实源', carrierResponse, '', OPTIONS)
  const carrier = carrierPage?.records?.find?.((item) => item?.id && item?.name)
  context.assert(MODULE, '跨服务拖车使用正式 ACTIVE TRUCKING 承运商', carrierResponse,
    Boolean(carrier?.id && carrier?.name), `carrierId=${id(carrier?.id) || 'missing'}`, OPTIONS)
  if (!carrier) return
  const payload = {
    outboundOrderId: null, oceanBookingId: ocean.id, warehouseId: id(oceanDetail?.oceanBooking?.warehouseId),
    carrierId: id(carrier.id), carrierName: carrier.name,
    billOfLadingNo: oceanDetail?.oceanBooking?.billOfLadingNo,
    fleetContact: '链路车队联系人', fleetPhone: '13800000007', driverName: '链路司机', driverPhone: '13800000008',
    driverIdCard: null, vehicleNo: `粤D-${suffix.slice(-6)}`, storeName: `链路门店-${suffix}`, storeContact: '链路联系人',
    storePhone: '13800000009', storeAddress: '深圳市南山区链路地址', storeCity: '深圳市', storeZipcode: '518000',
    packageCount: 1, grossWeightKg: 1, volumeCbm: 0.1, palletCount: 0, poNo: `FLOW-PO-${suffix}`,
    plannedLoadingAt: '2026-09-03T08:00:00', transitMinutes: 60, payableAmount: 1,
    currency: 'RMB', remark: context.marker, expectedVersion: 0,
  }
  context.assert(MODULE, '跨服务拖车创建请求仅使用订舱级协议', oceanResponse,
    bookingLevel(payload) && Boolean(payload.warehouseId && payload.billOfLadingNo),
    `fields=${Object.keys(payload).join(',')}`, OPTIONS)
  const response = await context.request('POST', TRUCK, payload)
  const appointment = context.apiSuccess(MODULE, '创建订舱级跨服务拖车预约', response, `oceanBookingId=${ocean.id}`, OPTIONS)
  const appointmentId = id(appointment?.id)
  context.assert(MODULE, '拖车预约关联订舱、版本和审计字段完整且无柜次协议', response,
    Boolean(appointmentId) && id(appointment?.oceanBookingId) === id(ocean.id) && Number.isFinite(Number(appointment?.version))
      && bookingLevel(appointment) && Boolean(appointment?.createdAt || appointment?.createdBy || appointment?.operatorName),
    `appointmentId=${appointmentId || 'missing'}, oceanBookingId=${appointment?.oceanBookingId || 'missing'}, version=${appointment?.version ?? 'missing'}`, OPTIONS)
  if (!appointmentId) return
  const path = `${TRUCK}/${appointmentId}`
  let version = Number(appointment.version)
  for (const [name, endpoint, status] of [
    ['提交跨链路预约', 'submit', 'PENDING_DISPATCH'],
    ['派发跨链路拖车', 'dispatch', 'DISPATCHED'],
    ['跨链路开始提货', 'pickup', 'PICKUP_IN_PROGRESS'],
    ['跨链路拖车到仓', 'arrive', 'ARRIVED_WAREHOUSE'],
    ['跨链路开始装货', 'load', 'LOADING'],
    ['跨链路拖车离仓', 'depart', 'DEPARTED'],
    ['完成跨链路拖车', 'complete', 'COMPLETED'],
  ]) {
    const action = await actionRequest(context, path, endpoint, version)
    const changed = context.apiSuccess(MODULE, name, action, '', OPTIONS)
    context.assert(MODULE, `${name}状态正确`, action, changed?.status === status,
      `status=${changed?.status || 'missing'}, version=${changed?.version ?? 'missing'}`, OPTIONS)
    if (!changed) return
    version = Number(changed.version)
  }
  const detail = await context.request('GET', `${TRUCK}/${appointmentId}`)
  const final = context.apiSuccess(MODULE, '回查跨服务链路安全终态', detail, '', OPTIONS)
  context.assert(MODULE, '跨服务链路终态持久化且关联订舱未漂移', detail,
    final?.status === 'COMPLETED' && id(final?.oceanBookingId) === id(ocean.id)
      && bookingLevel(final),
    `status=${final?.status || 'missing'}, oceanBookingId=${final?.oceanBookingId || 'missing'}`, OPTIONS)

  const historyResponse = await context.request('GET', `${TRUCK}/${appointmentId}/history`)
  const history = context.apiSuccess(MODULE, '查询跨服务链路拖车预约状态历史', historyResponse, '', OPTIONS)
  const actions = Array.isArray(history) ? history.filter((item) => item?.action !== 'CREATE') : []
  const expectedActions = ['SUBMIT', 'DISPATCH', 'PICKUP', 'ARRIVE', 'LOAD', 'DEPART', 'COMPLETE']
  context.assert(MODULE, '跨服务链路历史包含完整状态链、操作者、时间和备注', historyResponse,
    expectedActions.every((action) => actions.some((item) => item.action === action
      && id(item.appointmentId) === appointmentId && Boolean(item.operatorId)
      && Boolean(item.operatorName) && Boolean(item.createdAt) && item.reason === context.marker)),
    `history=${history?.length ?? 'n/a'}, actions=${actions.map((item) => item.action).join(',')}`,
    OPTIONS)
  if (final?.status === 'COMPLETED') {
    context.createdResources.serviceCenterFlow = {
      appointmentId, oceanBookingId: ocean.id,
      marker: context.marker, finalStatus: 'COMPLETED',
    }
  }
}