import assert from 'node:assert/strict'
import test from 'node:test'
import { readFileSync } from 'node:fs'
import ts from 'typescript'
import * as vue from 'vue'
import * as pinia from 'pinia'

function compile(path, dependencies) {
  const source = readFileSync(new URL(path, import.meta.url), 'utf8')
  const code = ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 } }).outputText
  const exports = {}
  new Function('require', 'exports', code)(id => { assert.ok(id in dependencies, id); return dependencies[id] }, exports)
  return exports
}
function harness(t) {
  const context = pinia.createPinia(); pinia.setActivePinia(context)
  t.after(() => pinia.disposePinia(context))
  const calls = []
  const behavior = { failWrite: false, failRead: false, version: 9, status: 'DRAFT' }
  const api = compile('../api/firstLeg.ts', { '@/api/http': { apiRequest: async config => {
    calls.push(structuredClone(config))
    if (config.method === 'GET') {
      if (behavior.failRead) throw new Error('读取失败')
      return { order: { id: 'one', orderNo: 'FL-ONE', version: behavior.version, status: behavior.status, receivingWarehouseId: 'warehouse', destinationCountryCode: 'US' }, cargoes: [] }
    }
    if (behavior.failWrite) throw new Error('响应丢失')
  } } })
  const module = compile('./firstLegOrders.ts', {
    vue, pinia,
    '@/modules/first-leg/api/firstLeg': api,
    '@/modules/first-leg/api/unifiedOrders': {
      getMerchantUnifiedOrder: async () => ({ summary: { orderId: 'one', mainStatus: null }, order: { order: { id: 'one', status: behavior.status, version: behavior.version, receivingWarehouseId: 'warehouse' } }, timeline: [] }),
      isUnifiedOrderQueryUnavailable: () => false,
    },
    '@/modules/first-leg/utils/firstLegOrder': { canClientEditFirstLegOrder: status => status === 'DRAFT', getFirstLegStatusLabel: value => value },
    '@/modules/first-leg/utils/warehousePagination': {},
  })
  const store = module.useFirstLegOrdersStore()
  store.warehouses = [{ id: 'warehouse', name: '国内仓', warehouseType: 'DOMESTIC' }]
  const draft = { receivingWarehouseId: 'warehouse', destinationType: 'PRIVATE', destinationCountryCode: 'US', items: [], customerRemark: '原草稿' }
  return { store, api, calls, behavior, draft }
}

test('raw and unified cancelled detail remain CANCELLED even when unified mainStatus is null', async t => {
  const h = harness(t)
  h.behavior.status = 'CANCELLED'
  const raw = await h.store.loadDraftDetail('one')
  assert.equal(raw.status, 'CANCELLED')
  const unified = await h.store.loadDetail('one')
  assert.equal(unified.status, 'CANCELLED')
  h.behavior.status = 'APPROVED'
  const unknown = await h.store.loadDetail('one')
  assert.notEqual(unknown.status, 'CANCELLED', 'unknown summary must not be reclassified as cancellation')
})

test('cancelled detail summary has no pending overseas synchronization entries', () => {
  const source = readFileSync(new URL('../views/FirstLegOrdersView.vue', import.meta.url), 'utf8')
  const script = source.match(/<script setup lang="ts">([\s\S]*?)<\/script>/)[1]
  const ast = ts.createSourceFile('view.ts', script, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
  const declaration = ast.statements.flatMap(node => ts.isVariableStatement(node) ? [...node.declarationList.declarations] : []).find(node => node.name.getText(ast) === 'progressSummaryItems')
  const code = ts.transpileModule('const progressSummaryItems = ' + declaration.initializer.getText(ast), { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText
  const summary = new Function('computed', 'detailOrder', code + '; return progressSummaryItems.value')(vue.computed, { value: { status: 'CANCELLED' } })
  assert.deepEqual(summary, [])
})

test('edit freezes detail version rather than cached list version and replays same key/body after uncertain result', async t => {
  const h = harness(t)
  const original = await h.store.loadDraftDetail('one')
  const session = h.store.beginDraftEdit(original)
  h.store.orders[0].version = 0
  h.behavior.failWrite = true
  await assert.rejects(h.store.saveDraft(h.draft, '测试企业', 'one', session), /响应丢失/)
  const first = h.calls.find(call => call.method === 'PUT')
  assert.equal(first.data.expectedVersion, 9)
  assert.equal(first.data.draft.customerRemark, '原草稿')
  assert.ok(first.headers['Idempotency-Key'])
  assert.deepEqual(h.calls.map(call => call.method), ['GET', 'PUT'], 'no pre-save version refresh')
  h.behavior.failWrite = false; h.behavior.version = 10
  const result = await h.store.saveDraft(h.draft, '测试企业', 'one', session)
  const writes = h.calls.filter(call => call.method === 'PUT')
  assert.deepEqual(writes[1], first)
  assert.deepEqual(h.calls.map(call => call.method), ['GET', 'PUT', 'GET', 'PUT', 'GET'])
  assert.equal(result.version, 10)
})

test('changed retry payload or missing edit session fails closed without issuing a new write', async t => {
  const h = harness(t)
  await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one'), /重新打开/)
  assert.equal(h.calls.length, 0)
  const session = h.store.beginDraftEdit(await h.store.loadDraftDetail('one'))
  h.behavior.failWrite = true
  await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one', session))
  h.draft.customerRemark = '不同内容'
  await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one', session), /重试原内容/)
  assert.equal(h.calls.filter(call => call.method === 'PUT').length, 1)
  assert.equal(session.expectedVersion, 9)
  assert.ok(Object.isFrozen(session))
})

test('read failure after successful edit preserves the same command for retry', async t => {
  const h = harness(t)
  const session = h.store.beginDraftEdit(await h.store.loadDraftDetail('one'))
  h.behavior.failRead = true
  await assert.rejects(h.store.saveDraft(h.draft, '客户', 'one', session), /读取失败/)
  h.behavior.failRead = false
  await h.store.saveDraft(h.draft, '客户', 'one', session)
  const writes = h.calls.filter(call => call.method === 'PUT')
  assert.deepEqual(writes[0], writes[1])
})

test('cancel forwards version and reason without rejecting submitted orders locally; retry keeps key and body', async t => {
  const h = harness(t)
  h.behavior.status = 'SUBMITTED'
  h.store.orders = [{ id: 'one', status: 'PENDING_REVIEW', version: 0 }]
  h.behavior.failWrite = true
  await assert.rejects(h.store.cancelOrder('one', 12, '客户要求取消'), /响应丢失/)
  const first = h.calls[0]
  assert.equal(first.method, 'POST')
  assert.equal(first.url, '/merchant/v1/orders/first-leg/one/cancel')
  assert.deepEqual(first.data, { expectedVersion: 12, reason: '客户要求取消' })
  await assert.rejects(h.store.cancelOrder('one', 13, '其他原因'), /原版本和原因/)
  assert.equal(h.calls.length, 1)
  h.behavior.failWrite = false
  await h.store.cancelOrder('one', 12, '客户要求取消')
  assert.deepEqual(h.calls[2], first)
  assert.equal(h.calls[1].method, 'GET')
  assert.equal(h.store.orders.length, 0)
})

test('cancel requires a detail version and a nonempty reason', async t => {
  const h = harness(t)
  await assert.rejects(h.store.cancelOrder('one', undefined, '理由'))
  await assert.rejects(h.store.cancelOrder('one', 1, ' '))
  assert.equal(h.calls.length, 0)
})

test('cancellation decision reads raw server status and version including SUBMITTED', async t => {
  const h = harness(t)
  for (const status of ['DRAFT', 'SUBMITTED', 'APPROVED', 'ACCEPTED', 'REJECTED']) {
    h.behavior.status = status
    const target = await h.store.prepareCancellation('one')
    assert.equal(target.expectedVersion, 9)
    assert.equal(target.businessNo, 'FL-ONE')
  }
  for (const status of ['PROCESSING', 'COMPLETED', 'CANCELLED']) {
    h.behavior.status = status
    await assert.rejects(h.store.prepareCancellation('one'), /不允许取消/)
  }
  assert.ok(h.calls.every(call => call.method === 'GET'))
})

function cancellationViewHarness() {
  const source = readFileSync(new URL('../views/FirstLegOrdersView.vue', import.meta.url), 'utf8').match(/<script setup lang="ts">([\s\S]*?)<\/script>/)[1]
  const ast = ts.createSourceFile('view.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
  const functions = ast.statements.filter(node => ts.isFunctionDeclaration(node) && ['canOfferCancellation', 'cancelOrder'].includes(node.name?.text)).map(node => node.getText(ast)).join('\n')
  const code = ts.transpileModule(functions, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText
  const calls = [], messages = [], prompts = []
  const canCancelOrder = vue.ref(true), cancellingOrderId = vue.ref(''), pendingCancellation = vue.shallowRef()
  class ApiError extends Error { constructor() { super('订单版本已变化'); this.code = 'A0409'; this.status = 409 } }
  const behavior = { error: null }
  const store = {
    prepareCancellation: async id => { calls.push(['prepare', id]); return { id, expectedVersion: 12, businessNo: 'FL-ONE', statusLabel: '审核中' } },
    cancelOrder: async (...args) => { calls.push(['cancel', ...args]); if (behavior.error) throw behavior.error },
    load: async query => calls.push(['load', query]),
  }
  const ElMessageBox = {
    prompt: async (message, title, options) => { prompts.push({ message, title, options }); return { value: '客户申请取消' } },
    confirm: async (...args) => calls.push(['confirm', ...args]),
  }
  const ElMessage = { error: message => messages.push(message), warning: message => messages.push(message), success: message => messages.push(message) }
  const globals = { canCancelOrder, cancellingOrderId, pendingCancellation, store, ElMessageBox, ElMessage, ApiError,
    isDetailPage: vue.ref(true), router: { push: async route => calls.push(['route', route]) } }
  const handler = new Function(...Object.keys(globals), code + '\nreturn cancelOrder')(...Object.values(globals))
  return { handler, calls, messages, prompts, canCancelOrder, pendingCancellation, behavior, ApiError }
}

test('cancel UI uses mandatory-reason centered prompt and refreshes after successful submitted-order cancellation', async () => {
  const h = cancellationViewHarness()
  await h.handler({ id: 'one', status: 'PENDING_REVIEW' })
  assert.match(h.prompts[0].message, /FL-ONE.*审核中/)
  const validate = h.prompts[0].options.inputValidator
  assert.notEqual(validate(' '), true)
  assert.notEqual(validate('x'.repeat(501)), true)
  assert.equal(validate('合理原因'), true)
  assert.deepEqual(h.calls.map(call => call[0]), ['prepare', 'cancel', 'load', 'route'])
  assert.deepEqual(h.calls[1], ['cancel', 'one', 12, '客户申请取消'])
})

test('cancel UI keeps an uncertain command for explicit retry, but conflict requires a fresh decision', async () => {
  const h = cancellationViewHarness()
  const order = { id: 'one', status: 'DRAFT' }
  h.behavior.error = new Error('网络无响应')
  await h.handler(order)
  assert.equal(h.pendingCancellation.value.expectedVersion, 12)
  h.behavior.error = null
  await h.handler(order)
  assert.equal(h.prompts.length, 1)
  assert.equal(h.calls.filter(call => call[0] === 'prepare').length, 1)
  assert.equal(h.calls.filter(call => call[0] === 'confirm').length, 1)
  assert.deepEqual(h.calls.filter(call => call[0] === 'cancel')[0], h.calls.filter(call => call[0] === 'cancel')[1])
  h.behavior.error = new h.ApiError()
  await h.handler(order)
  assert.equal(h.pendingCancellation.value, undefined)
  assert.match(h.messages.at(-1), /刷新订单后重新确认/)
})

test('cancel UI blocks unavailable permission and irreversible visible stages before reads or writes', async () => {
  const h = cancellationViewHarness()
  h.canCancelOrder.value = false
  await h.handler({ id: 'one', status: 'DRAFT' })
  h.canCancelOrder.value = true
  await h.handler({ id: 'one', status: 'LOADED' })
  assert.equal(h.calls.length, 0)
  assert.equal(h.prompts.length, 0)
})

test('both editor entry points capture detail sessions and both save paths pass them', () => {
  const view = readFileSync(new URL('../views/FirstLegOrdersView.vue', import.meta.url), 'utf8')
  assert.equal((view.match(/editingSession\.value = store\.beginDraftEdit\(detailedOrder\)/g) ?? []).length, 2)
  assert.equal((view.match(/store\.saveDraft\(cloneDraft\(form\), tenantStore\.company\.companyName, editingId\.value, editingSession\.value\)/g) ?? []).length, 2)
})