import { findPricedOrderRouteAcrossOrigins } from './orders.mjs'

const MODULE = 'order-inbound-status-fixtures'
const OPTIONS = { scenario: 'manual-order-inbound-status-matrix', deploymentBlocker: true }
const MERCHANT_USERNAME = process.env.MERCHANT_TEST_USERNAME || 'merchant_admin'
const MERCHANT_PASSWORD = process.env.MERCHANT_TEST_PASSWORD || 'ChangeMe123!'

const ORDER_TARGETS = [
  ['DRAFT', []],
  ['SUBMITTED', ['submit']],
  ['REJECTED', ['submit', 'reject']],
  ['APPROVED', ['submit', 'approve']],
  ['ACCEPTED', ['submit', 'approve', 'accept']],
  ['PROCESSING', ['submit', 'approve', 'accept', 'start']],
  ['COMPLETED', ['submit', 'approve', 'accept', 'start', 'complete']],
  ['CANCELLED', ['cancel']],
]
const INBOUND_FILTER_STATUSES = [
  'WAIT_MEASURE', 'MEASURING', 'MEASURE_PENDING', 'MEASURE_REJECTED', 'WAIT_PRICING',
  'FEE_CONFIRMING', 'INBOUNDING', 'WAIT_SPLIT', 'VOIDED',
]
const UNIFIED_FILTER_STATUSES = [
  'PENDING_REVIEW', 'WAIT_MEASURE', 'WAIT_SPLIT', 'LOADING', 'LOADED', 'DELIVERED',
]

function id(value) { return value == null ? '' : String(value) }
function rows(value) { return Array.isArray(value?.records) ? value.records : [] }
function ok(response) { return response?.http === 200 && String(response?.body?.code) === '200' }
function data(response) { return response?.body?.data }
function key(context, operation) { return `${context.marker}-manual-${operation}`.slice(0, 128) }
function query(value) { return encodeURIComponent(String(value)) }
function wait(milliseconds) { return new Promise((resolve) => setTimeout(resolve, milliseconds)) }

function recordCoverageGap(context, name, reason, category = 'fixture-unavailable') {
  context.addCoverageGap?.(MODULE, OPTIONS.scenario, name, reason, category, { marker: context.marker })
  context.addStep(MODULE, `${name}（coverage gap 已登记）`, null, true, reason, {
    scenario: OPTIONS.scenario, deploymentBlocker: false,
  })
}

async function merchantRequest(context, method, path, body, token, headers = {}) {
  const requestHeaders = { Accept: 'application/json', Authorization: `Bearer ${token}`, ...headers }
  const payload = body === undefined ? undefined : JSON.stringify(body)
  if (payload !== undefined) requestHeaders['Content-Type'] = 'application/json; charset=utf-8'
  try {
    const response = await fetch(`${context.options.gateway}${path}`, {
      method, headers: requestHeaders, body: payload, signal: AbortSignal.timeout(30_000),
    })
    const content = await response.text()
    let parsed = null
    try { parsed = content ? JSON.parse(content) : null } catch { /* Keep bounded raw evidence. */ }
    return { method, path, http: response.status, body: parsed, raw: parsed ? null : content.slice(0, 500),
      requestId: parsed?.requestId || response.headers.get('x-request-id'),
      traceId: parsed?.traceId || response.headers.get('x-trace-id') }
  } catch (error) {
    return { method, path, http: 0, body: null, raw: String(error), requestId: null, traceId: null }
  }
}

async function merchantGet(context, path, token) {
  return merchantRequest(context, 'GET', path, undefined, token)
}

async function loadFixtureInputs(context, token) {
  const profileResponse = await merchantGet(context, '/api/merchant/v1/iam/tenant/profile', token)
  const profile = context.apiSuccess(MODULE, '读取 IT 测试客户资料', profileResponse)
  const domesticResponse = await merchantGet(context,
    '/api/merchant/v1/warehouses?page=1&size=200&status=ACTIVE&warehouseType=DOMESTIC', token)
  const domesticPage = context.apiSuccess(MODULE, '读取国内收货仓', domesticResponse)
  const receivings = rows(domesticPage).filter((item) => item?.status === 'ACTIVE')
  const destinationResponse = await merchantGet(context,
    '/api/merchant/v1/warehouses?page=1&size=200&status=ACTIVE&warehouseType=FBA', token)
  const destinations = rows(context.apiSuccess(MODULE, '读取 FBA 目的仓', destinationResponse))
  if (!profile?.id || receivings.length === 0 || destinations.length === 0) throw new Error('状态样本缺少客户或仓库基础数据')
  const priced = await findPricedOrderRouteAcrossOrigins({
    receivings, destinations,
    loadChannels: (receiving) => merchantGet(context,
      `/api/merchant/v1/first-leg/pricing/channels?originWarehouseId=${query(receiving.id)}`, token),
    estimate: (body) => merchantRequest(context, 'POST', '/api/merchant/v1/first-leg/pricing/estimate', body, token),
  })
  if (!priced.receiving || !priced.priced) throw new Error('状态样本缺少真实可计价的仓库/渠道/目的仓组合')
  return { tenantId: id(profile.id), customerName: profile.tenantName || 'IT 测试客户',
    domestic: priced.receiving, destination: priced.priced.destination, channel: priced.priced.channel,
    pricingTaxMode: priced.priced.pricingTaxMode }
}

function orderPayload(context, fixture, target) {
  const sample = `${context.marker}-${target}`
  const shipmentId = `MANUAL-${target}-${context.marker}`.slice(0, 64)
  const referenceId = `STATUS-${target}-${context.marker}`.slice(0, 64)
  const upcNo = `${String(context.marker).replace(/\D/g, '').slice(-11)}${ORDER_TARGETS.findIndex(([status]) => status === target) + 1}`
    .slice(-12).padStart(12, '0')
  return {
    customerId: null, customerName: fixture.customerName, transportMode: 'SEA', tradeTerm: 'FOB',
    destinationCountryCode: fixture.destination.countryCode || 'US',
    destinationWarehouseId: fixture.destination.id, destinationWarehouseName: fixture.destination.warehouseName,
    expectedShipDate: new Date(Date.now() + 30 * 86400000).toISOString().slice(0, 10),
    customerRemark: `${sample} 人工列表状态样本`, pickupMethod: 'PICKUP',
    receivingWarehouseId: fixture.domestic.id, receivingWarehouseName: fixture.domestic.warehouseName,
    channelCode: fixture.channel.channelCode, channelName: fixture.channel.channelName,
    carrierId: null, carrierName: null, taxMode: 'BUY_DECLARATION',
    pricingTaxMode: fixture.pricingTaxMode, containerMode: 'LCL', customsInspection: false,
    destinationType: 'FBA', amazonWarehouseCode: fixture.destination.warehouseCode,
    shipmentId, referenceId,
    sender: { companyName: fixture.customerName, contactName: 'IT 测试联系人', phone: '13800138000',
      email: 'it-test@example.com', countryCode: 'CN', province: '广东省', city: '深圳市', district: '南山区',
      addressLine: `${sample} 测试地址`, postalCode: '518000' },
    receiver: null,
    cargoes: [{ cargoName: `${target} 状态样本货物`, cargoNameEn: `${target} fixture cargo`, hsCode: '8518210000',
      customsHsCode: '8518210000', packageType: 'CARTON', packageCount: 1, grossWeightKg: 10,
      volumeCbm: 0.024, lengthCm: 40, widthCm: 30, heightCm: 20, declaredValue: 100, currency: 'USD',
      dangerousGoods: false, cargoRemark: sample, skuNo: `SKU-${target}-${context.marker}`.slice(0, 64),
      upcNo, shipmentId, referenceId,
      unitsPerPackage: 10, totalQuantity: 10, netWeightKg: 9, unitDeclaredValue: 10,
      material: '塑料', usage: '人工验收', model: `MODEL-${target}`, brand: 'IT-TEST' }],
  }
}

async function createOrder(context, token, fixture, target) {
  const response = await merchantRequest(context, 'POST', '/api/merchant/v1/orders/first-leg',
    orderPayload(context, fixture, target), token, { 'Idempotency-Key': key(context, `${target}-create`) })
  const orderId = id(context.apiSuccess(MODULE, `创建 ${target} 订单状态样本`, response))
  if (!orderId) throw new Error(`${target} 状态样本未返回订单 ID`)
  return orderId
}

async function transition(context, token, fixture, orderId, target, action) {
  const merchantPath = `/api/merchant/v1/orders/first-leg/${query(orderId)}`
  if (action === 'submit') {
    const response = await merchantRequest(context, 'POST', `${merchantPath}/submit`, undefined, token,
      { 'Idempotency-Key': key(context, `${target}-submit`) })
    context.apiSuccess(MODULE, `${target} 样本提交订单`, response)
    return
  }
  const platformPath = `/api/platform/v1/orders/first-leg/${query(orderId)}/${action}?tenantId=${query(fixture.tenantId)}`
  const body = action === 'reject' || action === 'cancel' ? { reason: `${context.marker} 保留 ${target} 人工样本` } : undefined
  const response = await context.request('POST', platformPath, body)
  context.apiSuccess(MODULE, `${target} 样本执行 ${action}`, response)
}

async function readOrder(context, fixture, orderId) {
  const response = await context.request('GET',
    `/api/platform/v1/orders/first-leg/${query(orderId)}?tenantId=${query(fixture.tenantId)}`)
  return { response, detail: context.apiSuccess(MODULE, '回读订单状态样本', response) }
}

async function waitForInbound(context, fixture, orderId) {
  const path = `/api/platform/v1/orders/${query(orderId)}?tenantId=${query(fixture.tenantId)}`
  for (let attempt = 0; attempt < 20; attempt += 1) {
    const response = await context.request('GET', path)
    const summary = data(response)?.summary
    if (ok(response) && summary?.inboundId
      && ['WAIT_MEASURE', 'MEASURING', 'MEASURE_PENDING', 'MEASURE_REJECTED', 'WAIT_SPLIT'].includes(summary.mainStatus)) {
      return { response, summary }
    }
    if (attempt < 19) await wait(500)
  }
  return { response: null, summary: null }
}

async function prepareInboundStatus(context, target) {
  const originalMarker = context.marker
  const originalRequest = context.request
  const fixtureMarker = `${originalMarker}-IN-${target}`
  const stop = Symbol(target)
  const createdKeys = ['orders', 'ocrInbound', 'testInbound', 'inboundMeasurement', 'inboundWarehouseResources']
  const contextKeys = ['inboundWeightOcr', 'ocrInbound', 'testInbound', 'createdInbound']
  const createdSnapshot = new Map(createdKeys.map((name) => [name,
    { present: Object.hasOwn(context.createdResources, name), value: context.createdResources[name] }]))
  const contextSnapshot = new Map(contextKeys.map((name) => [name,
    { present: Object.hasOwn(context.context, name), value: context.context[name] }]))
  try {
    context.marker = fixtureMarker
    const orders = await import(new URL('./orders.mjs', import.meta.url))
    await orders.run(context)
    const order = { ...context.createdResources.orders }
    const inboundId = id(order.inboundId)
    const tenantId = id(order.tenantId)
    if (!inboundId || !tenantId) throw new Error(`${target} 未生成独立待测量入库单`)
    const detailPath = `/api/platform/inbounds/${query(inboundId)}?tenantId=${query(tenantId)}`

    if (target === 'MEASURING') {
      const weightOcr = await import(new URL('./inbound-weight-ocr.mjs', import.meta.url))
      await weightOcr.run(context)
    }

    context.request = async (method, path, body, token, headers) => {
      const isSubmit = path.includes(`/inbounds/${inboundId}/measurement/submit`)
      if (target === 'MEASURE_PENDING' && isSubmit) {
        const response = await originalRequest.call(context, method, path, body, token, headers)
        if (!ok(response)) throw new Error(`MEASURE_PENDING 提交失败: HTTP=${response?.http}, code=${response?.body?.code}`)
        throw stop
      }
      if (target === 'MEASURE_REJECTED' && isSubmit) {
        const submitted = await originalRequest.call(context, method, path, body, token, headers)
        if (!ok(submitted)) throw new Error(`MEASURE_REJECTED 提交失败: HTTP=${submitted?.http}, code=${submitted?.body?.code}`)
        const latest = await originalRequest.call(context, 'GET', detailPath, undefined, token)
        const version = Number(data(latest)?.summary?.version)
        const rejectPath = `/api/platform/v1/inbounds/${query(inboundId)}/measurements/reject?tenantId=${query(tenantId)}`
        const rejected = await originalRequest.call(context, 'POST', rejectPath,
          { measurementId: body?.measurementId, expectedVersion: version, reason: `${fixtureMarker} 保留审核驳回样本` },
          token, { 'Idempotency-Key': `${fixtureMarker}-reject`.slice(0, 128) })
        if (!ok(rejected)) throw new Error(`MEASURE_REJECTED 审核驳回失败: HTTP=${rejected?.http}, code=${rejected?.body?.code}, requestId=${rejected?.requestId || 'missing'}, traceId=${rejected?.traceId || 'missing'}`)
        throw stop
      }
      return originalRequest.call(context, method, path, body, token, headers)
    }
    if (target !== 'MEASURING') {
      try {
        const measurement = await import(new URL('./inbound-measurement.mjs', import.meta.url))
        await measurement.run(context)
      } catch (error) {
        if (error !== stop) throw error
      } finally {
        context.request = originalRequest
      }
    }

    const response = await originalRequest.call(context, 'GET',
      `/api/platform/inbounds/${query(inboundId)}?tenantId=${query(tenantId)}`)
    const detail = context.apiSuccess(MODULE, `回读 ${target} 独立入库单`, response, '', OPTIONS)
    context.assert(MODULE, `${target} 入库状态样本可从详情打开`, response,
      detail?.summary?.processStatus === target, `inboundId=${inboundId}, actual=${detail?.summary?.processStatus || 'missing'}`, OPTIONS)
    return { inboundId, orderId: id(order.orderId), tenantId, status: target,
      inboundCode: detail?.summary?.inboundCode || null }
  } finally {
    context.request = originalRequest
    context.marker = originalMarker
    for (const [name, snapshot] of createdSnapshot) {
      if (snapshot.present) context.createdResources[name] = snapshot.value
      else Reflect.deleteProperty(context.createdResources, name)
    }
    for (const [name, snapshot] of contextSnapshot) {
      if (snapshot.present) context.context[name] = snapshot.value
      else Reflect.deleteProperty(context.context, name)
    }
  }
}

export async function run(context, matrix = context.createdResources.manualStateMatrix) {
  if (!matrix) {
    matrix = { marker: context.marker, generatedAt: new Date().toISOString(), pages: {} }
    context.createdResources.manualStateMatrix = matrix
  }
  matrix.pages ||= {}
  const loginResponse = await context.request('POST', '/api/auth/login',
    { username: MERCHANT_USERNAME, password: MERCHANT_PASSWORD }, '')
  const token = context.apiSuccess(MODULE, 'IT 测试客户管理员登录', loginResponse)?.accessToken
  if (!token) throw new Error('客户管理员登录未返回 accessToken')
  const fixture = await loadFixtureInputs(context, token)
  const result = { marker: context.marker, tenantId: fixture.tenantId, orders: {}, inbounds: {}, unifiedOrders: {} }
  matrix.pages.firstLegOrders = { requiredStatuses: ORDER_TARGETS.map(([status]) => status), fixtures: {} }
  matrix.pages.inbounds = { requiredStatuses: INBOUND_FILTER_STATUSES, fixtures: {} }
  matrix.pages.unifiedOrders = { requiredStatuses: UNIFIED_FILTER_STATUSES, fixtures: {} }

  for (const [target, actions] of ORDER_TARGETS) {
    const orderId = await createOrder(context, token, fixture, target)
    for (const action of actions) await transition(context, token, fixture, orderId, target, action)
    const { response, detail } = await readOrder(context, fixture, orderId)
    context.assert(MODULE, `${target} 订单状态样本可从详情打开`, response,
      id(detail?.order?.id) === orderId && detail?.order?.status === target,
      `orderId=${orderId}, status=${detail?.order?.status ?? 'missing'}`)
    result.orders[target] = { orderId, orderNo: detail?.order?.orderNo || null, status: target,
      listPath: `/admin/first-leg-orders?status=${target}` }
    matrix.pages.firstLegOrders.fixtures[target] = {
      id: orderId, status: target, detailPath: `/orders/${orderId}`,
    }

    if (actions.includes('approve')) {
      const inbound = await waitForInbound(context, fixture, orderId)
      const inboundId = id(inbound.summary?.inboundId)
      context.assert(MODULE, `${target} 订单生成待测量入库单`, inbound.response, Boolean(inboundId),
        `orderId=${orderId}, inboundId=${inboundId || 'missing'}`)
      if (inboundId && !result.inbounds.WAIT_MEASURE) result.inbounds.WAIT_MEASURE = {
        inboundId, inboundCode: inbound.summary?.inboundCode || null, orderId, processStatus: 'WAIT_MEASURE',
        listPath: '/admin/inbounds?processStatus=WAIT_MEASURE',
      }
    }
  }

  for (const [status, sample] of Object.entries(result.orders)) {
    const response = await context.request('GET',
      `/api/platform/v1/orders/first-leg?tenantId=${query(fixture.tenantId)}&status=${status}&keyword=${query(sample.orderNo)}&page=1&size=20`)
    const page = context.apiSuccess(MODULE, `${status} 订单可按列表状态筛选`, response)
    context.assert(MODULE, `${status} 筛选结果包含人工样本`, response,
      rows(page).some((item) => id(item.id) === sample.orderId), `orderId=${sample.orderId}, total=${page?.total ?? 'n/a'}`)
  }

  const waitMeasure = result.inbounds.WAIT_MEASURE
  if (waitMeasure) matrix.pages.inbounds.fixtures.WAIT_MEASURE = {
    id: waitMeasure.inboundId, status: 'WAIT_MEASURE', detailPath: `/orders/${waitMeasure.orderId}`,
  }

  const submitted = result.orders.SUBMITTED
  result.unifiedOrders.PENDING_REVIEW = { orderId: submitted.orderId, orderNo: submitted.orderNo,
    mainStatus: 'PENDING_REVIEW', listPath: '/admin/unified-orders?mainStatus=PENDING_REVIEW' }
  matrix.pages.unifiedOrders.fixtures.PENDING_REVIEW = {
    id: submitted.orderId, status: 'PENDING_REVIEW', detailPath: `/orders/${submitted.orderId}`,
  }
  if (waitMeasure) result.unifiedOrders.WAIT_MEASURE = { orderId: waitMeasure.orderId,
    inboundId: waitMeasure.inboundId, mainStatus: 'WAIT_MEASURE', listPath: '/admin/unified-orders?mainStatus=WAIT_MEASURE' }
  if (waitMeasure) matrix.pages.unifiedOrders.fixtures.WAIT_MEASURE = {
    id: waitMeasure.orderId, status: 'WAIT_MEASURE', detailPath: `/orders/${waitMeasure.orderId}`,
  }

  for (const status of ['MEASURING', 'MEASURE_PENDING', 'MEASURE_REJECTED', 'WAIT_SPLIT']) {
    const sample = await prepareInboundStatus(context, status)
    result.inbounds[status] = sample
    matrix.pages.inbounds.fixtures[status] = {
      id: sample.inboundId, status, detailPath: `/orders/${sample.orderId}`,
    }
    if (status === 'WAIT_SPLIT') {
      result.unifiedOrders.WAIT_SPLIT = sample
      matrix.pages.unifiedOrders.fixtures.WAIT_SPLIT = {
        id: sample.orderId, status, detailPath: `/orders/${sample.orderId}`,
      }
    }
  }

  if (!result.inbounds.WAIT_SPLIT) {
    const legacyResponse = await context.request('GET',
      `/api/platform/v1/inbounds?tenantId=${query(fixture.tenantId)}&processStatus=WAIT_SPLIT&page=1&size=20`)
    const legacyPage = context.apiSuccess(MODULE, '查询存量 WAIT_SPLIT 样本', legacyResponse, '', OPTIONS)
    const legacyInbound = rows(legacyPage)[0]
    if (legacyInbound?.id && legacyInbound?.orderId) {
    const sample = { inboundId: id(legacyInbound.id), orderId: id(legacyInbound.orderId), tenantId: fixture.tenantId,
      status: 'WAIT_SPLIT', inboundCode: legacyInbound.inboundCode || null }
    result.inbounds.WAIT_SPLIT = sample
    result.unifiedOrders.WAIT_SPLIT = sample
    matrix.pages.inbounds.fixtures.WAIT_SPLIT = {
      id: sample.inboundId, status: 'WAIT_SPLIT', detailPath: `/orders/${sample.orderId}`,
    }
    matrix.pages.unifiedOrders.fixtures.WAIT_SPLIT = {
      id: sample.orderId, status: 'WAIT_SPLIT', detailPath: `/orders/${sample.orderId}`,
    }
    }
  }

  const blockers = {
    WAIT_PRICING: '审核通过先进入 WAIT_PRICING，但自动计费与入库编排会继续推进，不能稳定停留',
    FEE_CONFIRMING: '需要先取得可匹配的真实计价快照并停在费用确认前',
    INBOUNDING: 'AutomaticInboundCompletionService 在同一调用内立即从 INBOUNDING 推进 WAIT_SPLIT，无可暂停 API',
    VOIDED: 'InboundProcessStatus 声明了 VOIDED，但当前 Controller/Service 没有作废入库单 API',
  }
  for (const status of INBOUND_FILTER_STATUSES) if (!matrix.pages.inbounds.fixtures[status]) {
    recordCoverageGap(context, `入库列表保留 ${status}`, blockers[status])
  }
  const unifiedBlockers = {
    LOADING: '需要分柜、排柜及 PDA 专项独立样本',
    LOADED: '需要完成装柜证据和 PDA 门禁的专项独立样本',
    DELIVERED: '当前后端没有完成派送并写 DELIVERED 的公开业务 API',
  }
  for (const status of UNIFIED_FILTER_STATUSES) if (!matrix.pages.unifiedOrders.fixtures[status]) {
    recordCoverageGap(context, `统一订单列表保留 ${status}`, unifiedBlockers[status])
  }

  context.addStep(MODULE, '登记订单/入库人工状态矩阵', null, true,
    `orders=${Object.keys(result.orders).length}, inbounds=${Object.keys(result.inbounds).length}`, OPTIONS)
}