// 全站页面的假数据逻辑和 SSR 检查，不登录账号、不请求后端、不操作家具。
import assert from 'node:assert/strict'
import { after, test } from 'node:test'
import fs from 'node:fs'
import path from 'node:path'
import vm from 'node:vm'
import { fileURLToPath } from 'node:url'
import { parse, compileScript } from 'vue/compiler-sfc'
import { createSSRApp, h, isRef } from 'vue'
import { renderToString } from 'vue/server-renderer'
import { createMemoryHistory, createRouter } from 'vue-router'
import { createServer } from 'vite'
import vuePlugin from '@vitejs/plugin-vue'
import ts from 'typescript'

const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../src')
const deferred = () => {
  let resolve, reject
  const promise = new Promise((yes, no) => { resolve = yes; reject = no })
  return { promise, resolve, reject }
}
const dashboardRecord = (name = '演示用户') => ({ user: { id: 1, displayName: name, phone: '13800000000' },
  profile: {}, hasCompletedAssessment: false, tcmResult: { hasCompleted: true, constitutionName: '平和质' } })
const deviceStatus = () => ({ connected: true, sceneDevices: { available: 3 } })

function environment(overrides = {}) {
  const disposed = [], toasts = [], navigations = [], tokenWrites = [], mounted = []
  const router = { replace: location => navigations.push(location), push: location => navigations.push(location) }
  const vue = { defineComponent: options => options, ref: value => ({ value }), reactive: value => value,
    computed: getter => ({ get value() { return getter() } }),
    onMounted: handler => mounted.push(handler), onUnmounted: handler => disposed.push(handler) }
  const healthApi = { dashboard: async () => dashboardRecord(), homeAssistantStatus: async () => deviceStatus(),
    getAssessment: async () => ({ hasCompletedAssessment: false, basicInfo: {}, answers: {} }),
    login: async () => ({ accessToken: 'test-token', refreshToken: 'test-refresh' }),
    register: async () => ({ accessToken: 'test-token', refreshToken: 'test-refresh' }), ...overrides }
  let sceneOptions
  const mocks = {
    vue, 'vue-router': { useRouter: () => router },
    vant: { Button: {}, Field: {}, Form: {}, showToast: value => toasts.push(value), showConfirmDialog: async () => {} },
  }
  const cache = new Map()
  function load(relative) {
    const file = path.resolve(root, /\.(vue|ts)$/.test(relative) ? relative : relative + '.ts')
    const normalized = file.replaceAll('\\', '/')
    if (normalized.endsWith('services/health.ts')) return { healthApi }
    if (normalized.endsWith('services/auth.ts')) return { saveTokens: (...args) => tokenWrites.push(args), clearTokens: () => tokenWrites.push('clear') }
    if (file.endsWith('AppTabBar.vue')) return { default: {} }
    if (file.endsWith('useDeviceScenes.ts')) return { useDeviceScenes: options => {
      sceneOptions = options; return { sceneRunning: vue.ref(), executeScene() {} }
    } }
    if (cache.has(file)) return cache.get(file).exports
    const raw = fs.readFileSync(file, 'utf8')
    const source = file.endsWith('.vue') ? compileScript(parse(raw).descriptor, { id: 'test-page' }).content : raw
    const output = ts.transpileModule(source, { compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS } }).outputText
    const module = { exports: {} }; cache.set(file, module)
    vm.runInNewContext(output, { module, exports: module.exports,
      require: name => mocks[name] ?? load(path.relative(root, path.resolve(path.dirname(file), name))), Date, Intl, Error,
    }, { filename: file })
    return module.exports
  }
  return { page: name => load(`views/${name}.vue`).default.setup({}, { expose() {} }), healthApi, toasts, navigations, tokenWrites,
    feedback: (...args) => sceneOptions.feedback(...args), dispose: () => disposed.forEach(handler => handler()) }
}

test('dashboard failure is retryable instead of looking like an empty unassessed account', async () => {
  const env = environment({ dashboard: async () => { throw new Error('读取失败') } })
  const page = env.page('DashboardView'); await page.load()
  assert.equal(page.loadError.value, '读取失败'); assert.equal(page.loading.value, false)
  assert.equal(page.dashboard.value, undefined)
  env.healthApi.dashboard = async () => dashboardRecord(); await page.load()
  assert.equal(page.loadError.value, ''); assert.equal(page.dashboard.value.user.displayName, '演示用户')
})

test('dashboard refuses outdated reads and late feedback after leaving', async () => {
  const old = deferred(), latest = deferred(); let reads = 0
  const env = environment({ dashboard: () => (++reads === 1 ? old : latest).promise })
  const page = env.page('DashboardView'), a = page.load(), b = page.load()
  latest.resolve(dashboardRecord('新数据')); await b
  old.resolve(dashboardRecord('旧数据')); await a
  assert.equal(page.dashboard.value.user.displayName, '新数据')
  env.dispose(); env.feedback('success', '迟到反馈')
  assert.equal(page.actionFeedback.value, undefined)
})

test('profile failed assessment reads do not silently claim an unassessed profile; retry works', async () => {
  const env = environment({ getAssessment: async () => { throw new Error('评估读取失败') } })
  const page = env.page('ProfileView'); await page.loadData()
  assert.equal(page.loadError.value, '评估读取失败'); assert.equal(page.dashboard.value, undefined)
  env.healthApi.getAssessment = async () => ({ hasCompletedAssessment: false, basicInfo: {}, answers: {} })
  await page.loadData(); assert.equal(page.loadError.value, '')
  page.dashboard.value.profile.birthday = 'not-a-date'; assert.equal(page.ageDisplay.value, undefined)
  page.dashboard.value.bmi = NaN; assert.equal(page.bmiDisplay.value, null)
})

test('profile displays age from backend timestamps in either profile or assessment', async () => {
  const birthday = '2006-01-01 00:00:00'
  const env = environment({ dashboard: async () => ({ ...dashboardRecord(), profile: { birthday } }) })
  const page = env.page('ProfileView'); await page.loadData()
  const expectedAge = new Date().getFullYear() - 2006
  assert.equal(page.ageDisplay.value, expectedAge)
  page.dashboard.value.profile.birthday = undefined
  page.assessment.value.basicInfo.birthday = birthday
  assert.equal(page.ageDisplay.value, expectedAge)
  page.assessment.value.basicInfo.birthday = undefined
  assert.equal(page.ageDisplay.value, undefined)
})

test('profile does not update after leaving during a read', async () => {
  const read = deferred(), env = environment({ dashboard: () => read.promise })
  const page = env.page('ProfileView'), pending = page.loadData()
  env.dispose(); read.resolve(dashboardRecord()); await pending
  assert.equal(page.dashboard.value, undefined); assert.equal(env.toasts.length, 0)
})

test('auth blocks duplicate submission and uses the submitted mode even if mode later changes', async () => {
  const pending = deferred(); let logins = 0, registers = 0
  const env = environment({ login: () => { logins++; return pending.promise }, register: async () => { registers++ } })
  const page = env.page('AuthView'); Object.assign(page.form, { phone: '13800000000', password: 'oldpwd' })
  const request = page.submit(); page.mode.value = 'register'; await page.submit()
  assert.equal(logins, 1); assert.equal(registers, 0)
  pending.resolve({ accessToken: 'test-token', refreshToken: 'test-refresh' }); await request
  assert.deepEqual(env.navigations, ['/dashboard']); assert.equal(page.loading.value, false)
})

test('registration validates its minimum password and still opens four diagnoses first', async () => {
  let writes = 0
  const env = environment({ register: async () => { writes++; return { accessToken: 'test-token', refreshToken: 'test-refresh' } } })
  const page = env.page('AuthView'); page.mode.value = 'register'
  Object.assign(page.form, { phone: '13800000000', password: 'short', displayName: '演示用户' })
  await page.submit(); assert.equal(writes, 0)
  page.form.password = 'demo-password'; await page.submit()
  assert.equal(writes, 1); assert.deepEqual(env.navigations, ['/tcm-assessment'])
})

test('late login response cannot write a token or navigate after leaving the auth page', async () => {
  const pending = deferred(), env = environment({ login: () => pending.promise })
  const page = env.page('AuthView'); Object.assign(page.form, { phone: '13800000000', password: 'demo-password' })
  const request = page.submit(); env.dispose()
  pending.resolve({ accessToken: 'test-token', refreshToken: 'test-refresh' }); await request
  assert.equal(env.tokenWrites.length, 0); assert.equal(env.navigations.length, 0); assert.equal(env.toasts.length, 0)
})

const server = await createServer({ configFile: false, root: path.dirname(root), plugins: [vuePlugin()], appType: 'custom',
  server: { middlewareMode: true, hmr: false }, optimizeDeps: { noDiscovery: true, include: [] } })
after(() => server.close())
async function render(name, values = {}, routePath = '/dashboard') {
  const { default: view } = await server.ssrLoadModule(`/src/views/${name}.vue`)
  const component = { ...view, setup(props, context) {
    const state = view.setup(props, context)
    for (const [key, value] of Object.entries(values)) { assert.ok(isRef(state[key]), key); state[key].value = value }
    return state
  } }
  const router = createRouter({ history: createMemoryHistory(), routes: [{ path: '/:pathMatch(.*)*', component }] })
  await router.push(routePath); await router.isReady()
  const app = createSSRApp({ render: () => h(component) }); app.use(router)
  return renderToString(app)
}

test('home renders a prominent scene, collapsed presets, a real profile entry and the required navigation order', async () => {
  const record = { ...dashboardRecord(), bmi: 31.1, sceneConfig: { targetHumidity: 55, fanLevel: '1挡', lightBrightnessPercent: 50, lightColorTemperatureKelvin: 2700 } }
  const html = await render('DashboardView', { loading: false, dashboard: record, homeAssistant: deviceStatus() })
  for (const value of ['我的舒睡空间', '一键开启舒睡', '查看舒睡设备', '查看体质启动预设', '打开我的健康档案']) assert.ok(html.includes(value), value)
  assert.match(html, /<details class="startup-preset-details">/)
  assert.ok(html.indexOf('首页</span>') < html.indexOf('中医四诊</span>'))
  assert.ok(html.indexOf('中医四诊</span>') < html.indexOf('健康评估</span>'))
  assert.ok(html.indexOf('健康评估</span>') < html.indexOf('我的</span>'))
})

test('error pages render retry controls without mistaken missing-assessment or device actions', async () => {
  for (const [name, path] of [['DashboardView', '/dashboard'], ['ProfileView', '/profile']]) {
    const html = await render(name, { loading: false, loadError: '测试连接失败' }, path)
    assert.ok(html.includes('测试连接失败')); assert.ok(html.includes('重新加载'))
    assert.ok(!html.includes('一键开启舒睡')); assert.ok(!html.includes('未评估'))
  }
})

test('auth and both questionnaires render safely; loading records never show an editable form', async () => {
  const auth = await render('AuthView', {}, '/auth')
  assert.ok(auth.includes('autocomplete="username"')); assert.ok(auth.includes('autocomplete="current-password"'))
  for (const [name, path] of [['AssessmentView', '/assessment'], ['TcmAssessmentView', '/tcm-assessment']]) {
    const html = await render(name, {}, path)
    assert.ok(html.includes('正在读取'))
    assert.ok(!html.includes('type="number"')); assert.ok(!html.includes('<textarea'))
  }
})