import { createHash } from 'node:crypto'

import type { APIRequestContext, APIResponse, TestInfo } from '@playwright/test'

import { attachJson, captureScreenshot, expect, runPrefix, test } from './fixtures'
import {
  adminAccessToken,
  envelopeData,
  fillFormItem,
  loginAsAdmin,
  tableRowByText,
  visibleDialog,
} from './helpers'

test.describe.configure({ mode: 'serial' })

type JsonRecord = Record<string, unknown>
type AssetName = 'logo' | 'favicon'
type Headers = Record<string, string>

interface AssetSnapshot {
  configured: boolean
  originalName: string | null
  mediaType: string | null
  sha256: string | null
  bytes: Buffer | null
  canRestore: boolean
  untouchedReason?: string
}

interface Activity {
  module: string
  action: string
  result: 'PASS' | 'SKIP' | 'CLEANED' | 'CLEANUP_FAILED'
  httpStatus?: number
  resourceId?: string
  detail?: string
}

const PNG_1X1 = Buffer.from(
  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=',
  'base64',
)
const TEST_PNG_SHA256 = createHash('sha256').update(PNG_1X1).digest('hex')

const asRecord = (value: unknown): JsonRecord => value && typeof value === 'object' && !Array.isArray(value)
  ? value as JsonRecord
  : {}
const authorized = (token: string): Headers => ({ Authorization: `Bearer ${token}` })
const responseJson = async (response: APIResponse) => response.json().catch(() => ({}))

function configData(value: unknown) {
  const envelope = asRecord(envelopeData(value))
  return asRecord(envelope.configuration ?? envelope.config ?? envelope.settings ?? envelope)
}

function generalSnapshot(value: unknown) {
  const root = configData(value)
  const general = asRecord(root.general ?? root.generalSettings ?? root)
  return {
    systemName: String(general.systemName ?? root.systemName ?? ''),
    shortName: String(general.shortName ?? root.shortName ?? ''),
    subtitle: String(general.subtitle ?? general.description ?? root.subtitle ?? root.description ?? ''),
    defaultTheme: String(general.defaultTheme ?? root.defaultTheme ?? 'light') === 'dark' ? 'dark' as const : 'light' as const,
    allowThemeSwitch: Boolean(general.allowThemeSwitch ?? root.allowThemeSwitch ?? true),
    knowledgeMenuVisible: Boolean(
      general.knowledgeMenuVisible
      ?? general.localKnowledgeMenuVisible
      ?? root.knowledgeMenuVisible
      ?? true,
    ),
  }
}

function configVersions(value: unknown) {
  const root = configData(value)
  const versions = asRecord(root.versions ?? root.dataVersions ?? root.versionMap)
  return {
    systemName: Number(versions.systemName ?? 0),
    shortName: Number(versions.shortName ?? 0),
    subtitle: Number(versions.subtitle ?? 0),
    defaultTheme: Number(versions.defaultTheme ?? 0),
    allowThemeSwitch: Number(versions.allowThemeSwitch ?? 0),
    knowledgeMenuVisible: Number(versions.knowledgeMenuVisible ?? 0),
  }
}

function assetMetadata(value: unknown, asset: AssetName) {
  const root = configData(value)
  const prefix = asset === 'logo' ? 'logo' : 'favicon'
  const assets = asRecord(root.assets)
  const nested = asRecord(assets[asset] ?? root[asset])
  return {
    configured: Boolean(nested.configured ?? root[`${prefix}Configured`] ?? false),
    originalName: String(nested.originalName ?? root[`${prefix}OriginalName`] ?? '').trim() || null,
    mediaType: String(nested.mediaType ?? root[`${prefix}MediaType`] ?? '').trim() || null,
    sha256: String(nested.sha256 ?? root[`${prefix}Sha256`] ?? '').trim().toLowerCase() || null,
    version: Number(nested.dataVersion ?? nested.version ?? root[`${prefix}DataVersion`] ?? 0),
    url: String(nested.url ?? root[`${prefix}Url`] ?? '').trim() || null,
  }
}

async function readConfiguration(request: APIRequestContext, token: string) {
  const response = await request.get('/api/auth/v1/system-config', { headers: authorized(token) })
  expect(response.status(), '读取完整系统配置快照').toBe(200)
  return responseJson(response)
}

async function snapshotAsset(
  request: APIRequestContext,
  token: string,
  configuration: unknown,
  asset: AssetName,
): Promise<AssetSnapshot> {
  const metadata = assetMetadata(configuration, asset)
  if (!metadata.configured) {
    return { ...metadata, bytes: null, canRestore: true }
  }

  const response = await request.get(`/api/auth/v1/system-config/assets/${asset}`, {
    headers: authorized(token),
  })
  if (response.status() !== 200) {
    return {
      ...metadata,
      bytes: null,
      canRestore: false,
      untouchedReason: `现有定制资源下载失败（HTTP ${response.status()}），为避免破坏不执行替换`,
    }
  }
  const bytes = await response.body()
  const digest = createHash('sha256').update(bytes).digest('hex')
  if (metadata.sha256 && digest !== metadata.sha256) {
    return {
      ...metadata,
      bytes: null,
      canRestore: false,
      untouchedReason: '现有定制资源下载内容与配置摘要不一致，为避免破坏不执行替换',
    }
  }
  return { ...metadata, bytes, sha256: metadata.sha256 ?? digest, canRestore: true }
}

async function restoreGeneral(request: APIRequestContext, token: string, original: unknown) {
  const current = await readConfiguration(request, token)
  return request.put('/api/auth/v1/system-config/general', {
    headers: authorized(token),
    data: {
      ...generalSnapshot(original),
      versions: configVersions(current),
    },
  })
}

function restoredFilename(asset: AssetName, snapshot: AssetSnapshot) {
  if (snapshot.originalName) return snapshot.originalName
  if (snapshot.mediaType === 'image/jpeg') return `${asset}.jpg`
  if (snapshot.mediaType?.includes('icon')) return `${asset}.ico`
  return `${asset}.png`
}

async function restoreAsset(
  request: APIRequestContext,
  token: string,
  asset: AssetName,
  snapshot: AssetSnapshot,
) {
  if (!snapshot.canRestore) return { status: 0, skipped: true }
  const currentPayload = await readConfiguration(request, token)
  const current = assetMetadata(currentPayload, asset)
  if (snapshot.configured) {
    if (!snapshot.bytes || !snapshot.mediaType) throw new Error(`${asset} 原资源备份不完整，无法恢复`)
    const response = await request.post(`/api/auth/v1/system-config/${asset}`, {
      headers: authorized(token),
      params: { version: String(current.version) },
      multipart: {
        file: {
          name: restoredFilename(asset, snapshot),
          mimeType: snapshot.mediaType,
          buffer: snapshot.bytes,
        },
      },
    })
    return { status: response.status(), skipped: false }
  }
  if (!current.configured) return { status: 200, skipped: false }
  const response = await request.delete(`/api/auth/v1/system-config/${asset}`, {
    headers: authorized(token),
    params: { version: String(current.version) },
  })
  return { status: response.status(), skipped: false }
}

async function attachActivities(testInfo: TestInfo, title: string, activities: Activity[]) {
  await attachJson(testInfo, title, {
    runPrefix,
    activities,
    security: '附件仅记录动作、状态和资源编号，不包含登录密码、访问令牌、一次性 API Key 或品牌资源二进制。',
  })
}

test('基础设置显示策略、知识入口与品牌资源经页面即时应用并精确恢复', async ({ page, request }, testInfo) => {
  test.setTimeout(180_000)
  const activities: Activity[] = []
  const token = await adminAccessToken(request)
  const original = await readConfiguration(request, token)
  const originalGeneral = generalSnapshot(original)
  const snapshots: Record<AssetName, AssetSnapshot> = {
    logo: await snapshotAsset(request, token, original, 'logo'),
    favicon: await snapshotAsset(request, token, original, 'favicon'),
  }
  const touched = new Set<AssetName>()
  let primaryError: unknown
  const targetTheme = originalGeneral.defaultTheme === 'light' ? 'dark' : 'light'
  const targetAllowThemeSwitch = !originalGeneral.allowThemeSwitch
  const targetKnowledgeVisible = !originalGeneral.knowledgeMenuVisible

  try {
    await page.addInitScript(() => {
      window.localStorage.removeItem('digital-human-theme')
      document.cookie = 'digital-human-theme=; Max-Age=0; Path=/; SameSite=Strict'
    })
    await loginAsAdmin(page)
    await page.goto('/settings/general')
    await expect(page.getByRole('heading', { name: '基础设置' })).toBeVisible()

    const themeRadios = page.locator('fieldset').filter({ hasText: '默认主题' }).locator('input[type="radio"]')
    await expect(themeRadios).toHaveCount(2)
    expect(await themeRadios.evaluateAll((nodes) => nodes.map((node) => (node as HTMLInputElement).value).sort())).toEqual(['dark', 'light'])
    await page.locator(`input[type="radio"][value="${targetTheme}"]`).check()

    const themeSwitch = page.locator('.system-switch-list label').filter({ hasText: '允许用户切换主题' })
    const knowledgeSwitch = page.locator('.system-switch-list label').filter({ hasText: '显示维修知识入口' })
    const setSwitch = async (scope: ReturnType<typeof page.locator>, value: boolean) => {
      const input = scope.locator('input[type="checkbox"]')
      if ((await input.isChecked()) !== value) await scope.locator('.el-switch').click()
      await expect(input).toBeChecked({ checked: value })
    }
    await setSwitch(themeSwitch, targetAllowThemeSwitch)
    await setSwitch(knowledgeSwitch, targetKnowledgeVisible)

    await captureScreenshot(page, testInfo, 'settings-display-policy-before-save')
    await page.getByRole('button', { name: '保存基础设置' }).click()
    await expect(page.getByText('基础设置已保存并立即生效').last()).toBeVisible()
    activities.push({ module: '基础设置', action: '页面保存默认主题、主题切换和维修知识入口', result: 'PASS' })

    const persisted = generalSnapshot(await readConfiguration(request, token))
    expect(persisted).toEqual({
      ...originalGeneral,
      defaultTheme: targetTheme,
      allowThemeSwitch: targetAllowThemeSwitch,
      knowledgeMenuVisible: targetKnowledgeVisible,
    })
    await expect(page.locator('html')).toHaveAttribute('data-theme', targetTheme)
    await expect(page.locator('.theme-toggle')).toHaveCount(targetAllowThemeSwitch ? 1 : 0)
    await expect(page.getByText('维修知识', { exact: true })).toHaveCount(targetKnowledgeVisible ? 1 : 0)
    await captureScreenshot(page, testInfo, 'settings-display-policy-immediate-application')

    for (const asset of ['logo', 'favicon'] as const) {
      const snapshot = snapshots[asset]
      if (!snapshot.canRestore) {
        activities.push({
          module: '基础设置',
          action: `${asset === 'logo' ? '系统 LOGO' : '网站图标'}上传与即时应用`,
          result: 'SKIP',
          detail: snapshot.untouchedReason,
        })
        continue
      }

      const selector = asset === 'logo'
        ? 'input[type="file"][accept="image/png,image/jpeg"]'
        : 'input[type="file"][accept*=".ico"]'
      await page.locator(selector).setInputFiles({
        name: `${runPrefix}-${asset}.png`,
        mimeType: 'image/png',
        buffer: PNG_1X1,
      })
      const dialog = visibleDialog(page)
      await expect(dialog).toContainText(asset === 'logo' ? '预览并上传系统 LOGO' : '预览并上传网站图标')
      await captureScreenshot(page, testInfo, `settings-${asset}-upload-preview`)
      // 点击确认后即把资源视为已触碰；即便网络响应已成功但成功提示断言失败，finally 也必须恢复。
      touched.add(asset)
      await dialog.getByRole('button', { name: '确认上传' }).click()
      await expect(page.getByText(asset === 'logo' ? '系统 LOGO已更新并立即生效' : '网站图标已更新并立即生效').last()).toBeVisible()

      const afterUpload = assetMetadata(await readConfiguration(request, token), asset)
      expect(afterUpload.configured).toBe(true)
      expect(afterUpload.sha256).toBe(TEST_PNG_SHA256)
      if (asset === 'logo') {
        await expect(page.locator('.brand-mark img').first()).toHaveAttribute('src', new RegExp(TEST_PNG_SHA256))
      } else {
        await expect(page.locator('link[rel~="icon"]')).toHaveAttribute('href', new RegExp(TEST_PNG_SHA256))
      }
      activities.push({
        module: '基础设置',
        action: `${asset === 'logo' ? '系统 LOGO' : '网站图标'}页面上传并即时应用`,
        result: 'PASS',
        httpStatus: 200,
      })
    }
    await captureScreenshot(page, testInfo, 'settings-brand-assets-immediate-application')
  } catch (error) {
    primaryError = error
  } finally {
    for (const asset of ['logo', 'favicon'] as const) {
      if (!touched.has(asset)) continue
      try {
        const result = await restoreAsset(request, token, asset, snapshots[asset])
        expect(result.status, `${asset} 恢复响应`).toBe(200)
        activities.push({ module: '基础设置', action: `恢复 ${asset} 原始资源`, result: 'CLEANED', httpStatus: result.status })
      } catch (error) {
        activities.push({
          module: '基础设置',
          action: `恢复 ${asset} 原始资源`,
          result: 'CLEANUP_FAILED',
          detail: error instanceof Error ? error.message : String(error),
        })
        if (!primaryError) primaryError = error
      }
    }
    try {
      const response = await restoreGeneral(request, token, original)
      expect(response.status(), '恢复基础设置原值').toBe(200)
      activities.push({ module: '基础设置', action: '恢复显示策略与知识入口原值', result: 'CLEANED', httpStatus: response.status() })
    } catch (error) {
      activities.push({
        module: '基础设置',
        action: '恢复显示策略与知识入口原值',
        result: 'CLEANUP_FAILED',
        detail: error instanceof Error ? error.message : String(error),
      })
      if (!primaryError) primaryError = error
    }
    await attachActivities(testInfo, '基础设置扩展与恢复', activities)
  }

  if (primaryError) throw primaryError
  const restored = await readConfiguration(request, token)
  expect(generalSnapshot(restored)).toEqual(originalGeneral)
  for (const asset of ['logo', 'favicon'] as const) {
    const snapshot = snapshots[asset]
    if (!snapshot.canRestore) continue
    const metadata = assetMetadata(restored, asset)
    expect(metadata.configured, `${asset} configured 精确恢复`).toBe(snapshot.configured)
    expect(metadata.sha256, `${asset} 内容摘要精确恢复`).toBe(snapshot.sha256)
    expect(metadata.mediaType, `${asset} MIME 精确恢复`).toBe(snapshot.mediaType)
    expect(metadata.originalName, `${asset} 原文件名精确恢复`).toBe(snapshot.originalName)
  }
})

async function apiData(response: APIResponse, expectedStatus: number, label: string) {
  expect(response.status(), label).toBe(expectedStatus)
  return asRecord(envelopeData(await responseJson(response)))
}

async function projectDetail(request: APIRequestContext, headers: Headers, projectId: string) {
  const response = await request.get(`/api/v1/agent-projects/${encodeURIComponent(projectId)}`, { headers })
  return { response, data: response.status() === 200 ? await apiData(response, 200, '读取项目详情') : {} }
}

async function agentDetail(request: APIRequestContext, headers: Headers, agentId: string) {
  const response = await request.get(`/api/v1/realtime-agents/${encodeURIComponent(agentId)}`, { headers })
  return { response, data: response.status() === 200 ? await apiData(response, 200, '读取智能体详情') : {} }
}

async function cleanupProject(
  request: APIRequestContext,
  headers: Headers,
  projectId: string,
  activities: Activity[],
) {
  const current = await projectDetail(request, headers, projectId)
  if (current.response.status() === 404) return
  const response = await request.delete(`/api/v1/agent-projects/${encodeURIComponent(projectId)}`, {
    headers,
    params: { dataVersion: String(Number(current.data.dataVersion ?? 0)) },
  })
  activities.push({
    module: '智能体组别',
    action: '失败兜底删除项目',
    result: response.status() === 200 ? 'CLEANED' : 'CLEANUP_FAILED',
    httpStatus: response.status(),
    resourceId: projectId,
  })
  expect(response.status(), '失败兜底删除项目').toBe(200)
}

async function cleanupAgent(
  request: APIRequestContext,
  headers: Headers,
  agentId: string,
  activities: Activity[],
) {
  const current = await agentDetail(request, headers, agentId)
  if (current.response.status() === 404) return
  const response = await request.delete(`/api/v1/realtime-agents/${encodeURIComponent(agentId)}`, {
    headers,
    params: { dataVersion: String(Number(current.data.dataVersion ?? 0)) },
  })
  activities.push({
    module: '智能体组别',
    action: '删除测试智能体',
    result: response.status() === 200 ? 'CLEANED' : 'CLEANUP_FAILED',
    httpStatus: response.status(),
    resourceId: agentId,
  })
  expect(response.status(), '删除测试智能体').toBe(200)
}

test('智能体组别页面完成创建编辑启停筛选成员归集组内创建与删除闭环', async ({ page, request }, testInfo) => {
  test.setTimeout(240_000)
  const activities: Activity[] = []
  const token = await adminAccessToken(request)
  const headers = authorized(token)
  const suffix = runPrefix.replace(/[^A-Za-z0-9]/g, '').slice(-10) || Date.now().toString().slice(-10)
  const projectCode = `APE2E-${suffix}`.slice(0, 24)
  const projectName = `APE2E智能体组别-${suffix}`
  const editedProjectName = `${projectName}-已编辑`
  const dependencyAgentName = `APE2E组别成员-${suffix}`
  const scopedAgentName = `APE2E组内创建-${suffix}`
  let projectId = ''
  const agentIds: string[] = []
  let primaryError: unknown

  try {
    await loginAsAdmin(page)
    await page.goto('/agents/projects')
    await expect(page.getByRole('heading', { name: '智能体组别管理' })).toBeVisible()

    await page.getByRole('button', { name: '新建项目' }).click()
    let dialog = visibleDialog(page)
    await fillFormItem(dialog, '项目名称', projectName)
    await fillFormItem(dialog, '项目编号', projectCode)
    await fillFormItem(dialog, '承担单位', '装备维修教研室')
    await fillFormItem(dialog, '项目说明', `${runPrefix} 装备维修数字教员建设与交付验证`)
    // 编号已知，提交前就登记为可能创建；即使成功提示未出现，finally 也能按编号查询并清理。
    projectId = projectCode
    await dialog.getByRole('button', { name: '保存' }).click()
    await expect(page.getByText('项目已创建').last()).toBeVisible()
    let detail = await projectDetail(request, headers, projectId)
    expect(detail.response.status()).toBe(200)
    expect(detail.data.name).toBe(projectName)
    expect(detail.data.status).toBe('enabled')
    activities.push({ module: '智能体组别', action: '页面创建项目并读取数据库结果', result: 'PASS', httpStatus: 201, resourceId: projectId })
    await captureScreenshot(page, testInfo, 'projects-created-and-persisted')

    let row = tableRowByText(page, projectName)
    await row.getByRole('button', { name: '编辑' }).click()
    dialog = visibleDialog(page)
    await fillFormItem(dialog, '项目名称', editedProjectName)
    await fillFormItem(dialog, '承担单位', '装备维修与智能教学中心')
    await fillFormItem(dialog, '项目说明', `${runPrefix} 已编辑：覆盖液压、电气与机械维修课目`)
    await dialog.getByRole('button', { name: '保存' }).click()
    await expect(page.getByText('项目已更新').last()).toBeVisible()
    detail = await projectDetail(request, headers, projectId)
    expect(detail.data.name).toBe(editedProjectName)
    expect(detail.data.unit).toBe('装备维修与智能教学中心')
    activities.push({ module: '智能体组别', action: '页面编辑项目并刷新核验', result: 'PASS', httpStatus: 200, resourceId: projectId })
    await captureScreenshot(page, testInfo, 'projects-edited-and-persisted')

    row = tableRowByText(page, editedProjectName)
    await row.getByRole('button', { name: '停用', exact: true }).click()
    await expect(page.getByText('项目已停用（仅归档标记，不影响项目下智能体对外服务）').last()).toBeVisible()
    detail = await projectDetail(request, headers, projectId)
    expect(detail.data.status).toBe('disabled')
    activities.push({ module: '智能体组别', action: '页面停用项目', result: 'PASS', httpStatus: 200, resourceId: projectId })

    const keyword = page.getByPlaceholder('搜索项目名称、编号、承担单位或负责人')
    await keyword.fill(editedProjectName)
    const statusSelect = page.locator('.toolbar .el-select')
    await statusSelect.click()
    await page.locator('.el-select-dropdown:visible .el-select-dropdown__item').filter({ hasText: '启用中' }).click()
    await expect(tableRowByText(page, editedProjectName)).toHaveCount(0)
    await statusSelect.click()
    await page.locator('.el-select-dropdown:visible .el-select-dropdown__item').filter({ hasText: '已停用' }).click()
    await expect(tableRowByText(page, editedProjectName)).toBeVisible()
    activities.push({ module: '智能体组别', action: '按关键词与启停状态筛选', result: 'PASS', resourceId: projectId })
    await captureScreenshot(page, testInfo, 'projects-disabled-filter-result')

    row = tableRowByText(page, editedProjectName)
    await row.getByRole('button', { name: '启用', exact: true }).click()
    await expect(page.getByText('项目已启用').last()).toBeVisible()
    detail = await projectDetail(request, headers, projectId)
    expect(detail.data.status).toBe('enabled')
    activities.push({ module: '智能体组别', action: '页面重新启用项目', result: 'PASS', httpStatus: 200, resourceId: projectId })

    const dependencyResponse = await request.post('/api/v1/realtime-agents', {
      headers,
      data: { name: dependencyAgentName, expiresAt: '2035-08-15T12:00:00+08:00' },
    })
    const dependency = await apiData(dependencyResponse, 201, '创建成员管理依赖智能体')
    const dependencyAgentId = String(dependency.id ?? '')
    expect(dependencyAgentId).not.toBe('')
    agentIds.push(dependencyAgentId)
    activities.push({ module: '智能体组别', action: 'API 创建未归属草稿智能体作为成员依赖', result: 'PASS', httpStatus: 201, resourceId: dependencyAgentId })

    await page.goto('/agents/projects')
    row = tableRowByText(page, editedProjectName)
    await expect(row).toBeVisible()
    await row.getByRole('button', { name: '管理成员' }).click()
    dialog = visibleDialog(page)
    const dependencyMember = dialog.locator('.member-row').filter({ hasText: dependencyAgentName })
    await expect(dependencyMember).toBeVisible()
    await dependencyMember.locator('input[type="checkbox"]').check()
    await expect(dialog.getByText('已选 1 个')).toBeVisible()
    await dialog.getByRole('button', { name: '保存成员' }).click()
    await expect(page.getByText('已更新项目成员，共 1 个智能体').last()).toBeVisible()
    const assignedDependency = await agentDetail(request, headers, dependencyAgentId)
    expect(assignedDependency.data.projectId).toBe(projectId)
    detail = await projectDetail(request, headers, projectId)
    expect(detail.data.agentCount).toBe(1)
    activities.push({ module: '智能体组别', action: '页面勾选成员并保存归属', result: 'PASS', httpStatus: 200, resourceId: dependencyAgentId })
    await captureScreenshot(page, testInfo, 'projects-member-assignment-persisted')

    row = tableRowByText(page, editedProjectName)
    await row.getByRole('button', { name: '新建智能体' }).click()
    dialog = visibleDialog(page)
    await expect(dialog).toContainText(`所属项目`)
    await expect(dialog).toContainText(`${editedProjectName} · ${projectCode}`)
    await expect(dialog.locator('select')).toHaveCount(0)
    await captureScreenshot(page, testInfo, 'projects-scoped-create-entry')
    await dialog.getByPlaceholder('例如：装备维修虚拟教员').fill(scopedAgentName)
    await dialog.getByRole('button', { name: '长期有效' }).click()
    const createdResponsePromise = page.waitForResponse((response) => (
      response.request().method() === 'POST'
      && new URL(response.url()).pathname === '/api/v1/realtime-agents'
    ))
    await dialog.getByRole('button', { name: '创建', exact: true }).click()
    const createdResponse = await createdResponsePromise
    expect(createdResponse.status(), '项目内入口创建智能体').toBe(201)
    const scopedAgent = asRecord(envelopeData(await createdResponse.json()))
    const scopedAgentId = String(scopedAgent.id ?? '')
    expect(scopedAgentId).not.toBe('')
    agentIds.push(scopedAgentId)
    expect(scopedAgent.projectId).toBe(projectId)
    await expect(page).toHaveURL(new RegExp(`/agents/${encodeURIComponent(scopedAgentId)}(?:\\?|$)`))
    await expect(page.locator('body')).toContainText(scopedAgentName)
    activities.push({ module: '智能体组别', action: '项目内入口锁定归属并真实创建草稿智能体', result: 'PASS', httpStatus: 201, resourceId: scopedAgentId })
    await captureScreenshot(page, testInfo, 'projects-scoped-agent-created', [
      page.locator('input[type="password"], pre, code, [data-testid*="secret"], [data-testid*="password"]'),
    ])

    await page.goto('/agents/projects')
    row = tableRowByText(page, editedProjectName)
    await expect(row).toContainText('共 2 个')
    detail = await projectDetail(request, headers, projectId)
    expect(detail.data.agentCount).toBe(2)

    await row.getByRole('button', { name: '删除' }).click()
    const confirmation = page.locator('.el-message-box:visible').last()
    await expect(confirmation).toContainText('下有 2 个智能体')
    await expect(confirmation).toContainText('删除项目只会解除归属')
    await captureScreenshot(page, testInfo, 'projects-delete-release-warning')
    await confirmation.getByRole('button', { name: '确认删除' }).click()
    await expect(page.getByText('项目已删除，2 个智能体转为未归属').last()).toBeVisible()
    projectId = ''
    await page.reload()
    await expect(tableRowByText(page, editedProjectName)).toHaveCount(0)
    const absentProject = await request.get(`/api/v1/agent-projects/${encodeURIComponent(projectCode)}`, { headers })
    expect(absentProject.status()).toBe(404)
    for (const agentId of agentIds) {
      const released = await agentDetail(request, headers, agentId)
      expect(released.response.status()).toBe(200)
      expect(String(released.data.projectId ?? '')).toBe('')
    }
    activities.push({ module: '智能体组别', action: '页面删除项目、刷新消失且成员仅解除归属', result: 'PASS', httpStatus: 200, resourceId: projectCode })
    await captureScreenshot(page, testInfo, 'projects-deleted-after-refresh')
  } catch (error) {
    primaryError = error
  } finally {
    try {
      if (projectId) await cleanupProject(request, headers, projectId, activities)
    } catch (error) {
      if (!primaryError) primaryError = error
    }
    for (const agentId of agentIds) {
      try {
        await cleanupAgent(request, headers, agentId, activities)
      } catch (error) {
        if (!primaryError) primaryError = error
      }
    }
    await attachActivities(testInfo, '智能体组别完整页面生命周期', activities)
  }

  if (primaryError) throw primaryError
  for (const agentId of agentIds) {
    const response = await request.get(`/api/v1/realtime-agents/${encodeURIComponent(agentId)}`, { headers })
    expect(response.status(), `测试智能体 ${agentId} 已清理`).toBe(404)
  }
})