import test from 'node:test'
import assert from 'node:assert/strict'
import { readFileSync } from 'node:fs'
import ts from 'typescript'
import * as vue from 'vue'
import { parse, compileScript, compileTemplate } from '@vue/compiler-sfc'

const read = (path) => readFileSync(path, 'utf8')
function evaluate(source, imports = {}, globals = {}) {
  const code = ts.transpileModule(source, {
    compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS }
  }).outputText
  const m = { exports: {} }
  new Function('require', 'module', 'exports', ...Object.keys(globals), code)(
    (name) => {
      if (name.endsWith('.vue')) return { default: {} }
      assert.ok(imports[name], `Unexpected dependency: ${name}`)
      return imports[name]
    },
    m,
    m.exports,
    ...Object.values(globals)
  )
  return m.exports
}
const helpers = evaluate(read('src/utils/business/packageSilence.ts'))
const constants = evaluate(read('src/config/constants/packageSilence.ts'))
const format = evaluate(read('src/utils/business/format.ts'))
const gateway = evaluate(read('src/utils/business/gateway.ts'), { './format': format })
const polling = evaluate(read('src/utils/business/pollingScheduler.ts'), { './gateway': gateway })
const exportConfig = evaluate(read('src/config/constants/exportTask.ts'))

test('silence business errors never count as successful orders, package saves or refunds', () => {
  for (const code of [1260, 1261, 1262, 1268, 1275])
    assert.throws(() => helpers.assertSilenceResponse({ code, data: null }), {
      message: helpers.SILENCE_ERROR_MESSAGES[code]
    })
  assert.throws(
    () => helpers.assertSilenceResponse({ code: 1266, msg: 'min_days=30,max_days=90' }),
    { message: 'min_days=30,max_days=90' }
  )
  const response = { code: 0, data: { warnings: ['saved'] } }
  assert.equal(helpers.assertSilenceResponse(response), response)
  for (const path of [
    'src/views/order-management/order-list/index.vue',
    'src/views/package-management/package-list/index.vue',
    'src/views/asset-management/asset-information/components/dialogs/PackageRechargeDialog.vue',
    'src/components/business/CreateRefundDialog.vue'
  ])
    assert.ok(read(path).includes('assertSilenceResponse'))
})

function setup(path, { type = 2, props = {}, permissions = [], overrides = {} } = {}) {
  const calls = [],
    unmount = []
  const user = vue.reactive({
    info: { id: 1, user_type: type },
    get isSuperAdmin() {
      return Number(this.info.user_type) === 1
    },
    get getUserInfo() {
      return this.info
    }
  })
  const services = new Proxy(
    {},
    {
      get:
        (_, name) =>
        async (...args) => {
          calls.push({ name, args })
          return overrides[name]
            ? overrides[name](...args)
            : { code: 0, data: { items: [], total: 0 } }
        }
    }
  )
  const runtime = {
    ...vue,
    onMounted() {},
    onActivated() {},
    onDeactivated() {},
    onBeforeUnmount: (fn) => unmount.push(fn)
  }
  const store = { useUserStore: () => user }
  const auth = {
    useAuth: () => ({ hasAuth: (code) => user.isSuperAdmin || permissions.includes(code) })
  }
  const scheduler = evaluate(read('src/composables/useSchedulerRequest.ts'), {
    vue: runtime,
    '@/store/modules/user': store,
    '@/utils/business/gateway': gateway,
    '@/utils/business/pollingScheduler': polling
  })
  const checked = evaluate(read('src/composables/useCheckedColumns.ts'), { vue: runtime })
  const imports = {
    vue: runtime,
    pinia: { storeToRefs: vue.toRefs },
    'vue-router': { useRouter: () => ({ push() {}, back() {} }) },
    'element-plus': {
      ElMessage: { success() {}, warning() {}, error() {} },
      ElMessageBox: { confirm: async () => {} },
      ElTag: {}
    },
    '@/api/modules': {
      OrderService: services,
      ExportTaskService: services,
      CardService: services,
      DeviceService: services,
      PackageManageService: services,
      ShopService: services,
      AssetService: services
    },
    '@/api/modules/packageSilence': { PackageSilenceService: services },
    '@/store/modules/user': store,
    '@/composables/useAuth': auth,
    '@/composables/useCheckedColumns': checked,
    '@/composables/useSchedulerRequest': scheduler,
    '@/utils/business/format': format,
    '@/utils/business/packageSilence': helpers,
    '@/utils/business/pollingScheduler': polling,
    '@/utils/business/gateway': gateway,
    '@/utils/business/orderPayment': {},
    '@/utils/business': { hasVoucherKeys: (v) => !!v?.length, toVoucherKeyList: (v) => v },
    '@/router/routesAlias': { RoutesAlias: {} },
    '@/config/constants/audit': { AUDIT_PERMISSIONS: {} },
    '@/utils/business/auditNavigation': {},
    '@/components/business/audit/investigationController': {},
    '@/config/constants/bulkPurchase': { BULK_PURCHASE_PERMISSIONS: {} },
    '@/config/constants/packageSilence': constants,
    '@/config/constants': exportConfig,
    '@/config/constants/exportTask': exportConfig
  }
  const { descriptor } = parse(read(path)),
    scope = vue.effectScope()
  const component = evaluate(
    compileScript(descriptor, { id: 'silence-integration' }).content,
    imports,
    runtime
  ).default
  const state = scope.run(() => component.setup(props, { expose() {}, emit() {} }))
  return {
    state,
    calls,
    user,
    dispose() {
      unmount.forEach((fn) => fn())
      scope.stop()
    }
  }
}

test('order category role matrix and export scene boundaries match the document', () => {
  for (const type of [1, 2, 3, 4, 0, undefined])
    for (const category of ['all', 'platform', 'agent', 'online']) {
      const allowed = (category === 'online' ? [1, 2] : [1, 2, 3]).includes(type)
      assert.equal(helpers.canAccessOrderCategory(type, category), allowed)
      assert.equal(
        exportConfig.canAccessExportTaskScene(
          constants.ORDER_CATEGORY_CONFIG[category].scene,
          type
        ),
        allowed
      )
    }
  assert.equal(helpers.canEditRestrictedAsset(4), false)
  assert.equal(helpers.canEditRestrictedAsset(3), true)
})
test('three category endpoints preserve query and shared legacy detail contract', async () => {
  const calls = []
  class BaseService {}
  for (const name of ['get', 'getOne'])
    BaseService[name] = (url, params) => {
      calls.push({ url, params })
      return Promise.resolve({ code: 0 })
    }
  const { OrderService: S } = evaluate(read('src/api/modules/order.ts'), {
    '../BaseService': { BaseService }
  })
  const query = { page: 1, page_size: 20, is_expired: false, seller_shop_id: 8 }
  await S.getPlatformOrders(query)
  await S.getAgentOrders(query)
  await S.getOnlineOrders(query)
  await S.getOrders(query)
  await S.getOrderById(1)
  assert.deepEqual(
    calls.map((x) => x.url),
    [
      '/api/admin/orders/platform',
      '/api/admin/orders/agent',
      '/api/admin/orders/online',
      '/api/admin/orders',
      '/api/admin/orders/1'
    ]
  )
  for (const call of calls.slice(0, 4)) {
    assert.deepEqual(call.params, query)
    assert.equal('category' in call.params, false)
  }
})
for (const [category, method] of [
  ['platform', 'getPlatformOrders'],
  ['agent', 'getAgentOrders'],
  ['online', 'getOnlineOrders'],
  ['all', 'getOrders']
])
  test(`order view ${category} uses exact service and scene, blocks disallowed identities`, async () => {
    for (const type of [1, 2, 3, 4]) {
      const h = setup('src/views/order-management/order-list/index.vue', {
        type,
        props: { category }
      })
      h.state.searchForm.is_expired = 0
      await h.state.getTableData()
      const allowed = helpers.canAccessOrderCategory(type, category)
      assert.equal(h.calls.length, allowed ? 1 : 0)
      if (allowed) {
        assert.equal(h.calls[0].name, method)
        assert.equal(h.calls[0].args[0].is_expired, false)
        assert.equal('category' in h.calls[0].args[0], false)
      }
      assert.equal(
        h.state.categoryConfig.value.scene,
        constants.ORDER_CATEGORY_CONFIG[category].scene
      )
      h.dispose()
    }
  })
test('package defaults enforce 1..90, nullable purchase defaults, addon omission and immutable activation base', () => {
  for (const days of [0, 91, 1.5, NaN])
    assert.throws(() =>
      helpers.packageSilenceFields({
        package_type: 'formal',
        expiry_base: 'from_activation',
        silence_period_days: days
      })
    )
  for (const days of [1, 30, 90])
    assert.equal(
      helpers.packageSilenceFields({
        package_type: 'formal',
        expiry_base: 'from_activation',
        silence_period_days: days
      }).silence_period_days,
      days
    )
  assert.throws(() =>
    helpers.packageSilenceFields({
      package_type: 'formal',
      expiry_base: 'from_activation',
      silence_period_days: null
    })
  )
  assert.equal(
    helpers.packageSilenceFields({
      package_type: 'formal',
      expiry_base: 'from_purchase',
      silence_period_days: null,
      silence_extension_enabled: false
    }).silence_extension_enabled,
    false
  )
  assert.deepEqual(
    helpers.packageSilenceFields({ package_type: 'addon', silence_period_days: 999 }),
    {}
  )
  assert.throws(() =>
    helpers.packageSilenceFields(
      { package_type: 'formal', expiry_base: 'from_purchase' },
      'from_activation'
    )
  )
})

test('allocation overrides enforce source defaults before single, batch and series writes', async () => {
  const packageData = {
    package_type: 'formal',
    expiry_base: 'from_purchase',
    silence_period_days: null
  }
  let reads = 0
  const validation = evaluate(read('src/api/modules/packageSilenceValidation.ts'), {
    './packageManage': {
      PackageManageService: {
        getPackageDetail: async () => {
          reads++
          return { code: 0, data: { ...packageData } }
        }
      }
    },
    '@/utils/business/packageSilence': helpers
  })
  const writes = []
  class BaseService {}
  for (const method of ['post', 'put', 'patch', 'create'])
    BaseService[method] = (url, data) => {
      writes.push({ url, data })
      return Promise.resolve({ code: 0, data })
    }
  const imports = { '../BaseService': { BaseService }, './packageSilenceValidation': validation }
  const S = evaluate(
    read('src/api/modules/shopPackageAllocation.ts'),
    imports
  ).ShopPackageAllocationService
  const G = evaluate(read('src/api/modules/shopSeriesGrant.ts'), imports).ShopSeriesGrantService
  const calls = [
    () => S.createShopPackageAllocation({ package_id: 8, expiry_base_override: 'from_activation' }),
    () =>
      S.createShopPackageBatchAllocations({
        package_ids: [8, 9],
        expiry_base_override: 'from_activation'
      }),
    () =>
      S.updateShopPackageAllocationExpiryBase(1, { expiry_base_override: 'from_activation' }, 8),
    () =>
      G.createShopSeriesGrant({
        packages: [{ package_id: 8 }],
        expiry_base_override: 'from_activation'
      }),
    () =>
      G.manageGrantPackages(1, {
        packages: [{ package_id: 8 }],
        expiry_base_override: 'from_activation'
      })
  ]
  for (const call of calls) await assert.rejects(call, /先配置默认沉默期/)
  assert.equal(writes.length, 0)
  packageData.silence_period_days = 30
  for (const call of calls) await call()
  assert.equal(writes.length, 5)
  packageData.expiry_base = 'from_activation'
  await assert.rejects(
    () => S.updateShopPackageAllocationExpiryBase(1, { expiry_base_override: 'from_purchase' }, 8),
    /不允许覆盖/
  )
  const previousReads = reads
  await S.createShopPackageAllocation({ package_id: 8, expiry_base_override: null })
  await G.manageGrantPackages(1, {
    packages: [{ package_id: 8, remove: true }],
    expiry_base_override: 'from_purchase'
  })
  assert.equal(reads, previousReads)
})
test('purchase overrides do not impose a 90-day maximum and never leak unauthorized fields', () => {
  assert.deepEqual(helpers.silencePurchaseFields(false, 91, 'why'), {})
  assert.deepEqual(helpers.silencePurchaseFields(true, null, 'why'), {})
  assert.deepEqual(helpers.silencePurchaseFields(true, 365, ' why '), {
    silence_period_days: 365,
    silence_reason: 'why'
  })
  for (const days of [0, -1, 1.5, NaN])
    assert.throws(() => helpers.silencePurchaseFields(true, days, 'why'))
  assert.throws(() => helpers.silencePurchaseFields(true, 30, ' '))
})

test('purchase override remains null until explicitly enabled and disabling clears the reason', async () => {
  const path = 'src/components/business/package-silence/SilencePurchaseFields.vue'
  const { descriptor } = parse(read(path))
  const definition = evaluate(compileScript(descriptor, { id: 'optional-override' }).content, {
    vue
  }).default
  let state
  const days = vue.ref(null),
    reason = vue.ref('')
  const component = {
    ...definition,
    setup(props, context) {
      state = definition.setup(props, context)
      return () => null
    }
  }
  const renderer = vue.createRenderer({
    createComment: () => ({}),
    insert() {},
    remove() {},
    parentNode: () => null,
    nextSibling: () => null
  })
  const app = renderer.createApp({
    render: () =>
      vue.h(component, {
        days: days.value,
        reason: reason.value,
        'onUpdate:days': (v) => (days.value = v),
        'onUpdate:reason': (v) => (reason.value = v)
      })
  })
  app.mount({})
  assert.equal(state.overrideEnabled.value, false)
  assert.equal(days.value, null)
  state.overrideEnabled.value = true
  await vue.nextTick()
  assert.equal(days.value, 1)
  days.value = 365
  reason.value = 'why'
  await vue.nextTick()
  assert.equal(state.overrideEnabled.value, true)
  state.overrideEnabled.value = false
  await vue.nextTick()
  assert.equal(days.value, null)
  assert.equal(reason.value, '')
  assert.match(descriptor.template.content, /<ElInputNumber\s+v-if="overrideEnabled"/)
  app.unmount()
})
test('first purchase range is shared RFC3339 and rejects invalid or reversed input', () => {
  const range = ['2026-10-01T00:00:00+08:00', '2026-10-28T23:59:59+08:00']
  assert.deepEqual(helpers.firstPurchaseRange(range), {
    first_purchase_start: '2026-09-30T16:00:00Z',
    first_purchase_end: '2026-10-28T15:59:59Z'
  })
  assert.deepEqual(helpers.firstPurchaseRange([]), {})
  for (const value of [['bad', 'date'], range.toReversed(), [range[0]]])
    assert.throws(() => helpers.firstPurchaseRange(value))
})

test('new order exports keep query.filters as an object, preserving zero/false and legacy serialization', () => {
  for (const scene of ['order_platform', 'order_agent', 'order_online', 'order']) {
    const filters = {
      payment_status: 2,
      is_expired: false,
      seller_shop_id: 0,
      start_time: '2026-10-01T00:00:00+08:00'
    }
    const h = setup('src/components/business/ExportTaskCreateDialog.vue', {
      props: { scene, query: { filters }, modelValue: true, defaultFormat: 'xlsx' }
    })
    const query = h.state.getNormalizedQuery()
    assert.deepEqual(query.filters, scene === 'order' ? JSON.stringify(filters) : filters)
    h.dispose()
  }
})
test('silence switch uses dedicated endpoints and boolean state, never generic system config', async () => {
  const calls = []
  class BaseService {}
  for (const method of ['get', 'put'])
    BaseService[method] = (url, data) => {
      calls.push({ method, url, data })
      return Promise.resolve({ code: 0 })
    }
  const { PackageSilenceService: S } = evaluate(read('src/api/modules/packageSilence.ts'), {
    '../BaseService': { BaseService }
  })
  await S.getSwitch()
  await S.setSwitch(false)
  assert.deepEqual(calls, [
    { method: 'get', url: '/api/admin/package-silence/switch', data: undefined },
    { method: 'put', url: '/api/admin/package-silence/switch', data: { enabled: false } }
  ])
})
test('silence switch refuses ordinary accounts and exposes failed prechecks from business errors', async () => {
  for (const type of [2, 3, 4]) {
    const h = setup('src/views/settings/package-silence-switch/index.vue', { type })
    await h.state.load()
    await h.state.toggle()
    assert.equal(h.calls.length, 0)
    h.dispose()
  }
  const failed = [{ code: 'unconfigured', name: 'missing config', passed: false, count: 3 }]
  const h = setup('src/views/settings/package-silence-switch/index.vue', {
    type: 1,
    overrides: {
      getSwitch: () => ({ code: 0, data: { enabled: false, precheck: failed } }),
      setSwitch: () => ({ code: 1275, msg: 'check failed', data: { failed_items: failed } })
    }
  })
  await h.state.load()
  await h.state.toggle()
  assert.equal(h.state.data.value.enabled, false)
  assert.deepEqual(h.state.failed.value, failed)
  assert.equal(h.state.error.value, 'check failed')
  await h.state.load()
  assert.deepEqual(h.state.failed.value, [])
  assert.equal(h.state.error.value, '')
  h.dispose()
})
test('all new and changed business templates compile, including conditional root order view', () => {
  const paths = [
    'src/views/order-management/order-list/index.vue',
    'src/views/package-management/package-list/index.vue',
    'src/views/settings/package-silence-switch/index.vue',
    'src/views/asset-management/asset-information/components/PackageListCard.vue',
    'src/views/asset-management/asset-information/components/CurrentPackageCard.vue',
    'src/components/business/package-silence/SilenceSummary.vue',
    'src/components/business/package-silence/SilencePurchaseFields.vue',
    'src/components/business/package-silence/PackageSilenceFields.vue'
  ]
  for (const path of paths) {
    const { descriptor, errors } = parse(read(path))
    assert.deepEqual(errors, [], path)
    const result = compileTemplate({
      source: descriptor.template.content,
      filename: path,
      id: path,
      compilerOptions: { expressionPlugins: ['typescript'] }
    })
    assert.deepEqual(result.errors, [], path)
  }
})
test('198 base regressions remain compatible while metadata and zero refunds follow the new contract', () => {
  assert.equal(Object.keys(helpers.SILENCE_ERROR_MESSAGES).length, 16)
  for (const type of ['override', 'extend', 'extend_batch', 'offline', 'exception', 'policy'])
    assert.ok(
      Object.values(constants.PACKAGE_SILENCE_PERMISSIONS).includes(`package_silence:${type}`)
    )
  assert.match(read('src/types/api/wecom.ts'), /package_silence_approval/)
  assert.match(read('src/views/settings/wecom/scenes/index.vue'), /沉默期审批/)
  assert.match(read('src/views/finance/refund/index.vue'), /requested_refund_amount"\s+:min="0"/)
  assert.match(
    read('src/views/finance/refund/index.vue'),
    /row.requested_refund_amount == null \? undefined : fenToYuan/
  )
  for (const path of [
    'src/views/asset-management/iot-card-management/index.vue',
    'src/views/asset-management/device-list/index.vue'
  ])
    assert.ok(read(path).includes('firstPurchaseRange'))
})