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 { compileScript, parse } from '@vue/compiler-sfc'

function evaluate(source, imports = {}, globals = {}) {
  const compiled = ts.transpileModule(source, {
    compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS }
  }).outputText
  const module = { exports: {} }
  new Function('require', 'module', 'exports', ...Object.keys(globals), compiled)(
    (name) => {
      assert.ok(imports[name], `Unexpected dependency: ${name}`)
      return imports[name]
    },
    module,
    module.exports,
    ...Object.values(globals)
  )
  return module.exports
}

const read = (path) => readFileSync(path, 'utf8')
const carrierTypes = evaluate(read('src/types/api/carrier.ts'))
const carrierConfig = evaluate(read('src/config/constants/carrierTypes.ts'), {
  '@/types/api': carrierTypes
})
const checkedColumns = evaluate(read('src/composables/useCheckedColumns.ts'), { vue })
const components = Object.fromEntries(
  ['index', 'detail'].map((name) => {
    const { descriptor } = parse(read(`src/views/system/carrier-management/${name}.vue`))
    return [
      name,
      { descriptor, script: compileScript(descriptor, { id: `carrier-${name}` }).content }
    ]
  })
)

test('carrier form grid top-aligns items so helper text cannot offset adjacent controls', () => {
  const style = components.index.descriptor.styles.map((block) => block.content).join('\n')
  assert.match(style, /\.carrier-form-grid\s*\{[^}]*align-items:\s*start\s*;/)
})

const carrier = (enabled) => ({
  id: 7,
  carrier_code: 'carrier-test',
  carrier_name: '测试运营商',
  carrier_type: 'CMCC',
  realname_control_enabled: enabled,
  status: 1,
  created_at: '',
  updated_at: ''
})

function harness(userType, responseCarrier = carrier(1)) {
  const writes = []
  const attempts = []
  let list
  const confirmations = []
  const user = vue.reactive({ info: { user_type: userType }, permissions: [], buttons: [] })
  const permission = evaluate(read('src/composables/usePermission.ts'), {
    vue,
    '@/store/modules/user': { useUserStore: () => user }
  })
  const service = {
    getCarriers: async () => ({ code: 0, data: { items: [responseCarrier], total: 1 } }),
    getCarrierDetail: async () => ({ code: 0, data: responseCarrier }),
    createCarrier: async (data) => writes.push({ method: 'create', data: { ...data } }),
    updateCarrier: async (id, data) => {
      attempts.push({ id, data: { ...data } })
      if (
        list?.originalRealnameControlEnabled.value === 0 &&
        data.realname_control_enabled === 1 &&
        !data.realname_control_confirm
      )
        throw new Error('开启实名管控将停机 12 张卡，请确认后重试')
      writes.push({ method: 'update', id, data: { ...data } })
      return { code: 0, data: responseCarrier }
    }
  }
  const runtimeVue = { ...vue, onMounted: () => {} }
  const imports = {
    vue: runtimeVue,
    'vue-router': { useRouter: () => ({ push() {} }), useRoute: () => ({ params: { id: '7' } }) },
    '@vueuse/core': { useWindowSize: () => ({ width: vue.ref(1200) }) },
    '@/api/modules': { CarrierService: service },
    'element-plus': {
      ElMessage: { success() {}, warning() {}, error() {} },
      ElMessageBox: {
        confirm: async (...args) => {
          confirmations.push(args)
          return 'confirm'
        }
      },
      ElTag: {},
      ElSwitch: {},
      ElButton: {}
    },
    '@/composables/useCheckedColumns': checkedColumns,
    '@/composables/useAuth': { useAuth: () => ({ hasAuth: () => true }) },
    '@/composables/usePermission': permission,
    '@/router/routesAlias': {
      RoutesAlias: { CarrierDetail: '/carrier', CarrierManagement: '/carrier' }
    },
    '@/utils/codeGenerator': { generateCarrierCode: () => 'carrier-test' },
    '@/utils/business/format': { formatDateTime: (value) => value },
    '@/config/constants': {
      ...carrierConfig,
      CommonStatus: { ENABLED: 1, DISABLED: 0 },
      getStatusText: (value) => String(value)
    }
  }
  const setup = (name) =>
    evaluate(components[name].script, imports, runtimeVue).default.setup({}, { expose() {} })
  list = setup('index')
  return {
    list,
    attempts,
    detail: setup('detail'),
    writes,
    confirmations,
    messageBox: imports['element-plus'].ElMessageBox,
    service
  }
}

const validForm = {
  validate: async (callback) => callback(true),
  resetFields() {},
  clearValidate() {}
}

for (const userType of [1, 2, '1', '2', 3, 4, 0, undefined]) {
  const allowed = [1, 2].includes(Number(userType))
  test(`user_type=${userType}: list visibility, detail visibility and create/update field access`, async () => {
    const { list, detail, writes } = harness(userType)
    assert.equal(list.canConfigureRealnameControl.value, allowed)
    assert.equal(detail.canConfigureRealnameControl.value, allowed)
    assert.equal(
      list.columnOptions.some((column) => column.prop === 'realname_control_enabled'),
      allowed
    )
    assert.equal(
      list.columns.value.some((column) => column.prop === 'realname_control_enabled'),
      allowed
    )
    assert.equal(
      list.columnChecks.value.some((column) => column.prop === 'realname_control_enabled'),
      allowed
    )

    await list.getTableData()
    await detail.loadCarrier()
    assert.equal(list.carrierList.value[0].realname_control_enabled, 1)
    assert.equal(detail.carrier.value.realname_control_enabled, 1)

    list.showDialog('add')
    assert.equal(list.form.realname_control_enabled, 0)
    list.form.realname_control_enabled = 1
    await list.handleSubmit(validForm)
    list.showDialog('edit', carrier(1))
    assert.equal(list.form.realname_control_enabled, 1)
    list.form.realname_control_enabled = 0
    await list.handleSubmit(validForm)

    assert.equal(writes.length, 2)
    assert.equal(writes[0].method, 'create')
    assert.equal(writes[1].method, 'update')
    assert.equal(writes[1].id, 7)
    for (const [index, write] of writes.entries()) {
      assert.equal(Object.hasOwn(write.data, 'realname_control_enabled'), allowed)
      if (allowed) assert.equal(write.data.realname_control_enabled, index === 0 ? 1 : 0)
    }
  })
}

test('labels preserve numeric zero and handle missing fields without inventing a state', () => {
  const { getCarrierRealnameControlLabel: label } = carrierConfig
  assert.equal(label(0), '不管控')
  assert.equal(label(1), '管控')
  assert.equal(label(undefined), '-')
  assert.equal(label(null), '-')
  const { list } = harness(1)
  const column = list.columns.value.find((item) => item.prop === 'realname_control_enabled')
  assert.equal(column.formatter(carrier(0)), '不管控')
  assert.equal(column.formatter(carrier(1)), '管控')
  assert.equal(column.formatter(carrier(undefined)), '-')
})

test('editing then creating resets control state; default creation sends numeric zero', async () => {
  const { list, writes } = harness(2)
  list.showDialog('edit', carrier(1))
  list.showDialog('add')
  assert.equal(list.form.realname_control_enabled, 0)
  await list.handleSubmit(validForm)
  assert.equal(writes[0].data.realname_control_enabled, 0)
  list.showDialog('edit', carrier(0))
  assert.equal(list.form.realname_control_enabled, 0)
  list.showDialog('edit', carrier(undefined))
  assert.equal(list.form.realname_control_enabled, 0)
})

for (const userType of [1, 2]) {
  test(`user_type=${userType}: initial PUT obtains actual impact before confirmed retry`, async () => {
    const { list, writes, confirmations, messageBox, attempts } = harness(userType)
    list.showDialog('edit', carrier(0))
    list.form.realname_control_enabled = 1
    let confirm
    messageBox.confirm = (...args) => {
      confirmations.push(args)
      return new Promise((resolve) => {
        confirm = resolve
      })
    }
    const pending = list.handleSubmit(validForm)
    await new Promise((resolve) => setImmediate(resolve))
    assert.equal(confirmations.length, 1)
    assert.equal(confirmations[0][0], '开启实名管控将停机 12 张卡，请确认后重试')
    assert.equal(attempts.length, 1)
    assert.equal(attempts[0].data.realname_control_confirm, undefined)
    assert.deepEqual(writes, [])
    assert.equal(list.submitLoading.value, true)
    await list.handleSubmit(validForm)
    assert.equal(confirmations.length, 1)
    confirm('confirm')
    await pending
    assert.equal(writes.length, 1)
    assert.equal(writes[0].method, 'update')
    assert.equal(writes[0].data.realname_control_enabled, 1)
    assert.equal(writes[0].data.realname_control_confirm, true)
    assert.equal(list.submitLoading.value, false)
  })
}

for (const reason of ['cancel', 'close']) {
  test(`${reason} of realname confirmation does not submit; retry requires a fresh confirmation`, async () => {
    const { list, writes, messageBox } = harness(1)
    list.showDialog('edit', carrier(0))
    list.form.realname_control_enabled = 1
    let prompts = 0
    messageBox.confirm = async () => {
      prompts += 1
      throw reason
    }
    await list.handleSubmit(validForm)
    assert.deepEqual(writes, [])
    assert.equal(list.dialogVisible.value, true)
    assert.equal(list.submitLoading.value, false)
    assert.equal(list.form.realname_control_enabled, 1)
    messageBox.confirm = async () => {
      prompts += 1
      return 'confirm'
    }
    await list.handleSubmit(validForm)
    assert.equal(prompts, 2)
    assert.equal(writes[0].data.realname_control_confirm, true)
  })
}

test('unchanged, disabled, new, and unauthorized carriers never send confirmation automatically', async () => {
  for (const [userType, mode, original, selected] of [
    [1, 'edit', 1, 1],
    [1, 'edit', 0, 0],
    [2, 'edit', 1, 0],
    [1, 'add', 0, 1],
    [3, 'edit', 0, 1],
    [4, 'edit', 0, 1]
  ]) {
    const { list, writes, confirmations } = harness(userType)
    list.showDialog(mode, carrier(original))
    list.form.realname_control_enabled = selected
    await list.handleSubmit(validForm)
    assert.equal(confirmations.length, 0)
    assert.equal(writes.length, 1)
    assert.equal(Object.hasOwn(writes[0].data, 'realname_control_confirm'), false)
  }
})

test('opening another carrier resets the original control state after a cancelled enabling', async () => {
  const { list, writes, messageBox } = harness(2)
  list.showDialog('edit', carrier(0))
  list.form.realname_control_enabled = 1
  messageBox.confirm = async () => {
    throw 'cancel'
  }
  await list.handleSubmit(validForm)
  list.showDialog('edit', { ...carrier(1), id: 8 })
  await list.handleSubmit(validForm)
  assert.equal(writes[0].id, 8)
  assert.equal(Object.hasOwn(writes[0].data, 'realname_control_confirm'), false)
})

test('an unrelated PUT error never triggers confirmation or automatic retry', async (t) => {
  const { list, writes, confirmations, service } = harness(2)
  t.mock.method(console, 'error', () => {})
  list.showDialog('edit', carrier(0))
  list.form.realname_control_enabled = 1
  const updateCarrier = service.updateCarrier
  service.updateCarrier = async () => {
    throw new Error('PUT failed')
  }
  await list.handleSubmit(validForm)
  assert.equal(confirmations.length, 0)
  assert.deepEqual(writes, [])
  assert.equal(list.dialogVisible.value, true)
  assert.equal(list.submitLoading.value, false)
  service.updateCarrier = updateCarrier
  await list.handleSubmit(validForm)
  assert.equal(confirmations.length, 1)
  assert.equal(writes[0].data.realname_control_confirm, true)
})

function findElement(node, predicate) {
  if (node.type === 1 && predicate(node)) return node
  for (const child of node.children || []) {
    const match = findElement(child, predicate)
    if (match) return match
  }
}

test('form and detail guard the field, and the switch uses numeric 1/0', () => {
  for (const [name, tag] of [
    ['index', 'ElFormItem'],
    ['detail', 'ElDescriptionsItem']
  ]) {
    const field = findElement(
      components[name].descriptor.template.ast,
      (node) =>
        node.tag === tag &&
        node.props.some((prop) => prop.name === 'label' && prop.value?.content === '通道实名管控')
    )
    assert.ok(field)
    assert.equal(
      field.props.find((prop) => prop.type === 7 && prop.name === 'if')?.exp?.content,
      'canConfigureRealnameControl'
    )
    if (name === 'index') {
      const toggle = findElement(field, (node) => node.tag === 'ElSwitch')
      for (const [arg, value] of [
        ['active-value', '1'],
        ['inactive-value', '0']
      ]) {
        assert.equal(
          toggle.props.find((prop) => prop.type === 7 && prop.arg?.content === arg)?.exp?.content,
          value
        )
      }
    }
  }
})

test('carrier endpoints preserve the field in list/detail responses and create/update requests', async () => {
  const calls = []
  class BaseService {
    static getPage(url) {
      calls.push({ method: 'GET', url })
      return Promise.resolve({ code: 0, data: { items: [carrier(1)] } })
    }
    static getOne(url) {
      calls.push({ method: 'GET', url })
      return Promise.resolve({ code: 0, data: carrier(0) })
    }
    static create(url, data) {
      calls.push({ method: 'POST', url, data })
      return Promise.resolve({ code: 0, data })
    }
    static update(url, data) {
      calls.push({ method: 'PUT', url, data })
      return Promise.resolve({ code: 0, data })
    }
    static put(url, data) {
      return this.update(url, data)
    }
  }
  const { CarrierService } = evaluate(read('src/api/modules/carrier.ts'), {
    '../BaseService': { BaseService }
  })
  assert.equal((await CarrierService.getCarriers()).data.items[0].realname_control_enabled, 1)
  assert.equal((await CarrierService.getCarrierDetail(7)).data.realname_control_enabled, 0)
  await CarrierService.createCarrier({ ...carrier(1) })
  await CarrierService.updateCarrier(7, {
    realname_control_enabled: 1,
    realname_control_confirm: true
  })
  assert.deepEqual(calls, [
    { method: 'GET', url: '/api/admin/carriers' },
    { method: 'GET', url: '/api/admin/carriers/7' },
    { method: 'POST', url: '/api/admin/carriers', data: carrier(1) },
    {
      method: 'PUT',
      url: '/api/admin/carriers/7',
      data: { realname_control_enabled: 1, realname_control_confirm: true }
    }
  ])
})