/* ============================================================
 * test_travel_citytour_isolation.js —— 「游山玩水」skill 全栈隔离校验
 *
 * 为什么需要本脚本：
 *   本 lab 的架构约定是「skill 全栈隔离」——每个 skill 在 skills/<skill_id>/ 下自带一整套
 *   后端（config/index/ai/validate/repair + 技能包）与一整套前端（页面/渲染器/样式/导出器/
 *   ⬆图/照片），彼此零耦合。这个约定光靠注释和口头说明必然会被后续开发侵蚀（有人图省事
 *   直接 require 兄弟 skill 或引用 lab 层业务文件），所以这里把它变成「失败即挡」的硬校验。
 *
 * 自动覆盖未来新增的 skill：
 *   本脚本不写死任何 skill_id，而是通过 lab 的 registry 枚举当前所有 skill，
 *   逐个断言。所以以后每加一个 skill，这套校验自动生效，无需改本文件。
 *
 * 校验项（对每个 skill）：
 *   A. 后端：skill 目录内所有 .js 不得 require 出本目录（禁止 '../'）
 *   B. 前端：skill 目录内所有 .html/.js/.css 的相对引用，解析后必须落在
 *        「本 skill 目录内」或「lab 级 assets/vendor/」；其余一律违规
 *        （即：禁止引用兄弟 skill、禁止引用 lab 层业务文件/配置/照片）
 *   C. 前端：不得通过绝对路径引用 lab 业务文件（只允许 /api/... 接口前缀）
 *   D. 契约：config.json / index.js（导出 bindRoutes）/ index.html 三者齐全且可加载
 *   E. 运行时：后端能 require、bindRoutes 能注册出预期路由、prompt 能组装、校验器不抛异常
 *
 * 运行：node dev_test_scripts/unit/test_travel_citytour_isolation.js
 * 退出码：0 = 全部通过；1 = 存在违规
 * ============================================================ */
const fs = require('fs')
const path = require('path')

const ROOT = process.cwd()
const LAB_DIR = path.join(ROOT, 'src', 'server', 'thought_lab', 'labs', 'travel_citytour')
const LAB_PUBLIC = path.join(ROOT, 'public', 'tools', 'thought_lab', 'labs', 'travel_citytour')
const BE_SKILLS = path.join(LAB_DIR, 'skills')
const FE_SKILLS = path.join(LAB_PUBLIC, 'skills')

// 唯一允许 skill 向上引用的位置：lab 级第三方库（无业务语义）
const ALLOWED_UP_REF_PREFIX = path.join(LAB_PUBLIC, 'assets', 'vendor')

const bad = []
const info = []

const registry = require(path.join(LAB_DIR, 'index.js')).constructor ? require(path.join(LAB_DIR, 'registry.js')) : require(path.join(LAB_DIR, 'registry.js'))
const { makeCtx } = require(path.join(LAB_DIR, 'index.js'))

const rel = (p) => path.relative(ROOT, p)

/* 递归收集目录下的文件（跳过 data / node_modules / .gitkeep） */
const walkFiles = (dir, exts, out, skipDirs) => {
  out = out || []
  skipDirs = skipDirs || ['data', 'node_modules', '.git']
  if (!fs.existsSync(dir)) return out
  fs.readdirSync(dir, { withFileTypes: true }).forEach((e) => {
    if (e.isDirectory()) {
      if (skipDirs.indexOf(e.name) >= 0) return
      walkFiles(path.join(dir, e.name), exts, out, skipDirs)
      return
    }
    if (exts.indexOf(path.extname(e.name)) >= 0) out.push(path.join(dir, e.name))
  })
  return out
}

/* ---------- A. 后端：禁止 require 出本 skill 目录 ---------- */
const checkBackendIsolation = (skillId) => {
  const dir = path.join(BE_SKILLS, skillId)
  walkFiles(dir, ['.js']).forEach((file) => {
    const txt = fs.readFileSync(file, 'utf-8')
    // 去掉注释行，避免把「隔离说明」里提到的 ../ 误判成真实引用
    const code = txt.split(/\r?\n/).filter((l) => !/^\s*(\/\/|\*|\/\*)/.test(l)).join('\n')
    const m = code.match(/require\(\s*['"]\.\.?\/(\.\.\/)*[^'"]+['"]\s*\)/g) || []
    m.forEach((hit) => {
      if (/require\(\s*['"]\.\//.test(hit)) return // './xxx' 同目录，允许
      bad.push(`[后端隔离] ${rel(file)} 出现向上越级 require：${hit}（skill 后端只能 require 本目录文件或 npm 包）`)
    })
  })
}

/* ---------- B/C. 前端：相对引用与绝对引用必须落在允许范围 ---------- */
const REF_RE = /(?:src|href)\s*=\s*["']([^"']+)["']|fetch\(\s*['"]([^'"]+)['"]/g

// 两条【契约要求】的导航例外（不是业务耦合，必须放行）：
//   1. 站点首页 '/' —— 401 引导面板里的「重新从首页进入」按钮，指到工具箱根
//   2. lab 聚合页 <lab>/index.html —— 每个 skill 页面都要求有「← 返回技能列表」
const LAB_AGG_PAGE = path.join(LAB_PUBLIC, 'index.html')

const checkFrontendIsolation = (skillId) => {
  const skillRoot = path.join(FE_SKILLS, skillId)
  walkFiles(skillRoot, ['.html', '.js', '.css'], null, ['node_modules', '.git']).forEach((file) => {
    const txt = fs.readFileSync(file, 'utf-8')
    REF_RE.lastIndex = 0
    let hit
    while ((hit = REF_RE.exec(txt)) !== null) {
      const ref = String(hit[1] || hit[2] || '').trim()
      if (!ref) continue
      if (/^(https?:)?\/\//.test(ref) || ref.indexOf('data:') === 0) continue // 外链/内联，放过
      if (ref === '/') continue // 例外 1：站点首页导航

      if (ref.charAt(0) === '/') {
        // 绝对路径：只允许接口前缀，不允许指向 lab 业务文件
        if (ref.indexOf('/api/') !== 0) {
          bad.push(`[前端隔离] ${rel(file)} 出现绝对路径引用：${ref}（只允许 /api/... 接口前缀）`)
        }
        continue
      }
      if (ref.charAt(0) === '#') continue

      // 相对路径：解析后必须落在「本 skill 目录内」或「lab 级 assets/vendor/」
      const resolved = path.resolve(path.dirname(file), ref.split('?')[0].split('#')[0])
      if (resolved === LAB_AGG_PAGE) continue // 例外 2：返回聚合页
      const insideSkill = resolved === skillRoot || resolved.indexOf(skillRoot + path.sep) === 0
      const insideVendor = resolved === ALLOWED_UP_REF_PREFIX || resolved.indexOf(ALLOWED_UP_REF_PREFIX + path.sep) === 0
      if (!insideSkill && !insideVendor) {
        // 同 lab 但落在其他位置（兄弟 skill / lab 业务文件 / lab 配置）→ 违规
        if (resolved.indexOf(LAB_PUBLIC + path.sep) === 0 || resolved.indexOf(LAB_DIR + path.sep) === 0) {
          bad.push(`[前端隔离] ${rel(file)} 引用越界：${ref} → ${rel(resolved)}`
            + `（只允许本 skill 目录内，或 lab 级 ${rel(ALLOWED_UP_REF_PREFIX)}/）`)
        }
        // 完全跳出 lab 目录的（指向其他 tool / lab）也算违规
        else if (resolved.indexOf(path.join(ROOT, 'public', 'tools') + path.sep) === 0
          || resolved.indexOf(path.join(ROOT, 'src') + path.sep) === 0) {
          bad.push(`[前端隔离] ${rel(file)} 引用越界：${ref} → ${rel(resolved)}（禁止跨 tool / lab 引用）`)
        }
      }
    }
  })
}

/* ---------- 与兄弟 skill 的交叉引用（代码层面，注释不算） ---------- */
const checkSiblingRefs = (skillId, allIds) => {
  const siblings = allIds.filter((x) => x !== skillId)
  if (!siblings.length) return
  const scan = (dir, exts) => walkFiles(dir, exts).forEach((file) => {
    const code = fs.readFileSync(file, 'utf-8')
      .split(/\r?\n/).filter((l) => !/^\s*(\/\/|\*|\/\*|<!--)/.test(l)).join('\n')
    siblings.forEach((sib) => {
      // 只查「像引用」的用法（路径/字符串字面量），不看注释
      const re = new RegExp('[\'"`/]' + sib + '[/\'"`]', 'g')
      if (re.test(code)) {
        bad.push(`[兄弟隔离] ${rel(file)} 代码中引用了兄弟 skill「${sib}」（skill 之间不得互相引用）`)
      }
    })
  })
  scan(path.join(BE_SKILLS, skillId), ['.js', '.json'])
  scan(path.join(FE_SKILLS, skillId), ['.js', '.html', '.json'])
}

/* ---------- D/E. 契约与运行时 ---------- */
const checkContractAndRuntime = (skillId) => {
  const beDir = path.join(BE_SKILLS, skillId)
  const feDir = path.join(FE_SKILLS, skillId)
  const need = [
    [path.join(beDir, 'config.json'), '后端 config.json'],
    [path.join(beDir, 'index.js'), '后端 index.js'],
    [path.join(feDir, 'index.html'), '前端 index.html']
  ]
  need.forEach(([p, label]) => {
    if (!fs.existsSync(p)) bad.push(`[契约] ${skillId} 缺 ${label}`)
  })
  if (bad.some((b) => b.indexOf('[契约] ' + skillId) === 0)) return

  const cfg = JSON.parse(fs.readFileSync(path.join(beDir, 'config.json'), 'utf-8'))
  if (String(cfg.id || '') !== skillId) bad.push(`[契约] ${skillId} 的 config.json id 与目录名不一致：${cfg.id}`)

  try {
    const mod = require(path.join(beDir, 'index.js'))
    if (typeof mod.bindRoutes !== 'function') {
      bad.push(`[契约] ${skillId} 的 index.js 未导出 bindRoutes`)
      return
    }
    // 后端不得自行实现鉴权（红线：鉴权必须由 lab 层通过 Router 注入）
    const code = fs.readFileSync(path.join(beDir, 'index.js'), 'utf-8')
      .split(/\r?\n/).filter((l) => !/^\s*(\/\/|\*|\/\*)/.test(l)).join('\n')
    ;['nav_gate', 'parseCookie', 'verifyJwt', 'guidValue', 'DASHSCOPE_API_KEY'].forEach((k) => {
      if (code.indexOf(k) >= 0) {
        bad.push(`[红线] ${skillId}/index.js 出现「${k}」——鉴权/凭据必须由 lab 层 ctx 提供，skill 不得自行实现`)
      }
    })
    const routes = []
    const fakeRouter = { get: (p) => routes.push('GET ' + p), post: (p) => routes.push('POST ' + p), use: () => {} }
    mod.bindRoutes(fakeRouter, makeCtx(skillId))
    if (!routes.length) bad.push(`[契约] ${skillId} 的 bindRoutes 未注册任何路由`)
    info.push(`${skillId}：后端路由 ${routes.join(' / ')}`)
  } catch (e) {
    bad.push(`[契约] ${skillId} 后端加载失败：${String(e.message || e)}`)
  }

  // 深度检查（可选）：ai.js / validate.js 不是 lab 强制契约，只是两个已有 skill 的
  // 约定俗成的拆分方式。新 skill 完全可以不拆（把逻辑都写在 index.js 里）。
  // 所以这里只在「文件存在」时验证其可用性；不存在则跳过，避免把约定当强制而误报。
  const hasAi = fs.existsSync(path.join(beDir, 'ai.js'))
  const hasValidate = fs.existsSync(path.join(beDir, 'validate.js'))
  if (!hasAi && !hasValidate) {
    info.push(`${skillId}：未拆分 ai.js/validate.js（允许；lab 强制契约只有 config.json + index.js + index.html）`)
    return
  }
  try {
    const mod = require(path.join(beDir, 'index.js'))
    if (hasAi) {
      const aiMod = require(path.join(beDir, 'ai.js'))
      if (typeof mod.loadBundle === 'function' && typeof aiMod.buildMessages === 'function') {
        const b = mod.loadBundle()
        const msgs = aiMod.buildMessages(b, { destination: '测试地' }, null)
        if (!msgs || msgs.length !== 2) bad.push(`[运行时] ${skillId} buildMessages 未产出 system+user 两条消息`)
        info.push(`${skillId}：prompt ${msgs[0].content.length} 字符`)
      }
    }
    if (hasValidate) {
      const { validatePayload } = require(path.join(beDir, 'validate.js'))
      if (typeof mod.loadBundle === 'function' && typeof validatePayload === 'function') {
        const chk = validatePayload({}, mod.loadBundle())
        if (!chk.errors.length) bad.push(`[运行时] ${skillId} 校验器对空 payload 未报错（校验形同虚设）`)
        info.push(`${skillId}：空 payload 报 ${chk.errors.length} 个 error`)
      }
    }
    if (fs.existsSync(path.join(beDir, 'repair.js'))) require(path.join(beDir, 'repair.js'))
  } catch (e) {
    bad.push(`[运行时] ${skillId} 引擎加载失败：${String(e.message || e)}`)
  }
}

/* ---------- F. 离线样例（若存在）必须通过本 skill 自己的校验器 ---------- */
const checkSamples = (skillId) => {
  const beDir = path.join(BE_SKILLS, skillId)
  const sampleDir = path.join(FE_SKILLS, skillId, 'sample')
  if (!fs.existsSync(sampleDir)) return
  const files = fs.readdirSync(sampleDir).filter((f) => f.endsWith('.json') && f !== 'report_spec.json')
  if (!files.length) return
  // 样例校验依赖本 skill 的 validate.js（可选拆分）；没拆就跳过，不视为错误
  if (!fs.existsSync(path.join(beDir, 'validate.js'))) {
    info.push(`${skillId}：有样例但未拆分 validate.js，跳过样例校验`)
    return
  }
  try {
    const mod = require(path.join(beDir, 'index.js'))
    const { validatePayload } = require(path.join(beDir, 'validate.js'))
    const b = mod.loadBundle()
    files.forEach((f) => {
      const payload = JSON.parse(fs.readFileSync(path.join(sampleDir, f), 'utf-8'))
      const chk = validatePayload(payload, b)
      if (chk.errors.length) {
        bad.push(`[样例] ${skillId}/sample/${f} 未通过本 skill 校验器：${chk.errors.slice(0, 4).join(' / ')}`)
      } else {
        info.push(`${skillId}：样例 ${f} 校验通过（${chk.warnings.length} warnings，` +
          `卡片 ${chk.stats.cards} / 点位 ${chk.stats.markers}` +
          (chk.stats.addressCovered === undefined ? '' : ` / 地址覆盖 ${chk.stats.addressCovered}`) + '）')
      }
    })
  } catch (e) {
    bad.push(`[样例] ${skillId} 样例校验失败：${String(e.message || e)}`)
  }
}

/* ---------- G. destinations.json 的 sample_ref 必须相对【本 skill 前端目录】可解析 ----------
   这是隔离后修正过的口径：以前 sample_ref 指向 lab 级共享目录，会让 A skill 的样例被 B skill 引用。 */
const checkSampleRefs = (skillId) => {
  const beDest = path.join(BE_SKILLS, skillId, 'destinations.json')
  if (!fs.existsSync(beDest)) return
  const feSkillDir = path.join(FE_SKILLS, skillId)
  try {
    const dest = JSON.parse(fs.readFileSync(beDest, 'utf-8'))
    ;(dest.destinations || []).forEach((d) => {
      ;((d && d.runs) || []).forEach((r) => {
        if (!r || !r.sample_ref) return
        const resolved = path.join(feSkillDir, r.sample_ref)
        if (!fs.existsSync(resolved)) {
          bad.push(`[样例] ${skillId} destinations[${d.key}].runs.sample_ref 不存在（应相对本 skill 前端目录）：${r.sample_ref}`)
        } else if (resolved.indexOf(feSkillDir + path.sep) !== 0) {
          bad.push(`[样例] ${skillId} destinations[${d.key}].sample_ref 越界到本 skill 目录之外：${r.sample_ref}`)
        }
      })
    })
  } catch (e) {
    bad.push(`[样例] ${skillId} destinations.json 解析失败：${String(e.message || e)}`)
  }
}

/* ---------- H. 生成结果「有结构问题也必须落盘 + 200 回传」 ----------
 *
 * 背景（真实事故，本 skill 踩过）：过去只要结构校验出现哪怕 1 个 error，服务端就整份丢弃、
 * 不落盘也不回传 payload，用户什么都拿不到。而那个 error 很可能只是校验器的误判 ——
 * 一次 4 分钟 + 上万 token 的生成就这样白烧了。
 *
 * 这条检查直接调用 skill 注册出来的 POST /generate（把 ctx.callLLM 换成桩，返回一份必然
 * 不合契约的空 payload），断言三件事：
 *   1) 结果仍被写入 skill 私有 data/last_result.json
 *   2) HTTPstatus 为 200（若为 422，前端会走失败分支，payload 反而渲染不出来）
 *   3) envelope.ok === false（如实告知有结构问题，不假装成功）
 *
 * 自动覆盖所有「拆了 ai.js」的 skill；未拆分的（如脚手架骨架）跳过，不算违规。
 * ---------- */
const os = require('os')

const checkPersistOnError = (skillId) => {
  const beDir = path.join(BE_SKILLS, skillId)
  if (!fs.existsSync(path.join(beDir, 'ai.js'))) {
    info.push(`[落盘] ${skillId}：未拆分 ai.js，跳过本项检查`)
    return null
  }

  let mod = null
  let bundle = null
  let answers = {}
  try {
    mod = require(path.join(beDir, 'index.js'))
    bundle = mod.loadBundle()
    // 按本 skill 自己的 qa.json 组装必填答案（不写死任何字段名）
    const qa = bundle.qa || {}
    if ((qa.destination_input || {}).required !== false) answers.destination = '测试地'
    ;(qa.questions || []).forEach((q) => {
      if (!q || q.required === false || !q.key) return
      answers[q.key] = (q.default !== undefined && q.default !== null && q.default !== '')
        ? q.default
        : (q.type === 'number' ? 1 : '测试值')
    })
  } catch (e) {
    bad.push(`[落盘] ${skillId} 准备失败：${String((e && e.message) || e)}`)
    return null
  }

  let tmpDir = ''
  try {
    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tclab-last-'))
  } catch (e) {
    bad.push(`[落盘] ${skillId} 无法创建临时目录：${String((e && e.message) || e)}`)
    return null
  }

  const ctx = makeCtx(skillId)
  ctx.dataDir = tmpDir
  // 桩掉模型调用：返回空对象 → 必然触发一堆结构 error
  ctx.callLLM = async () => ({ content: JSON.stringify({}), finishReason: 'stop', usage: {} })

  const handlers = {}
  const fakeRouter = {
    get: (p, ...mw) => { handlers['GET ' + p] = mw[mw.length - 1] },
    post: (p, ...mw) => { handlers['POST ' + p] = mw[mw.length - 1] },
    use: () => {}
  }

  let gen = null
  try {
    mod.bindRoutes(fakeRouter, ctx)
    gen = handlers['POST /generate']
  } catch (e) {
    bad.push(`[落盘] ${skillId} 注册路由失败：${String((e && e.message) || e)}`)
    return null
  }
  if (typeof gen !== 'function') {
    bad.push(`[落盘] ${skillId} 未注册 POST /generate`)
    return null
  }

  const res = {
    statusCode: 200,
    body: null,
    status(c) { this.statusCode = c; return this },
    json(b) { this.body = b; return this },
    set() { return this },
    on() { return this },
    writableEnded: true
  }

  return Promise.resolve()
    .then(() => gen({ body: { answers }, headers: {} }, res))
    .then(() => {
      const saved = path.join(tmpDir, 'last_result.json')
      if (!fs.existsSync(saved)) {
        bad.push(`[落盘] ${skillId} 结果有结构问题时未落盘 —— 用户会失去整份生成结果（该行为必须避免）`)
        return
      }
      let env = null
      try {
        env = JSON.parse(fs.readFileSync(saved, 'utf-8'))
      } catch (e) {
        bad.push(`[落盘] ${skillId} 落盘文件不是合法 JSON`)
        return
      }
      const nErr = ((env.check || {}).errors || []).length
      if (nErr === 0) {
        bad.push(`[落盘] ${skillId} 用例失效：预期产生结构 error，实际为 0`)
        return
      }
      if (res.statusCode !== 200) {
        bad.push(`[落盘] ${skillId} 有 error 时返回 ${res.statusCode}（应为 200；422 会让前端渲染不出 payload）`)
      }
      if (!res.body || res.body.ok !== false) {
        bad.push(`[落盘] ${skillId} 有 error 时 envelope.ok 应为 false（如实告知结构问题）`)
      }
      info.push(`[落盘] ${skillId}：${nErr} 处结构问题时仍落盘 + 200 回传 + ok=false（用户可查看/导出）`)
    })
    .catch((e) => {
      bad.push(`[落盘] ${skillId} 「有 error 也落盘」测试异常：${String((e && e.message) || e)}`)
    })
    .then(() => {
      try { fs.rmSync(tmpDir, { recursive: true, force: true }) } catch {}
    })
}

/* ---------- 主流程 ---------- */
const health = registry.health()
if (!health.ok) bad.push('[registry] 自检未通过：' + JSON.stringify(health.problems_detail))
const ids = health.items.map((i) => i.id)
if (!ids.length) bad.push('[registry] 未扫描到任何 skill')

ids.forEach((id) => {
  checkBackendIsolation(id)
  checkFrontendIsolation(id)
  checkContractAndRuntime(id)
  checkSamples(id)
  checkSampleRefs(id)
})
if (ids.length > 1) ids.forEach((id) => checkSiblingRefs(id, ids))

const report = () => {
  console.log('===== 游山玩水 · skill 全栈隔离校验 =====')
  info.push(`扫描到 ${ids.length} 个 skill：${ids.join(', ')}`)
  info.push('隔离口径：skill 内联引用只允许「本 skill 目录内」或「lab 级 assets/vendor/」；后端只允许 require 本目录或 npm 包')
  info.forEach((l) => console.log('· ' + l))
  if (bad.length) {
    console.log('\n发现 ' + bad.length + ' 个违规：')
    bad.forEach((b) => console.log('  ✗ ' + b))
    process.exit(1)
  }
  console.log('\n✓ 隔离校验全部通过（' + ids.length + ' 个 skill）')
}

Promise.all(ids.map((id) => checkPersistOnError(id)).filter(Boolean)).then(report)