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 }
    ]
  })
)

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 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) => writes.push({ method: 'update', id, data: { ...data } })
  }
  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() {} },
      ElMessageBox: {},
      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() {} })
  return { list: setup('index'), detail: setup('detail'), writes }
}

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)
})

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 })
    }
  }
  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: 0 })
  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: 0 } }
  ])
})