/**
 * HTTP 接口。
 *
 * 分成三类：
 *   /api/config*    配置文件的读写，走 config-store 那条保护链路
 *   /api/kernel/*   内核状态，以及对管理接口的只读透传
 *   /api/meta/*     静态数据，比如入站类型的字段表
 *
 * 透传只开放 GET。写操作（切换节点、关连接）属于运行时面板的功能，等做到那一步再单独开，
 * 现在不留一个「什么都能转发」的口子。
 */
import listenerFields from '../shared/listener-fields.json' with { type: 'json' }
import { applyConfig, listBackups, readConfig, restoreBackup } from './config-store.ts'
import { kernelVersion, proxyGet, proxyWrite, selectProxy } from './kernel.ts'
import { tokenFromRequest, tokenMatches } from './auth.ts'
import type { ConfigObject } from '../vendor/config-editor/index.ts'
import type { Env } from './env.ts'

/**
 * 延迟测试。名字里可能有斜杠和中文，所以按前缀匹配而不是列进上面那个精确白名单。
 * 它是 GET 但会真的发起网络连接，属于「读」里比较重的一类，单独列出来提醒这一点。
 */
const DELAY_PATH = /^\/(proxies|group)\/.+\/delay$/

/**
 * 订阅线路的健康检查。
 *
 * 订阅线路不在内核的全局名字表里，所以 /proxies/{名字}/delay 对它们一律 404——
 * 要测只能从它所属的订阅进去。整条订阅测用 {订阅}/healthcheck，单条用 {订阅}/{线路}/healthcheck。
 */
const HEALTHCHECK_PATH = /^\/providers\/proxies\/[^/]+(\/[^/]+)?\/healthcheck$/

/**
 * 会持续吐数据的接口。透传它们时不能设超时。
 * 内核在没有 WebSocket 升级时把这三个退化成分块的 HTTP 流，一行一个 JSON。
 */
const STREAM_PATHS = new Set(['/traffic', '/memory', '/logs'])

/**
 * 允许透传的写操作。
 *
 * 每一条都是「只改内核运行状态、不碰配置文件」的动作，所以不走落盘那条保护链路。
 * 仍然是白名单：能写的东西必须一条条列出来。
 */
const WRITABLE: Array<{ method: 'PUT' | 'DELETE'; pattern: RegExp }> = [
  // 断开某条连接，或者全部断开
  { method: 'DELETE', pattern: /^\/connections(\/[^/]+)?$/ },
  // 让内核重新拉取某个订阅
  { method: 'PUT', pattern: /^\/providers\/proxies\/[^/]+$/ },
  // 让内核重新拉取某个规则组
  { method: 'PUT', pattern: /^\/providers\/rules\/[^/]+$/ },
]

/** 允许透传的管理接口路径。白名单而不是黑名单——多开一个口子要有意为之。 */
const READABLE_KERNEL_PATHS = new Set([
  '/version',
  '/configs',
  '/proxies',
  '/providers/proxies',
  '/rules',
  '/providers/rules',
  '/connections',
  '/memory',
  '/traffic',
  '/logs',
])

function json(body: unknown, status = 200): Response {
  return new Response(JSON.stringify(body), {
    status,
    headers: { 'Content-Type': 'application/json; charset=utf-8' },
  })
}

/** 把落盘失败的结果翻译成 HTTP 响应。状态码按「谁的问题」分。 */
function applyFailureStatus(stage: string): number {
  if (stage === 'stale') return 409 // 冲突，客户端该刷新重来
  if (stage === 'self-check' || stage === 'kernel-check') return 422 // 内容不合法
  return 500 // write / reload：服务端或内核的问题
}

/** 打包后的前端。开发时前端由 Vite 提供并把 /api 转发过来，走不到这里。 */
const WEB_DIST = new URL('../web-dist/', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1')

/**
 * 静态文件不需要令牌——它们只是一个空壳，所有数据都要带令牌才拿得到。
 *
 * 单页应用的路由由前端接管，所以找不到的路径回 index.html。但这条**不能**用在
 * 带扩展名的路径上：资源文件是带哈希的，每次打包都换名字，浏览器要是缓存了旧的
 * index.html，它引用的那个 .js 就已经不存在了。这时候回 index.html 等于把一份 HTML
 * 当作 JavaScript 交给浏览器，报出来的是「MIME 类型不对」——一句完全指不到病根的错误。
 * 老老实实回 404，浏览器才会重新去取 index.html。
 */
const HAS_EXTENSION = /\.[a-z0-9]+$/i

async function serveStatic(path: string): Promise<Response> {
  const shellHeaders = {
    'Content-Type': 'text/html; charset=utf-8',
    // 空壳不缓存，否则打包后旧的 index.html 会一直引用已经不存在的资源
    'Cache-Control': 'no-cache',
  }

  const target = Bun.file(WEB_DIST + (path === '/' ? 'index.html' : path.slice(1)))
  if (await target.exists()) {
    return path === '/' ? new Response(target, { headers: shellHeaders }) : new Response(target)
  }

  if (HAS_EXTENSION.test(path)) {
    return new Response(`找不到 ${path}`, {
      status: 404,
      headers: { 'Content-Type': 'text/plain; charset=utf-8' },
    })
  }

  const shell = Bun.file(`${WEB_DIST}index.html`)
  if (await shell.exists()) return new Response(shell, { headers: shellHeaders })
  return new Response('前端还没打包。运行 bun run build，或者开发时用 bun run dev:web。', {
    status: 404,
    headers: { 'Content-Type': 'text/plain; charset=utf-8' },
  })
}

export function createRouter(env: Env, token: string) {
  const route = makeRoute(env, token)

  /**
   * 兜底。没有它的话，请求体不是合法 JSON、或者配置文件在运行中被删，都会抛出一个
   * 没有响应体的 500，前端只能显示「请求失败（HTTP 500）」——这条链路的全部立意是
   * 出事时把用户救回来，而出事时给出的偏偏是最没信息量的一句话。
   */
  return async function handle(req: Request): Promise<Response> {
    try {
      return await route(req)
    } catch (error) {
      return json(
        {
          message: String(error),
          hint: '这是 Patchbay 自身的故障，配置文件没有被改动。',
        },
        500,
      )
    }
  }
}

function makeRoute(env: Env, token: string) {
  return async function route(req: Request): Promise<Response> {
    const url = new URL(req.url)
    const path = url.pathname

    if (!path.startsWith('/api/')) return serveStatic(path)

    if (!tokenMatches(token, tokenFromRequest(req))) {
      return json({ message: '令牌不正确', hint: '它在服务端配置文件的同级目录 .patchbay-token 里。' }, 401)
    }

    // ── 配置 ────────────────────────────────────────────
    if (path === '/api/config' && req.method === 'GET') {
      const snapshot = await readConfig(env)
      return json(snapshot)
    }

    if (path === '/api/config' && req.method === 'PUT') {
      const body = (await req.json()) as { data?: ConfigObject; baseRevision?: string }
      if (!body.data || typeof body.data !== 'object') {
        return json({ message: '请求缺少 data 字段' }, 400)
      }
      const result = await applyConfig(env, body.data, body.baseRevision)
      return result.ok ? json(result) : json(result, applyFailureStatus(result.stage))
    }

    if (path === '/api/config/backups' && req.method === 'GET') {
      return json({ backups: await listBackups(env) })
    }

    const restoreMatch = /^\/api\/config\/backups\/([^/]+)\/restore$/.exec(path)
    if (restoreMatch && req.method === 'POST') {
      const name = decodeURIComponent(restoreMatch[1]!)
      const result = await restoreBackup(env, name)
      return result.ok ? json(result) : json(result, applyFailureStatus(result.stage))
    }

    // ── 内核 ────────────────────────────────────────────
    if (path === '/api/kernel' && req.method === 'GET') {
      return json(await kernelVersion(env))
    }

    // 切换某个策略组当前选中哪个成员。这是白名单里唯一的写操作，单独开而不是放开整个透传：
    // 它只改内核的运行时状态，不碰配置文件，而且是这个工具最日常的动作。
    const selectMatch = /^\/api\/kernel\/proxies\/([^/]+)$/.exec(path)
    if (selectMatch && req.method === 'PUT') {
      const group = decodeURIComponent(selectMatch[1]!)
      const body = (await req.json()) as { name?: string }
      if (!body.name) return json({ message: '请求缺少 name 字段' }, 400)
      const upstream = await selectProxy(env, group, body.name)
      return upstream.ok
        ? json({ ok: true })
        : json({ message: upstream.message || '内核拒绝了这次切换' }, 422)
    }

    if (path.startsWith('/api/kernel/') && (req.method === 'PUT' || req.method === 'DELETE')) {
      const target = path.slice('/api/kernel'.length)
      const rule = WRITABLE.find((w) => w.method === req.method && w.pattern.test(target))
      if (!rule) return json({ message: `不允许写入该路径：${target}` }, 403)
      const upstream = await proxyWrite(env, rule.method, target + url.search)
      return new Response(upstream.body, {
        status: upstream.status,
        headers: { 'Content-Type': upstream.headers.get('Content-Type') ?? 'application/json' },
      })
    }

    if (path.startsWith('/api/kernel/') && req.method === 'GET') {
      const target = path.slice('/api/kernel'.length)
      const allowed =
        READABLE_KERNEL_PATHS.has(target) || DELAY_PATH.test(target) || HEALTHCHECK_PATH.test(target)
      if (!allowed) {
        return json({ message: `不允许访问该路径：${target}` }, 403)
      }
      const upstream = await proxyGet(env, target + url.search, STREAM_PATHS.has(target))
      return new Response(upstream.body, {
        status: upstream.status,
        headers: { 'Content-Type': upstream.headers.get('Content-Type') ?? 'application/json' },
      })
    }

    // ── 静态数据 ────────────────────────────────────────
    if (path === '/api/meta/listener-fields' && req.method === 'GET') {
      return json(listenerFields)
    }

    return json({ message: '没有这个接口' }, 404)
  }
}