// Cloudflare Worker: 订阅管理与转换工具 (Subscription Manager & Converter)
// 部署说明：复制此代码到 Cloudflare Workers 编辑器中
// 版本：v4.1 - 智能订阅管理系统，支持 Clash/V2Ray 双向转换

// KV 存储结构说明：
// 1. 短链接键：{shortId} -> JSON {url, type, subscriptionId, outputType} (JSON对象)
// 2. 订阅配置键：sub:{subscriptionId} -> subscription object (JSON)
// 3. 订阅索引键：subscriptions:list -> array of subscription IDs (JSON)
// 4. 订阅类型：permanent (正式) / temporary (临时)

addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
  const url = new URL(request.url)
  
  // 处理根路径 - 返回网页界面
  if (url.pathname === '/' && request.method === 'GET') {
    return new Response(getHTML(), {
      headers: { 'Content-Type': 'text/html;charset=UTF-8' }
    })
  }
  
  // 处理转换请求
  if (url.pathname === '/convert' && request.method === 'POST') {
    try {
      const { clashUrl } = await request.json()
      
      if (!clashUrl) {
        return jsonResponse({ error: '请提供 Clash 订阅链接' }, 400)
      }
      
      const v2raySubscription = await convertClashToV2ray(clashUrl)
      
      return new Response(v2raySubscription, {
        headers: {
          'Content-Type': 'text/plain;charset=UTF-8',
          'Content-Disposition': 'attachment; filename="v2ray_subscription.txt"'
        }
      })
    } catch (error) {
      return jsonResponse({ error: error.message }, 500)
    }
  }
  
  // 处理直接URL转换（用于在线订阅链接）
  if (url.pathname === '/convert' && request.method === 'GET') {
    const clashUrl = url.searchParams.get('url')
    
    if (!clashUrl) {
      return jsonResponse({ error: '请提供 url 参数' }, 400)
    }
    
    try {
      const v2raySubscription = await convertClashToV2ray(clashUrl)
      return new Response(v2raySubscription, {
        headers: {
          'Content-Type': 'text/plain;charset=UTF-8',
          'Cache-Control': 'no-cache, no-store, must-revalidate',
          'Pragma': 'no-cache',
          'Expires': '0'
        }
      })
    } catch (error) {
      return jsonResponse({ error: error.message }, 500)
    }
  }
  
  // 处理生成短链接（如果配置了 KV）
  if (url.pathname === '/shorten' && request.method === 'POST') {
    try {
      const { clashUrl } = await request.json()
      
      if (!clashUrl) {
        return jsonResponse({ error: '请提供 Clash 订阅链接' }, 400)
      }
      
      // 检查是否配置了 KV
      if (typeof SUBSCRIPTION_KV === 'undefined') {
        // 如果没有配置 KV，直接返回长链接
        const longUrl = `${url.origin}/convert?url=${encodeURIComponent(clashUrl)}`
        return jsonResponse({ url: longUrl, type: 'direct' })
      }
      
      // 使用 KV 生成短链接
      const shortId = generateShortId()
      const expirationTime = 7 * 24 * 60 * 60 // 7天过期
      
      const metadata = {
        clashUrl,
        createdAt: Date.now()
      }
      await SUBSCRIPTION_KV.put(shortId, clashUrl, {
        expirationTtl: expirationTime,
        metadata
      })
      
      const shortUrl = `${url.origin}/s/${shortId}`
      return jsonResponse({ url: shortUrl, type: 'short', expiresIn: expirationTime })
      
    } catch (error) {
      return jsonResponse({ error: error.message }, 500)
    }
  }
  
  // 处理短链接访问
  if (url.pathname.startsWith('/s/')) {
    const shortId = url.pathname.substring(3)
    const requestedType = url.searchParams.get('type') // clash or v2ray
    
    try {
      // 检查是否配置了 KV
      if (typeof SUBSCRIPTION_KV === 'undefined') {
        return new Response('短链接功能未启用', { status: 404 })
      }
      
      const shortLinkJson = await SUBSCRIPTION_KV.get(shortId)
      
      if (!shortLinkJson) {
        return new Response('链接不存在或已过期', { status: 404 })
      }
      
      const shortLinkData = JSON.parse(shortLinkJson)
      
      const sourceUrl = shortLinkData.url
      const sourceType = shortLinkData.type || 'clash'
      const defaultOutputType = shortLinkData.outputType || 'v2ray'
      const targetType = requestedType || defaultOutputType
      
      let result
      
      // 根据源类型和目标类型进行转换
      if (sourceType === 'clash' && targetType === 'v2ray') {
        result = await convertClashToV2ray(sourceUrl)
      } else if (sourceType === 'v2ray' && targetType === 'clash') {
        result = await convertV2rayToClash(sourceUrl)
      } else if (sourceType === 'clash' && targetType === 'clash') {
        // 直接返回 clash 订阅
        const response = await fetch(sourceUrl, {
          headers: { 'User-Agent': 'ClashForWindows/0.20.39' }
        })
        result = await response.text()
      } else if (sourceType === 'v2ray' && targetType === 'v2ray') {
        // 直接返回 v2ray 订阅
        const response = await fetch(sourceUrl, {
          headers: { 'User-Agent': 'v2rayN/6.0' }
        })
        result = await response.text()
      } else {
        // 默认：clash to v2ray
        result = await convertClashToV2ray(sourceUrl)
      }
      
      return new Response(result, {
        headers: {
          'Content-Type': 'text/plain;charset=UTF-8',
          'Cache-Control': 'no-cache, no-store, must-revalidate',
          'Pragma': 'no-cache',
          'Expires': '0'
        }
      })
    } catch (error) {
      return new Response(`转换失败: ${error.message}`, { status: 500 })
    }
  }

  // ========== 订阅管理 API ==========
  
  // 创建新订阅
  if (url.pathname === '/api/subscriptions' && request.method === 'POST') {
    try {
      const { name, clashUrl, expiration = '7d', outputType = 'auto', subscriptionMode = 'permanent' } = await request.json()
      
      if (!name || !clashUrl) {
        return jsonResponse({ error: '缺少必需参数 name 或 clashUrl' }, 400)
      }
      
      // 检查是否配置了 KV
      if (typeof SUBSCRIPTION_KV === 'undefined') {
        return jsonResponse({ error: 'KV 未配置' }, 500)
      }
      
      // 临时订阅限制有效期
      let finalExpiration = expiration
      if (subscriptionMode === 'temporary') {
        // 临时订阅只能选择 1天、3天、7天
        if (!['1d', '3d', '7d'].includes(expiration)) {
          finalExpiration = '3d'  // 默认3天
        }
      }
      
      // 自动检测订阅类型
      const subscriptionType = await detectSubscriptionType(clashUrl)
      
      // 生成订阅ID
      const subscriptionId = generateShortId()
      
      const expirationTime = parseExpiration(finalExpiration)
      
      // 创建订阅对象（先创建，短链按需生成）
      const subscription = {
        id: subscriptionId,
        name,
        clashUrl,
        subscriptionType,
        subscriptionMode,
        outputType,
        shortIds: {}, // 改为对象，存储不同类型的短链: {clash: 'xxx', v2ray: 'yyy'}
        shortIdsExpiry: {}, // 存储每个短链的过期时间: {clash: timestamp, v2ray: timestamp}
        createdAt: Date.now(),
        expiresAt: expirationTime ? Date.now() + expirationTime * 1000 : null,
        expiration: finalExpiration,
        updatedAt: Date.now()
      }
      
      // 保存订阅
      await SUBSCRIPTION_KV.put(`sub:${subscriptionId}`, JSON.stringify(subscription))
      
      // 更新订阅列表索引
      await addToSubscriptionList(subscriptionId)
      
      // 短链按需生成，不在这里预先创建
      subscription.isExpired = expirationTime ? Date.now() > subscription.expiresAt : false
      
      return jsonResponse({ success: true, subscription })
      
    } catch (error) {
      return jsonResponse({ error: error.message }, 500)
    }
  }
  
  // 获取所有订阅列表
  if (url.pathname === '/api/subscriptions' && request.method === 'GET') {
    try {
      const subscriptionIds = await getSubscriptionList()
      const subscriptions = []
      
      for (const id of subscriptionIds) {
        const data = await SUBSCRIPTION_KV.get(`sub:${id}`)
        if (data) {
          const sub = JSON.parse(data)
          sub.shortIds = sub.shortIds || {}
          sub.shortIdsExpiry = sub.shortIdsExpiry || {}
          // 检查是否过期
          sub.isExpired = sub.expiresAt ? Date.now() > sub.expiresAt : false
          subscriptions.push(sub)
        }
      }
      
      return jsonResponse({ success: true, subscriptions })
      
    } catch (error) {
      console.error('获取订阅列表失败:', error)
      return jsonResponse({ error: error.message }, 500)
    }
  }
  
  // 获取单个订阅详情
  if (url.pathname.match(/^\/api\/subscriptions\/[^\/]+$/) && request.method === 'GET') {
    try {
      const subscriptionId = url.pathname.split('/').pop()
      
      if (typeof SUBSCRIPTION_KV === 'undefined') {
        return jsonResponse({ error: 'KV 未配置' }, 500)
      }
      
      const data = await SUBSCRIPTION_KV.get(`sub:${subscriptionId}`)
      if (!data) {
        return jsonResponse({ error: '订阅不存在' }, 404)
      }
      
      const subscription = JSON.parse(data)
      subscription.shortIds = subscription.shortIds || {}
      subscription.shortIdsExpiry = subscription.shortIdsExpiry || {}
      subscription.isExpired = subscription.expiresAt ? Date.now() > subscription.expiresAt : false
      
      return jsonResponse({ success: true, subscription })
      
    } catch (error) {
      return jsonResponse({ error: error.message }, 500)
    }
  }
  
  // 更新订阅
  if (url.pathname.match(/^\/api\/subscriptions\/[^\/]+$/) && request.method === 'PUT') {
    try {
      const subscriptionId = url.pathname.split('/').pop()
      const updates = await request.json()
      
      if (typeof SUBSCRIPTION_KV === 'undefined') {
        return jsonResponse({ error: 'KV 未配置' }, 500)
      }
      
      const data = await SUBSCRIPTION_KV.get(`sub:${subscriptionId}`)
      if (!data) {
        return jsonResponse({ error: '订阅不存在' }, 404)
      }
      
      const subscription = JSON.parse(data)
      
      // 更新允许的字段
      if (updates.name) subscription.name = updates.name
      if (updates.outputType) subscription.outputType = updates.outputType
      
      if (updates.clashUrl && updates.clashUrl !== subscription.clashUrl) {
        // 如果更新了 clashUrl，重新检测类型并更新所有已存在的短链接
        subscription.clashUrl = updates.clashUrl
        subscription.subscriptionType = await detectSubscriptionType(updates.clashUrl)
        
        // 更新所有已存在的短链接数据
        const ttl = subscription.expiresAt ? Math.floor((subscription.expiresAt - Date.now()) / 1000) : null
        const putOptions = ttl && ttl > 0
          ? { expirationTtl: ttl, metadata: { updatedAt: Date.now() } }
          : { metadata: { updatedAt: Date.now(), permanent: true } }
        
        subscription.shortIds = subscription.shortIds || {}
        for (const [linkType, shortId] of Object.entries(subscription.shortIds)) {
          if (shortId) {
            const shortLinkData = {
              url: updates.clashUrl,
              type: subscription.subscriptionType,
              subscriptionId,
              outputType: linkType
            }
            await SUBSCRIPTION_KV.put(shortId, JSON.stringify(shortLinkData), putOptions)
          }
        }
      }
      
      subscription.updatedAt = Date.now()
      
      // 保存更新后的订阅
      await SUBSCRIPTION_KV.put(`sub:${subscriptionId}`, JSON.stringify(subscription))
      
      subscription.shortIds = subscription.shortIds || {}
      subscription.shortIdsExpiry = subscription.shortIdsExpiry || {}
      subscription.isExpired = subscription.expiresAt ? Date.now() > subscription.expiresAt : false
      
      return jsonResponse({ success: true, subscription })
      
    } catch (error) {
      return jsonResponse({ error: error.message }, 500)
    }
  }
  
  // 清空所有KV数据 (必须放在删除订阅路由之前，否则会被正则匹配拦截)
  if (url.pathname === '/api/subscriptions/clear-all' && request.method === 'POST') {
    try {
      if (typeof SUBSCRIPTION_KV === 'undefined') {
        return jsonResponse({ error: 'KV 未配置' }, 500)
      }
      
      // 列出所有 KV 键并逐一删除
      let cursor = undefined
      let deletedCount = 0
      
      do {
        const listResult = await SUBSCRIPTION_KV.list({ limit: 1000, cursor })
        
        for (const key of listResult.keys) {
          await SUBSCRIPTION_KV.delete(key.name)
          deletedCount++
        }
        
        cursor = listResult.list_complete ? undefined : listResult.cursor
      } while (cursor)
      
      return jsonResponse({ success: true, message: `已清空所有数据，共删除 ${deletedCount} 条记录` })
      
    } catch (error) {
      return jsonResponse({ error: error.message }, 500)
    }
  }
  
  // 删除订阅
  if (url.pathname.match(/^\/api\/subscriptions\/[^\/]+$/) && request.method === 'DELETE') {
    try {
      const subscriptionId = url.pathname.split('/').pop()
      
      if (typeof SUBSCRIPTION_KV === 'undefined') {
        return jsonResponse({ error: 'KV 未配置' }, 500)
      }
      
      const data = await SUBSCRIPTION_KV.get(`sub:${subscriptionId}`)
      if (!data) {
        return jsonResponse({ error: '订阅不存在' }, 404)
      }
      
      const subscription = JSON.parse(data)
      
      // 删除所有短链接
      if (subscription.shortIds) {
        for (const shortId of Object.values(subscription.shortIds)) {
          if (shortId) {
            await SUBSCRIPTION_KV.delete(shortId)
          }
        }
      }
      
      // 删除订阅
      await SUBSCRIPTION_KV.delete(`sub:${subscriptionId}`)
      
      // 从订阅列表中移除
      await removeFromSubscriptionList(subscriptionId)
      
      return jsonResponse({ success: true, message: '订阅已删除' })
      
    } catch (error) {
      return jsonResponse({ error: error.message }, 500)
    }
  }
  
  // 续期订阅短链
  if (url.pathname.match(/^\/api\/subscriptions\/[^\/]+\/renew$/) && request.method === 'POST') {
    try {
      const subscriptionId = url.pathname.split('/')[3]
      const { expiration = '7d', outputType, linkType = 'auto' } = await request.json()
      
      if (typeof SUBSCRIPTION_KV === 'undefined') {
        return jsonResponse({ error: 'KV 未配置' }, 500)
      }
      
      const data = await SUBSCRIPTION_KV.get(`sub:${subscriptionId}`)
      if (!data) {
        return jsonResponse({ error: '订阅不存在' }, 404)
      }
      
      const subscription = JSON.parse(data)
      
      subscription.shortIds = subscription.shortIds || {}
      subscription.shortIdsExpiry = subscription.shortIdsExpiry || {}
      
      // 临时订阅限制有效期
      let finalExpiration = expiration
      if (subscription.subscriptionMode === 'temporary') {
        if (!['1d', '3d', '7d'].includes(expiration)) {
          finalExpiration = '3d'
        }
      }
      
      const expirationTime = parseExpiration(finalExpiration)
      const newExpiryTime = expirationTime ? Date.now() + expirationTime * 1000 : null
      
      // 更新输出类型（如果提供）
      if (outputType) {
        subscription.outputType = outputType
      }
      
      // 检查是否已有该类型的短链，如有则续期，没有则创建
      let targetShortId = subscription.shortIds[linkType]
      
      if (!targetShortId) {
        // 创建新的短链
        targetShortId = generateShortId()
        subscription.shortIds[linkType] = targetShortId
      }
      
      // 更新短链接过期时间
      const shortLinkData = {
        url: subscription.clashUrl,
        type: subscription.subscriptionType || 'clash',
        subscriptionId,
        outputType: linkType,
        subscriptionMode: subscription.subscriptionMode
      }
      
      const putOptions = expirationTime
        ? { expirationTtl: expirationTime, metadata: { renewedAt: Date.now() } }
        : { metadata: { renewedAt: Date.now(), permanent: true } }
      
      await SUBSCRIPTION_KV.put(targetShortId, JSON.stringify(shortLinkData), putOptions)
      
      // 保存该短链的过期时间
      subscription.shortIdsExpiry[linkType] = newExpiryTime
      
      // 更新订阅过期时间（取所有短链中最晚的）
      const allExpiries = Object.values(subscription.shortIdsExpiry).filter(t => t !== null)
      subscription.expiresAt = allExpiries.length > 0 ? Math.max(...allExpiries) : null
      subscription.expiration = finalExpiration
      subscription.updatedAt = Date.now()
      
      await SUBSCRIPTION_KV.put(`sub:${subscriptionId}`, JSON.stringify(subscription))
      
      subscription.isExpired = false
      
      return jsonResponse({ 
        success: true, 
        subscription, 
        message: `已续期: ${finalExpiration}`,
        shortId: targetShortId,
        shortUrl: `${url.origin}/s/${targetShortId}`
      })
      
    } catch (error) {
      return jsonResponse({ error: error.message }, 500)
    }
  }
  
  // 重新生成短链
  if (url.pathname.match(/^\/api\/subscriptions\/[^\/]+\/regenerate$/) && request.method === 'POST') {
    try {
      const subscriptionId = url.pathname.split('/')[3]
      const { expiration = '7d', outputType, linkType = 'auto' } = await request.json()
      
      if (typeof SUBSCRIPTION_KV === 'undefined') {
        return jsonResponse({ error: 'KV 未配置' }, 500)
      }
      
      const data = await SUBSCRIPTION_KV.get(`sub:${subscriptionId}`)
      if (!data) {
        return jsonResponse({ error: '订阅不存在' }, 404)
      }
      
      const subscription = JSON.parse(data)
      
      subscription.shortIds = subscription.shortIds || {}
      subscription.shortIdsExpiry = subscription.shortIdsExpiry || {}
      
      // 临时订阅限制有效期
      let finalExpiration = expiration
      if (subscription.subscriptionMode === 'temporary') {
        if (!['1d', '3d', '7d'].includes(expiration)) {
          finalExpiration = '3d'
        }
      }
      
      // 删除该类型的旧短链接（如果存在）
      const oldShortId = subscription.shortIds[linkType]
      if (oldShortId) {
        await SUBSCRIPTION_KV.delete(oldShortId)
      }
      
      // 生成新短链接
      const newShortId = generateShortId()
      const expirationTime = parseExpiration(finalExpiration)
      const newExpiryTime = expirationTime ? Date.now() + expirationTime * 1000 : null
      
      // 更新输出类型（如果提供）
      if (outputType) {
        subscription.outputType = outputType
      }
      
      const shortLinkData = {
        url: subscription.clashUrl,
        type: subscription.subscriptionType || 'clash',
        subscriptionId,
        outputType: linkType,
        subscriptionMode: subscription.subscriptionMode
      }
      
      const putOptions = expirationTime
        ? { expirationTtl: expirationTime, metadata: { regeneratedAt: Date.now() } }
        : { metadata: { regeneratedAt: Date.now(), permanent: true } }
      
      await SUBSCRIPTION_KV.put(newShortId, JSON.stringify(shortLinkData), putOptions)
      
      // 更新订阅中该类型的短链
      subscription.shortIds[linkType] = newShortId
      subscription.shortIdsExpiry[linkType] = newExpiryTime
      
      // 更新订阅过期时间（取所有短链中最晚的）
      const allExpiries = Object.values(subscription.shortIdsExpiry).filter(t => t !== null)
      subscription.expiresAt = allExpiries.length > 0 ? Math.max(...allExpiries) : null
      subscription.expiration = finalExpiration
      subscription.updatedAt = Date.now()
      
      await SUBSCRIPTION_KV.put(`sub:${subscriptionId}`, JSON.stringify(subscription))
      
      subscription.isExpired = false
      
      return jsonResponse({ 
        success: true, 
        subscription, 
        message: '已生成新短链',
        shortId: newShortId,
        shortUrl: `${url.origin}/s/${newShortId}`
      })
      
    } catch (error) {
      return jsonResponse({ error: error.message }, 500)
    }
  }

  // ========== 管理页和API ==========


  // 管理页（需要 ADMIN_TOKEN）
  if (url.pathname === '/admin' && request.method === 'GET') {
    const adminToken = getAdminToken()
    if (!adminToken) return new Response('管理功能未启用', { status: 404 })
    const requestToken = request.headers.get('x-admin-token') || url.searchParams.get('token')
    if (requestToken !== adminToken) return new Response('未授权', { status: 401 })
    return new Response(getAdminHTML(), {
      headers: { 'Content-Type': 'text/html;charset=UTF-8' }
    })
  }

  // 列出短链
  if (url.pathname === '/admin/list' && request.method === 'GET') {
    const adminToken = getAdminToken()
    if (!adminToken) return new Response('管理功能未启用', { status: 404 })
    const requestToken = request.headers.get('x-admin-token') || url.searchParams.get('token')
    if (requestToken !== adminToken) return new Response('未授权', { status: 401 })
    if (typeof SUBSCRIPTION_KV === 'undefined') return new Response('KV 未配置', { status: 500 })

    const cursor = url.searchParams.get('cursor') || undefined
    const listResult = await SUBSCRIPTION_KV.list({ limit: 50, cursor })

    const keys = listResult.keys.map(key => ({
      id: key.name,
      expiration: key.expiration || null,
      metadata: key.metadata || null
    }))

    return jsonResponse({
      keys,
      cursor: listResult.cursor || null,
      list_complete: listResult.list_complete
    })
  }

  // 续期短链
  if (url.pathname === '/admin/renew' && request.method === 'POST') {
    const adminToken = getAdminToken()
    if (!adminToken) return new Response('管理功能未启用', { status: 404 })
    const requestToken = request.headers.get('x-admin-token') || url.searchParams.get('token')
    if (requestToken !== adminToken) return new Response('未授权', { status: 401 })
    if (typeof SUBSCRIPTION_KV === 'undefined') return new Response('KV 未配置', { status: 500 })

    const { id, days = 7 } = await request.json()
    if (!id) return jsonResponse({ error: '缺少短链 id' }, 400)

    const ttlDays = Math.max(1, parseInt(days, 10) || 7)
    const expirationTime = ttlDays * 24 * 60 * 60

    const { value, metadata } = await SUBSCRIPTION_KV.getWithMetadata(id, { type: 'text' })
    if (!value) return jsonResponse({ error: '短链不存在或已过期' }, 404)

    const newMetadata = Object.assign({}, metadata || {}, { renewedAt: Date.now() })
    await SUBSCRIPTION_KV.put(id, value, {
      expirationTtl: expirationTime,
      metadata: newMetadata
    })

    return jsonResponse({ ok: true, expiresIn: expirationTime })
  }

  // 删除短链
  if (url.pathname === '/admin/delete' && request.method === 'POST') {
    const adminToken = getAdminToken()
    if (!adminToken) return new Response('管理功能未启用', { status: 404 })
    const requestToken = request.headers.get('x-admin-token') || url.searchParams.get('token')
    if (requestToken !== adminToken) return new Response('未授权', { status: 401 })
    if (typeof SUBSCRIPTION_KV === 'undefined') return new Response('KV 未配置', { status: 500 })

    const { id } = await request.json()
    if (!id) return jsonResponse({ error: '缺少短链 id' }, 400)

    await SUBSCRIPTION_KV.delete(id)
    return jsonResponse({ ok: true })
  }
  
  return new Response('Not Found', { status: 404 })
}

// ========== 辅助函数 ==========

// 检测订阅类型
async function detectSubscriptionType(subscriptionUrl) {
  try {
    const response = await fetch(subscriptionUrl, {
      headers: { 'User-Agent': 'ClashForWindows/0.20.39' },
      cf: { cacheTtl: 0, cacheEverything: false }
    })
    
    if (!response.ok) return 'unknown'
    
    const text = await response.text()
    
    // 尝试 Base64 解码检测 v2ray
    try {
      const decoded = atob(text.trim())
      if (decoded.includes('vmess://') || decoded.includes('ss://') || 
          decoded.includes('trojan://') || decoded.includes('vless://')) {
        return 'v2ray'
      }
    } catch (e) {
      // 不是 base64，继续检测
    }
    
    // 检测是否是 Clash YAML 格式
    if (text.includes('proxies:') || text.includes('proxy-groups:')) {
      return 'clash'
    }
    
    // 直接包含协议链接（未编码的 v2ray）
    if (text.includes('vmess://') || text.includes('ss://') || 
        text.includes('trojan://') || text.includes('vless://')) {
      return 'v2ray'
    }
    
    return 'unknown'
  } catch (error) {
    console.error('检测订阅类型失败:', error)
    return 'unknown'
  }
}

// 解析过期时间（支持：7, 30d, 3m, 1y, unlimited）
function parseExpiration(input) {
  if (!input || input === 'unlimited' || input === 'never') {
    return null // 无限期
  }
  
  const str = String(input).trim().toLowerCase()
  
  // 纯数字，默认天
  if (/^\d+$/.test(str)) {
    return parseInt(str) * 24 * 60 * 60
  }
  
  // 带单位
  const match = str.match(/^(\d+)([dmy])$/)
  if (match) {
    const value = parseInt(match[1])
    const unit = match[2]
    
    if (unit === 'd') return value * 24 * 60 * 60
    if (unit === 'm') return value * 30 * 24 * 60 * 60
    if (unit === 'y') return value * 365 * 24 * 60 * 60
  }
  
  // 默认 7 天
  return 7 * 24 * 60 * 60
}

// V2Ray 转 Clash（简化版，支持基本协议）
async function convertV2rayToClash(v2rayUrl) {
  const response = await fetch(v2rayUrl, {
    headers: { 'User-Agent': 'v2rayN/6.0' },
    cf: { cacheTtl: 0, cacheEverything: false }
  })
  
  if (!response.ok) {
    throw new Error(`下载订阅失败: ${response.status}`)
  }
  
  let text = await response.text()
  
  // 尝试 Base64 解码
  try {
    text = atob(text.trim())
  } catch (e) {
    // 已经是解码状态
  }
  
  const lines = text.split('\n').filter(l => l.trim())
  const proxies = []
  
  for (const line of lines) {
    try {
      if (line.startsWith('vmess://')) {
        proxies.push(parseVmessToClash(line))
      } else if (line.startsWith('ss://')) {
        proxies.push(parseShadowsocksToClash(line))
      } else if (line.startsWith('trojan://')) {
        proxies.push(parseTrojanToClash(line))
      }
    } catch (e) {
      console.error('解析节点失败:', e)
    }
  }
  
  if (proxies.length === 0) {
    throw new Error('没有找到有效的节点')
  }
  
  // 生成 Clash YAML
  const yaml = generateClashYAML(proxies)
  return yaml
}

function parseVmessToClash(vmessLink) {
  const json = JSON.parse(atob(vmessLink.substring(8)))
  return {
    name: json.ps || 'VMess',
    type: 'vmess',
    server: json.add,
    port: parseInt(json.port),
    uuid: json.id,
    alterId: parseInt(json.aid || 0),
    cipher: json.scy || 'auto',
    network: json.net || 'tcp',
    tls: json.tls === 'tls',
    'skip-cert-verify': true
  }
}

function parseShadowsocksToClash(ssLink) {
  const url = new URL(ssLink)
  const userinfo = atob(url.username)
  const [cipher, password] = userinfo.split(':')
  
  return {
    name: decodeURIComponent(url.hash.substring(1)) || 'SS',
    type: 'ss',
    server: url.hostname,
    port: parseInt(url.port),
    cipher: cipher,
    password: password
  }
}

function parseTrojanToClash(trojanLink) {
  const url = new URL(trojanLink)
  
  return {
    name: decodeURIComponent(url.hash.substring(1)) || 'Trojan',
    type: 'trojan',
    server: url.hostname,
    port: parseInt(url.port),
    password: url.username,
    'skip-cert-verify': true
  }
}

function generateClashYAML(proxies) {
  let yaml = 'proxies:\n'
  for (const proxy of proxies) {
    yaml += `  - name: "${proxy.name}"\n`
    yaml += `    type: ${proxy.type}\n`
    yaml += `    server: ${proxy.server}\n`
    yaml += `    port: ${proxy.port}\n`
    
    if (proxy.type === 'vmess') {
      yaml += `    uuid: ${proxy.uuid}\n`
      yaml += `    alterId: ${proxy.alterId}\n`
      yaml += `    cipher: ${proxy.cipher}\n`
      if (proxy.tls) yaml += `    tls: true\n`
    } else if (proxy.type === 'ss') {
      yaml += `    cipher: ${proxy.cipher}\n`
      yaml += `    password: ${proxy.password}\n`
    } else if (proxy.type === 'trojan') {
      yaml += `    password: ${proxy.password}\n`
      yaml += `    skip-cert-verify: true\n`
    }
  }
  return yaml
}

async function convertClashToV2ray(clashUrl) {
  // 1. 下载 Clash 订阅配置
  const response = await fetch(clashUrl, {
    headers: {
      'User-Agent': 'ClashForWindows/0.20.39'
    },
    cf: {
      cacheTtl: 0,
      cacheEverything: false
    }
  })
  
  if (!response.ok) {
    throw new Error(`下载订阅失败: ${response.status} ${response.statusText}`)
  }
  
  const text = await response.text()
  
  // 2. 解析 YAML (简化版解析器)
  const config = parseSimpleYAML(text)
  
  if (!config.proxies || !Array.isArray(config.proxies)) {
    throw new Error('订阅格式错误: 找不到 proxies 节点')
  }
  
  // 3. 转换每个代理节点
  const v2rayLinks = []
  
  for (const proxy of config.proxies) {
    try {
      const link = convertProxyToV2ray(proxy)
      if (link) {
        v2rayLinks.push(link)
      }
    } catch (error) {
      console.error(`转换节点失败: ${proxy.name}`, error)
      // 继续处理其他节点
    }
  }
  
  if (v2rayLinks.length === 0) {
    throw new Error('没有成功转换的节点')
  }
  
  // 4. 生成最终订阅 (Base64 编码)
  const allLinks = v2rayLinks.join('\n')
  return btoa(unescape(encodeURIComponent(allLinks)))
}

function convertProxyToV2ray(proxy) {
  const name = encodeURIComponent(proxy.name || 'node')
  const sniValue = proxy.sni || proxy.servername || ''
  const fingerprintValue = proxy.fingerprint || proxy['client-fingerprint'] || ''
  
  // Shadowsocks
  if (proxy.type === 'ss') {
    const userInfo = `${proxy.cipher}:${proxy.password}`
    const userInfoB64 = btoa(userInfo)
    
    // 处理插件和插件选项
    let plugin = ''
    if (proxy.plugin) {
      plugin = `?plugin=${encodeURIComponent(proxy.plugin)}`
      if (proxy['plugin-opts']) {
        const opts = Object.entries(proxy['plugin-opts'])
          .map(([k, v]) => `${k}=${v}`)
          .join(';')
        if (opts) {
          plugin += encodeURIComponent(';' + opts)
        }
      }
    }
    
    return `ss://${userInfoB64}@${proxy.server}:${proxy.port}${plugin}#${name}`
  }
  
  // VMess
  if (proxy.type === 'vmess') {
    const net = proxy.network || 'tcp'
    const vmessData = {
      v: '2',
      ps: proxy.name || 'node',
      add: proxy.server,
      port: String(proxy.port),
      id: proxy.uuid,
      aid: String(proxy.alterId || 0),
      scy: proxy.cipher || 'auto',
      net: net,
      type: 'none',  // 伪装类型，默认none
      host: '',
      path: '',
      tls: proxy.tls ? 'tls' : '',
      sni: sniValue,
      alpn: ''
    }

    if (proxy['skip-cert-verify']) {
      vmessData.allowInsecure = true
    }
    
    // 处理 WebSocket
    if (net === 'ws' && proxy['ws-opts']) {
      vmessData.path = proxy['ws-opts'].path || '/'
      vmessData.host = proxy['ws-opts'].headers?.Host || sniValue || ''
    }
    
    // 处理 HTTP/2
    if (net === 'h2' && proxy['h2-opts']) {
      vmessData.path = proxy['h2-opts'].path || '/'
      vmessData.host = Array.isArray(proxy['h2-opts'].host) 
        ? proxy['h2-opts'].host.join(',') 
        : (proxy['h2-opts'].host || '')
    }
    
    // 处理 gRPC
    if (net === 'grpc' && proxy['grpc-opts']) {
      vmessData.path = proxy['grpc-opts']['grpc-service-name'] || ''
      vmessData.type = 'gun'  // gRPC 的 type
    }
    
    // 处理 ALPN
    if (proxy.alpn) {
      vmessData.alpn = Array.isArray(proxy.alpn) 
        ? proxy.alpn.join(',') 
        : proxy.alpn
    }
    
    // 处理 fingerprint (TLS)
    if (fingerprintValue) {
      vmessData.fp = fingerprintValue
    }
    
    const vmessJson = JSON.stringify(vmessData)
    const vmessB64 = btoa(unescape(encodeURIComponent(vmessJson)))
    return `vmess://${vmessB64}`
  }
  
  // Trojan
  if (proxy.type === 'trojan') {
    const params = new URLSearchParams()
    
    if (sniValue) params.set('sni', sniValue)
    if (proxy.alpn) {
      const alpn = Array.isArray(proxy.alpn) ? proxy.alpn.join(',') : proxy.alpn
      params.set('alpn', alpn)
    }
    if (proxy['skip-cert-verify']) params.set('allowInsecure', '1')
    
    // WebSocket 传输
    if (proxy.network === 'ws' || proxy['ws-opts']) {
      params.set('type', 'ws')
      if (proxy['ws-opts']?.path) params.set('path', proxy['ws-opts'].path)
      if (proxy['ws-opts']?.headers?.Host) params.set('host', proxy['ws-opts'].headers.Host)
    }
    
    // gRPC 传输
    if (proxy.network === 'grpc' || proxy['grpc-opts']) {
      params.set('type', 'grpc')
      if (proxy['grpc-opts']?.['grpc-service-name']) {
        params.set('serviceName', proxy['grpc-opts']['grpc-service-name'])
      }
      if (proxy['grpc-opts']?.mode) {
        params.set('mode', proxy['grpc-opts'].mode)
      }
    }
    
    const query = params.toString() ? `?${params.toString()}` : ''
    return `trojan://${proxy.password}@${proxy.server}:${proxy.port}${query}#${name}`
  }
  
  // VLESS (部分 Clash 版本支持)
  if (proxy.type === 'vless') {
    const params = new URLSearchParams()
    
    params.set('encryption', proxy.cipher || 'none')
    if (proxy.flow) params.set('flow', proxy.flow)
    
    // TLS/Reality 设置
    if (proxy.tls) {
      params.set('security', 'tls')
      if (sniValue) params.set('sni', sniValue)
      if (proxy['skip-cert-verify']) params.set('allowInsecure', '1')
      if (fingerprintValue) params.set('fp', fingerprintValue)
    }
    
    // Reality 协议支持
    if (proxy['reality-opts']) {
      params.set('security', 'reality')
      if (proxy['reality-opts']['server-name'] && !sniValue) {
        params.set('sni', proxy['reality-opts']['server-name'])
      } else if (sniValue) {
        params.set('sni', sniValue)
      }
      if (proxy['reality-opts']['public-key']) {
        params.set('pbk', proxy['reality-opts']['public-key'])
      }
      if (proxy['reality-opts']['short-id']) {
        params.set('sid', proxy['reality-opts']['short-id'])
      }
      if (proxy['reality-opts']['fingerprint']) {
        params.set('fp', proxy['reality-opts']['fingerprint'])
      } else if (fingerprintValue) {
        params.set('fp', fingerprintValue)
      }
      if (proxy['reality-opts'].dest) {
        params.set('dest', proxy['reality-opts'].dest)
      }
      if (proxy['reality-opts'].spiderx || proxy['reality-opts'].spiderX) {
        params.set('spx', proxy['reality-opts'].spiderx || proxy['reality-opts'].spiderX)
      }
    }
    
    // 传输协议
    const network = proxy.network || 'tcp'
    params.set('type', network)
    
    if (network === 'ws' && proxy['ws-opts']) {
      if (proxy['ws-opts'].path) params.set('path', proxy['ws-opts'].path)
      const wsHost = proxy['ws-opts'].headers?.Host || sniValue
      if (wsHost) params.set('host', wsHost)
    }

    // XHTTP (httpupgrade) 传输
    if (network === 'xhttp' && proxy['xhttp-opts']) {
      if (proxy['xhttp-opts'].path) params.set('path', proxy['xhttp-opts'].path)
      const xhHost = proxy['xhttp-opts'].host || sniValue
      if (xhHost) params.set('host', xhHost)
      if (proxy['xhttp-opts'].mode) params.set('mode', proxy['xhttp-opts'].mode)
    }
    
    if (network === 'grpc' && proxy['grpc-opts']) {
      params.set('serviceName', proxy['grpc-opts']['grpc-service-name'] || '')
      if (proxy['grpc-opts'].mode) params.set('mode', proxy['grpc-opts'].mode)
    }
    
    if (network === 'h2' && proxy['h2-opts']) {
      if (proxy['h2-opts'].path) params.set('path', proxy['h2-opts'].path)
      if (proxy['h2-opts'].host) {
        const host = Array.isArray(proxy['h2-opts'].host) 
          ? proxy['h2-opts'].host.join(',') 
          : proxy['h2-opts'].host
        params.set('host', host)
      } else if (sniValue) {
        params.set('host', sniValue)
      }
    }
    
    // ALPN
    if (proxy.alpn) {
      const alpn = Array.isArray(proxy.alpn) ? proxy.alpn.join(',') : proxy.alpn
      params.set('alpn', alpn)
    }
    
    return `vless://${proxy.uuid}@${proxy.server}:${proxy.port}?${params.toString()}#${name}`
  }
  
  // Hysteria (v1)
  if (proxy.type === 'hysteria') {
    const params = new URLSearchParams()
    
    if (proxy.protocol) params.set('protocol', proxy.protocol)
    if (proxy.up) params.set('upmbps', proxy.up)
    if (proxy.down) params.set('downmbps', proxy.down)
    if (proxy.obfs) params.set('obfs', proxy.obfs)
    if (proxy['obfs-password']) params.set('obfsParam', proxy['obfs-password'])
    if (proxy.alpn) {
      const alpn = Array.isArray(proxy.alpn) ? proxy.alpn.join(',') : proxy.alpn
      params.set('alpn', alpn)
    }
    if (proxy['skip-cert-verify']) params.set('insecure', '1')
    if (sniValue) params.set('peer', sniValue)
    
    const auth = proxy.auth || proxy.password || ''
    return `hysteria://${proxy.server}:${proxy.port}?auth=${encodeURIComponent(auth)}&${params.toString()}#${name}`
  }
  
  // Hysteria2
  if (proxy.type === 'hysteria2' || proxy.type === 'hy2') {
    const params = new URLSearchParams()
    
    if (proxy.password) params.set('password', proxy.password)
    if (proxy.obfs) {
      params.set('obfs', proxy.obfs)
      if (proxy['obfs-password']) params.set('obfs-password', proxy['obfs-password'])
    }
    if (sniValue) params.set('sni', sniValue)
    if (proxy['skip-cert-verify']) params.set('insecure', '1')
    if (fingerprintValue) params.set('pinSHA256', fingerprintValue)
    
    return `hysteria2://${proxy.password}@${proxy.server}:${proxy.port}?${params.toString()}#${name}`
  }
  
  console.log(`不支持的协议类型: ${proxy.type}`)
  return null
}

// 增强的 YAML 解析器（支持嵌套对象）
function parseSimpleYAML(yamlText) {
  const config = { proxies: [] }
  const lines = yamlText.split('\n')
  let inProxies = false
  let currentProxy = null
  let currentNested = null
  let nestedKey = null
  
  for (let line of lines) {
    const trimmed = line.trim()
    
    if (trimmed === 'proxies:') {
      inProxies = true
      continue
    }
    
    if (!inProxies) continue
    
    // 检测新的代理节点 (  - name: xxx)
    if (line.match(/^  - name:/)) {
      if (currentProxy) {
        config.proxies.push(currentProxy)
      }
      currentProxy = {}
      currentNested = null
      nestedKey = null
      const match = line.match(/name:\s*(.+)/)
      if (match) currentProxy.name = match[1].replace(/['"]/g, '').trim()
      continue
    }
    
    // 检测嵌套对象开始 (    xxx-opts:) 或数组开始
    if (currentProxy && line.match(/^    [\w-]+:/)) {
      const match = line.match(/^    ([\w-]+):\s*(.*)$/)
      if (match) {
        const key = match[1]
        let value = match[2].trim()
        
        // 如果值为空，表示这是一个嵌套对象或数组的开始
        if (!value || value === '') {
          nestedKey = key
          // 检查下一行是否是数组项（以 - 开头）
          currentNested = {}
          currentProxy[key] = currentNested
        } else {
          // 普通键值对
          value = parseValue(value)
          currentProxy[key] = value
          currentNested = null
          nestedKey = null
        }
      }
      continue
    }
    
    // 处理数组项 (      - value)
    if (currentProxy && line.match(/^      - /)) {
      const match = line.match(/^      - (.+)/)
      if (match && nestedKey) {
        const value = parseValue(match[1])
        // 如果还不是数组，转换为数组
        if (!Array.isArray(currentProxy[nestedKey])) {
          currentProxy[nestedKey] = []
        }
        currentProxy[nestedKey].push(value)
      }
      continue
    }
    
    // 解析嵌套对象的属性 (      key: value)
    if (currentNested && line.match(/^      [\w-]+:/)) {
      const match = line.match(/^      ([\w-]+):\s*(.+)/)
      if (match) {
        const key = match[1]
        let value = parseValue(match[2])
        
        // 特殊处理 headers
        if ((nestedKey === 'ws-opts' || nestedKey === 'h2-opts') && key === 'headers') {
          currentNested.headers = {}
          continue
        }
        
        currentNested[key] = value
      }
      continue
    }
    
    // 解析更深层嵌套 (        Host: xxx)
    if (currentNested && line.match(/^        [\w-]+:/)) {
      const match = line.match(/^        ([\w-]+):\s*(.+)/)
      if (match) {
        const key = match[1]
        const value = parseValue(match[2])
        
        if (currentNested.headers) {
          currentNested.headers[key] = value
        }
      }
      continue
    }
    
    // 检测新的 section（退出 proxies）
    if (inProxies && line.match(/^[\w-]+:/) && !line.match(/^  /)) {
      if (currentProxy) {
        config.proxies.push(currentProxy)
      }
      break
    }
  }
  
  if (currentProxy) {
    config.proxies.push(currentProxy)
  }
  
  return config
}

// 解析 YAML 值
function parseValue(str) {
  // 去掉行内注释（# 之后的内容）
  const noComment = str.split('#')[0]
  let value = noComment.replace(/['"]/g, '').trim()
  
  // 数字
  if (/^\d+$/.test(value)) {
    return parseInt(value)
  }
  // 布尔值
  if (value === 'true') return true
  if (value === 'false') return false
  
  // 数组 [a, b, c]
  if (value.startsWith('[') && value.endsWith(']')) {
    return value.slice(1, -1).split(',').map(v => v.trim())
  }
  
  return value
}

// 生成短ID
function generateShortId() {
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
  let result = ''
  for (let i = 0; i < 8; i++) {
    result += chars.charAt(Math.floor(Math.random() * chars.length))
  }
  return result
}

// 获取订阅列表
async function getSubscriptionList() {
  if (typeof SUBSCRIPTION_KV === 'undefined') return []
  const data = await SUBSCRIPTION_KV.get('subscriptions:list')
  return data ? JSON.parse(data) : []
}

// 添加到订阅列表
async function addToSubscriptionList(subscriptionId) {
  if (typeof SUBSCRIPTION_KV === 'undefined') return
  const list = await getSubscriptionList()
  if (!list.includes(subscriptionId)) {
    list.push(subscriptionId)
    await SUBSCRIPTION_KV.put('subscriptions:list', JSON.stringify(list))
  }
}

// 从订阅列表中移除
async function removeFromSubscriptionList(subscriptionId) {
  if (typeof SUBSCRIPTION_KV === 'undefined') return
  const list = await getSubscriptionList()
  const newList = list.filter(id => id !== subscriptionId)
  await SUBSCRIPTION_KV.put('subscriptions:list', JSON.stringify(newList))
}

function getAdminToken() {
  if (typeof ADMIN_TOKEN === 'undefined') return null
  return ADMIN_TOKEN || null
}

function jsonResponse(data, status = 200) {
  return new Response(JSON.stringify(data), {
    status,
    headers: { 'Content-Type': 'application/json' }
  })
}

function getHTML() {
  return `<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>订阅管理中心</title>
    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
    <style>
        :root {
            --primary: #6366f1;
            --primary-hover: #4f46e5;
            --primary-light: #e0e7ff;
            --secondary: #ec4899;
            --accent: #0ea5e9;
            --success: #10b981;
            --warning: #f59e0b;
            --danger: #ef4444;
            --bg-body: #f3f4f6;
            --bg-card: #ffffff;
            --bg-sidebar: #f9fafb;
            --text-main: #111827;
            --text-sub: #6b7280;
            --border: #e5e7eb;
            --shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
            --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
            --shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
            --radius: 16px;
        }

        * { margin: 0; padding: 0; box-sizing: border-box; }
        
        body {
            font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
            background-color: var(--bg-body);
            color: var(--text-main);
            height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            padding: 20px;
        }

        .app-container {
            width: 100%;
            max-width: 1200px;
            height: 90vh;
            background: var(--bg-card);
            border-radius: var(--radius);
            box-shadow: var(--shadow-lg);
            display: flex;
            overflow: hidden;
            border: 1px solid var(--border);
        }

        /* Sidebar */
        .sidebar {
            width: 320px;
            background: var(--bg-sidebar);
            border-right: 1px solid var(--border);
            display: flex;
            flex-direction: column;
            flex-shrink: 0;
        }

        .sidebar-header {
            padding: 24px;
            border-bottom: 1px solid var(--border);
        }

        .app-title {
            font-size: 20px;
            font-weight: 800;
            background: linear-gradient(135deg, var(--primary) 0%, var(--secondary) 100%);
            -webkit-background-clip: text;
            -webkit-text-fill-color: transparent;
            margin-bottom: 4px;
            display: flex;
            align-items: center;
            gap: 8px;
        }

        .app-subtitle {
            font-size: 12px;
            color: var(--text-sub);
            font-weight: 500;
        }

        .sidebar-actions {
            padding: 16px 24px 0;
            display: flex;
            gap: 10px;
        }

        .btn-add {
            flex: 1;
            background: var(--primary);
            color: white;
            border: none;
            padding: 10px;
            border-radius: 10px;
            font-weight: 600;
            cursor: pointer;
            transition: all 0.2s;
            display: flex;
            align-items: center;
            justify-content: center;
            gap: 6px;
            box-shadow: 0 2px 4px rgba(99, 102, 241, 0.3);
        }

        .btn-add:hover {
            background: var(--primary-hover);
            transform: translateY(-1px);
        }

        .btn-icon {
            width: 36px;
            height: 36px;
            border-radius: 10px;
            border: 1px solid var(--border);
            background: white;
            color: var(--text-sub);
            cursor: pointer;
            display: flex;
            align-items: center;
            justify-content: center;
            transition: all 0.2s;
        }

        .btn-icon:hover {
            background: #f3f4f6;
            color: var(--text-main);
        }

        .subscription-list {
            flex: 1;
            overflow-y: auto;
            padding: 16px;
            display: flex;
            flex-direction: column;
            gap: 8px;
        }

        .sub-item {
            padding: 16px;
            background: white;
            border: 1px solid transparent;
            border-radius: 12px;
            cursor: pointer;
            transition: all 0.2s;
            position: relative;
            overflow: hidden;
        }

        .sub-item:hover {
            background: white;
            border-color: var(--primary-light);
            box-shadow: var(--shadow-sm);
            transform: translateY(-1px);
        }

        .sub-item.active {
            background: #f5f7ff;
            border-color: var(--primary);
            box-shadow: var(--shadow-md);
        }

        .sub-item.active::before {
            content: '';
            position: absolute;
            left: 0;
            top: 0;
            bottom: 0;
            width: 4px;
            background: var(--primary);
        }

        .sub-header {
            display: flex;
            justify-content: space-between;
            align-items: center;
            margin-bottom: 6px;
        }

        .sub-name {
            font-weight: 600;
            font-size: 14px;
            color: var(--text-main);
            white-space: nowrap;
            overflow: hidden;
            text-overflow: ellipsis;
        }

        .sub-badges {
            display: flex;
            gap: 4px;
        }

        .badge {
            font-size: 10px;
            padding: 2px 6px;
            border-radius: 4px;
            font-weight: 600;
            text-transform: uppercase;
        }

        .badge-clash { background: #e0f2fe; color: #0369a1; }
        .badge-v2ray { background: #f0fdf4; color: #15803d; }
        .badge-temp { background: #fffbeb; color: #b45309; }
        .badge-perm { background: #f3f4f6; color: #4b5563; }
        .badge-expired { background: #fef2f2; color: #b91c1c; }
        .badge-expiring { background: #fff7ed; color: #c2410c; }

        .sub-info {
            font-size: 11px;
            color: var(--text-sub);
            display: flex;
            justify-content: space-between;
            align-items: center;
        }

        /* Main Content */
        .main-content {
            flex: 1;
            background: var(--bg-card);
            display: flex;
            flex-direction: column;
            overflow-y: auto;
        }

        .empty-state {
            height: 100%;
            display: flex;
            flex-direction: column;
            align-items: center;
            justify-content: center;
            color: var(--text-sub);
        }

        .empty-icon {
            font-size: 64px;
            margin-bottom: 16px;
            opacity: 0.5;
        }

        .detail-view {
            padding: 40px;
            max-width: 800px;
            margin: 0 auto;
            width: 100%;
        }

        .detail-header {
            display: flex;
            justify-content: space-between;
            align-items: flex-start;
            margin-bottom: 32px;
        }

        .detail-title-group h2 {
            font-size: 28px;
            font-weight: 700;
            color: var(--text-main);
            margin-bottom: 8px;
        }

        .detail-meta {
            display: flex;
            gap: 12px;
            align-items: center;
        }

        .detail-actions {
            display: flex;
            gap: 8px;
        }

        .btn-action {
            padding: 8px 16px;
            border-radius: 8px;
            font-size: 13px;
            font-weight: 500;
            cursor: pointer;
            border: 1px solid var(--border);
            background: white;
            color: var(--text-main);
            transition: all 0.2s;
        }

        .btn-action:hover {
            background: #f9fafb;
            border-color: #d1d5db;
        }

        .btn-danger {
            color: var(--danger);
            border-color: #fecaca;
            background: #fef2f2;
        }

        .btn-danger:hover {
            background: #fee2e2;
            border-color: #fca5a5;
        }

        .card {
            background: white;
            border: 1px solid var(--border);
            border-radius: 12px;
            padding: 24px;
            margin-bottom: 24px;
            box-shadow: var(--shadow-sm);
        }

        .card-title {
            font-size: 16px;
            font-weight: 600;
            margin-bottom: 16px;
            color: var(--text-main);
            display: flex;
            align-items: center;
            gap: 8px;
        }

        .info-grid {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
            gap: 20px;
        }

        .info-item label {
            display: block;
            font-size: 12px;
            color: var(--text-sub);
            margin-bottom: 4px;
        }

        .info-item div {
            font-size: 14px;
            font-weight: 500;
            color: var(--text-main);
        }

        .link-tabs {
            display: flex;
            gap: 4px;
            background: #f3f4f6;
            padding: 4px;
            border-radius: 10px;
            margin-bottom: 16px;
            width: fit-content;
        }

        .tab-btn {
            padding: 8px 20px;
            border-radius: 8px;
            border: none;
            background: transparent;
            color: var(--text-sub);
            font-size: 13px;
            font-weight: 500;
            cursor: pointer;
            transition: all 0.2s;
        }

        .tab-btn.active {
            background: white;
            color: var(--primary);
            box-shadow: var(--shadow-sm);
            font-weight: 600;
        }

        .url-container {
            position: relative;
            margin-bottom: 16px;
        }

        .url-input {
            width: 100%;
            padding: 14px 100px 14px 16px;
            background: #f9fafb;
            border: 1px solid var(--border);
            border-radius: 10px;
            font-family: 'Monaco', 'Consolas', monospace;
            font-size: 13px;
            color: var(--text-main);
            outline: none;
            transition: all 0.2s;
        }

        .url-input:focus {
            border-color: var(--primary);
            background: white;
            box-shadow: 0 0 0 3px var(--primary-light);
        }

        .btn-copy {
            position: absolute;
            right: 8px;
            top: 50%;
            transform: translateY(-50%);
            background: white;
            border: 1px solid var(--border);
            padding: 6px 12px;
            border-radius: 6px;
            font-size: 12px;
            font-weight: 600;
            color: var(--text-main);
            cursor: pointer;
            transition: all 0.2s;
        }

        .btn-copy:hover {
            border-color: var(--primary);
            color: var(--primary);
        }

        .link-actions {
            display: flex;
            gap: 12px;
            align-items: center;
        }

        .progress-wrapper {
            flex: 1;
            background: #f3f4f6;
            height: 8px;
            border-radius: 4px;
            overflow: hidden;
            position: relative;
        }

        .progress-bar {
            height: 100%;
            background: var(--success);
            border-radius: 4px;
            transition: width 0.5s ease;
        }

        .progress-text {
            font-size: 12px;
            color: var(--text-sub);
            min-width: 80px;
            text-align: right;
        }

        /* Modals */
        .modal {
            display: none;
            position: fixed;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            background: rgba(0, 0, 0, 0.4);
            backdrop-filter: blur(4px);
            z-index: 1000;
            align-items: center;
            justify-content: center;
        }

        .modal.active { display: flex; }

        .modal-content {
            background: white;
            border-radius: 20px;
            padding: 32px;
            width: 90%;
            max-width: 480px;
            box-shadow: var(--shadow-lg);
            animation: modalSlide 0.3s ease;
        }

        @keyframes modalSlide {
            from { transform: translateY(20px); opacity: 0; }
            to { transform: translateY(0); opacity: 1; }
        }

        .modal-header {
            font-size: 20px;
            font-weight: 700;
            margin-bottom: 24px;
            color: var(--text-main);
        }

        .form-group { margin-bottom: 20px; }

        .form-label {
            display: block;
            font-size: 13px;
            font-weight: 500;
            color: var(--text-main);
            margin-bottom: 8px;
        }

        .form-input, .form-select {
            width: 100%;
            padding: 12px;
            border: 1px solid var(--border);
            border-radius: 10px;
            font-size: 14px;
            outline: none;
            transition: all 0.2s;
        }

        .form-input:focus, .form-select:focus {
            border-color: var(--primary);
            box-shadow: 0 0 0 3px var(--primary-light);
        }

        .form-hint {
            font-size: 12px;
            color: var(--text-sub);
            margin-top: 6px;
        }

        .modal-footer {
            display: flex;
            gap: 12px;
            margin-top: 32px;
        }

        .btn-primary {
            flex: 1;
            background: var(--primary);
            color: white;
            border: none;
            padding: 12px;
            border-radius: 10px;
            font-weight: 600;
            cursor: pointer;
            transition: all 0.2s;
        }

        .btn-primary:hover { background: var(--primary-hover); }

        .btn-secondary {
            flex: 1;
            background: white;
            color: var(--text-main);
            border: 1px solid var(--border);
            padding: 12px;
            border-radius: 10px;
            font-weight: 600;
            cursor: pointer;
            transition: all 0.2s;
        }

        .btn-secondary:hover { background: #f9fafb; }

        /* Scrollbar */
        ::-webkit-scrollbar { width: 6px; }
        ::-webkit-scrollbar-track { background: transparent; }
        ::-webkit-scrollbar-thumb { background: #d1d5db; border-radius: 3px; }
        ::-webkit-scrollbar-thumb:hover { background: #9ca3af; }
    </style>
</head>
<body>
    <div class="app-container">
        <!-- Sidebar -->
        <div class="sidebar">
            <div class="sidebar-header">
                <div class="app-title">
                    <span>⚡️ 订阅中心</span>
                </div>
                <div class="app-subtitle">智能转换 · 灵活管理</div>
            </div>
            
            <div class="sidebar-actions">
                <button class="btn-add" onclick="showAddModal()">
                    <span>+</span> 新建订阅
                </button>
                <button class="btn-icon" onclick="clearAllSubscriptions()" title="清空所有">
                    🗑️
                </button>
            </div>

            <div id="subscriptionList" class="subscription-list">
                <!-- List items will be injected here -->
            </div>
        </div>

        <!-- Main Content -->
        <div class="main-content">
            <div id="emptyState" class="empty-state">
                <div class="empty-icon">📡</div>
                <h3>选择一个订阅</h3>
                <p>查看详情或生成转换链接</p>
            </div>

            <div id="detailView" class="detail-view" style="display: none;">
                <div class="detail-header">
                    <div class="detail-title-group">
                        <h2 id="detailTitle">订阅名称</h2>
                        <div class="detail-meta">
                            <span id="detailTypeBadge" class="badge"></span>
                            <span id="detailModeBadge" class="badge"></span>
                        </div>
                    </div>
                    <div class="detail-actions">
                        <button class="btn-action" onclick="editSubscription()">✏️ 编辑</button>
                        <button class="btn-action btn-danger" onclick="deleteCurrentSubscription()">🗑️ 删除</button>
                    </div>
                </div>

                <div class="card">
                    <div class="card-title">📝 基本信息</div>
                    <div class="info-grid">
                        <div class="info-item">
                            <label>源格式</label>
                            <div id="detailSourceType">-</div>
                        </div>
                        <div class="info-item">
                            <label>创建时间</label>
                            <div id="detailCreatedAt">-</div>
                        </div>
                        <div class="info-item">
                            <label>有效期至</label>
                            <div id="detailExpiration">-</div>
                        </div>
                        <div class="info-item" style="grid-column: 1 / -1;">
                            <label>原始链接</label>
                            <div id="detailOriginalUrl" style="font-family: monospace; font-size: 12px; word-break: break-all; color: var(--text-sub); background: #f9fafb; padding: 8px; border-radius: 6px;">-</div>
                        </div>
                    </div>
                </div>

                <div class="card">
                    <div class="card-title">🔗 转换链接</div>
                    
                    <div class="link-tabs">
                        <button class="tab-btn active" data-type="clash" onclick="switchLinkType('clash')">Clash</button>
                        <button class="tab-btn" data-type="v2ray" onclick="switchLinkType('v2ray')">V2Ray</button>
                    </div>

                    <div class="url-container">
                        <input type="text" id="detailShortUrl" class="url-input" readonly placeholder="生成中...">
                        <button class="btn-copy" onclick="copyShortUrl(event)">复制</button>
                    </div>

                    <div class="link-actions">
                        <div class="progress-wrapper">
                            <div id="linkProgressBar" class="progress-bar" style="width: 0%"></div>
                        </div>
                        <div id="linkProgressText" class="progress-text">--</div>
                        <button class="btn-action" style="color: var(--primary); border-color: var(--primary-light);" onclick="renewSubscription()">🔄 续期</button>
                        <button class="btn-action" onclick="regenerateShortUrl()">⚡️ 换新</button>
                    </div>
                </div>
            </div>
        </div>
    </div>

    <!-- Add/Edit Modal -->
    <div id="subscriptionModal" class="modal">
        <div class="modal-content">
            <div class="modal-header" id="modalTitle">新建订阅</div>
            
            <div class="form-group">
                <label class="form-label">订阅名称</label>
                <input type="text" id="subName" class="form-input" placeholder="例如：我的主力节点">
            </div>
            
            <div class="form-group">
                <label class="form-label">订阅链接</label>
                <input type="url" id="subClashUrl" class="form-input" placeholder="https://...">
                <div class="form-hint">支持 Clash 或 V2Ray 链接，系统自动识别</div>
            </div>
            
            <div class="form-group">
                <label class="form-label">订阅模式</label>
                <select id="subMode" class="form-select" onchange="onSubscriptionModeChange()">
                    <option value="permanent">正式订阅 (长期)</option>
                    <option value="temporary">临时订阅 (短期)</option>
                </select>
            </div>
            
            <div class="form-group">
                <label class="form-label">短链有效期</label>
                <div id="permanentExpiration">
                    <select id="subPermanentExpiration" class="form-select">
                        <option value="7d">7天</option>
                        <option value="1m">1个月</option>
                        <option value="3m">3个月</option>
                        <option value="1y" selected>1年</option>
                        <option value="3y">3年</option>
                        <option value="unlimited">长期</option>
                    </select>
                </div>
                <div id="temporaryExpiration" style="display: none;">
                    <select id="subTempExpiration" class="form-select">
                        <option value="1d">1天</option>
                        <option value="3d" selected>3天</option>
                        <option value="7d">7天</option>
                    </select>
                </div>
            </div>
            
            <div class="modal-footer">
                <button class="btn-secondary" onclick="closeModal()">取消</button>
                <button class="btn-primary" onclick="saveSubscription()">保存订阅</button>
            </div>
        </div>
    </div>

    <!-- Renew Modal -->
    <div id="renewModal" class="modal">
        <div class="modal-content">
            <div class="modal-header" id="renewModalTitle">续期订阅</div>
            
            <div class="form-group">
                <label class="form-label">选择新的有效期</label>
                <div id="renewPermanentExpiration">
                    <select id="renewPermanentExp" class="form-select">
                        <option value="7d">7天</option>
                        <option value="1m">1个月</option>
                        <option value="3m">3个月</option>
                        <option value="1y" selected>1年</option>
                        <option value="3y">3年</option>
                        <option value="unlimited">长期</option>
                    </select>
                </div>
                <div id="renewTemporaryExpiration" style="display: none;">
                    <select id="renewTempExpiration" class="form-select">
                        <option value="1d">1天</option>
                        <option value="3d" selected>3天</option>
                        <option value="7d">7天</option>
                    </select>
                </div>
            </div>
            
            <div class="modal-footer">
                <button class="btn-secondary" onclick="closeRenewModal()">取消</button>
                <button class="btn-primary" onclick="confirmRenew()">确认执行</button>
            </div>
        </div>
    </div>

    <!-- Custom Alert Modal -->
    <div id="customAlertModal" class="modal">
        <div class="modal-content" style="max-width: 400px;">
            <div class="modal-header" id="customAlertTitle">提示</div>
            <div id="customAlertMessage" style="color: var(--text-main); font-size: 14px; line-height: 1.6; margin-bottom: 24px;"></div>
            <div class="modal-footer" style="justify-content: flex-end;">
                <button class="btn-primary" style="flex: none; min-width: 100px;" onclick="closeCustomAlert()">确定</button>
            </div>
        </div>
    </div>

    <!-- Custom Confirm Modal -->
    <div id="customConfirmModal" class="modal">
        <div class="modal-content" style="max-width: 400px;">
            <div class="modal-header" id="customConfirmTitle">确认</div>
            <div id="customConfirmMessage" style="color: var(--text-main); font-size: 14px; line-height: 1.6; margin-bottom: 24px;"></div>
            <div class="modal-footer">
                <button class="btn-secondary" onclick="closeCustomConfirm()">取消</button>
                <button class="btn-primary" id="customConfirmBtn" onclick="executeCustomConfirm()">确定</button>
            </div>
        </div>
    </div>

    <script>
        let currentEditId = null;
        let currentRenewId = null;
        let currentRenewAction = 'renew';
        let currentSelectedId = null;
        let allSubscriptions = [];
        let currentLinkType = 'clash';
        let confirmCallback = null;

        window.onload = loadSubscriptions;

        // --- Custom Dialog Functions ---
        function showCustomAlert(message, title = '提示') {
            document.getElementById('customAlertTitle').textContent = title;
            document.getElementById('customAlertMessage').textContent = message;
            document.getElementById('customAlertModal').classList.add('active');
        }

        function closeCustomAlert() {
            document.getElementById('customAlertModal').classList.remove('active');
        }

        function showCustomConfirm(message, callback, title = '确认') {
            document.getElementById('customConfirmTitle').textContent = title;
            document.getElementById('customConfirmMessage').textContent = message;
            confirmCallback = callback;
            document.getElementById('customConfirmModal').classList.add('active');
        }

        function closeCustomConfirm() {
            document.getElementById('customConfirmModal').classList.remove('active');
            confirmCallback = null;
        }

        function executeCustomConfirm() {
            document.getElementById('customConfirmModal').classList.remove('active');
            if (confirmCallback && typeof confirmCallback === 'function') {
                confirmCallback();
            }
            confirmCallback = null;
        }

        // --- UI Logic ---
        function onSubscriptionModeChange() {
            const mode = document.getElementById('subMode').value;
            const permExp = document.getElementById('permanentExpiration');
            const tempExp = document.getElementById('temporaryExpiration');
            
            if (mode === 'temporary') {
                permExp.style.display = 'none';
                tempExp.style.display = 'block';
            } else {
                permExp.style.display = 'block';
                tempExp.style.display = 'none';
            }
        }

        // --- Data Logic ---
        async function loadSubscriptions() {
            try {
                const res = await fetch('/api/subscriptions');
                const data = await res.json();
                allSubscriptions = data.subscriptions || [];
                renderList();
                
                if (allSubscriptions.length > 0 && !currentSelectedId) {
                    selectSubscription(allSubscriptions[0].id);
                } else if (allSubscriptions.length === 0) {
                    showEmptyState();
                }
            } catch (e) {
                console.error(e);
            }
        }

        function renderList() {
            const container = document.getElementById('subscriptionList');
            if (allSubscriptions.length === 0) {
                container.innerHTML = '<div style="text-align:center; padding:20px; color:#9ca3af; font-size:13px;">暂无订阅</div>';
                return;
            }

            container.innerHTML = allSubscriptions.map(sub => {
                const activeClass = sub.id === currentSelectedId ? 'active' : '';
                const typeBadge = sub.subscriptionType === 'v2ray' ? 'badge-v2ray' : 'badge-clash';
                const typeText = sub.subscriptionType === 'v2ray' ? 'V2Ray' : 'Clash';
                const modeBadge = sub.subscriptionMode === 'temporary' ? 'badge-temp' : 'badge-perm';
                const modeText = sub.subscriptionMode === 'temporary' ? '临时' : '正式';
                
                // 计算状态标记（仅对长期订阅显示快过期/已过期）
                let statusBadge = '';
                if (sub.subscriptionMode === 'permanent' && sub.expiresAt) {
                    const now = Date.now();
                    const daysRemaining = (sub.expiresAt - now) / (1000 * 60 * 60 * 24);
                    if (sub.isExpired || daysRemaining <= 0) {
                        statusBadge = '<span class="badge badge-expired">已过期</span>';
                    } else if (daysRemaining <= 15) {
                        statusBadge = '<span class="badge badge-expiring">快过期</span>';
                    }
                }
                
                return \`<div class="sub-item \${activeClass}" onclick="selectSubscription('\${sub.id}')">
                    <div class="sub-header">
                        <div class="sub-name">\${escapeHtml(sub.name)}</div>
                        <div class="sub-badges">
                            <span class="badge \${typeBadge}">\${typeText}</span>
                            \${statusBadge}
                        </div>
                    </div>
                    <div class="sub-info">
                        <span class="badge \${modeBadge}" style="font-weight:normal; padding:1px 4px;">\${modeText}</span>
                        <span>\${sub.isExpired ? '<span style="color:var(--danger)">已过期</span>' : (sub.expiresAt ? formatDateSimple(sub.expiresAt) : '无限期')}</span>
                    </div>
                </div>\`;
            }).join('');
        }

        function selectSubscription(id) {
            currentSelectedId = id;
            renderList(); // Update active state
            
            const sub = allSubscriptions.find(s => s.id === id);
            if (!sub) return;

            document.getElementById('emptyState').style.display = 'none';
            document.getElementById('detailView').style.display = 'block';

            // Fill Info
            document.getElementById('detailTitle').textContent = sub.name;
            
            const typeText = sub.subscriptionType === 'v2ray' ? 'V2Ray' : 'Clash';
            const typeClass = sub.subscriptionType === 'v2ray' ? 'badge-v2ray' : 'badge-clash';
            const modeText = sub.subscriptionMode === 'temporary' ? '临时订阅' : '正式订阅';
            const modeClass = sub.subscriptionMode === 'temporary' ? 'badge-temp' : 'badge-perm';

            const typeBadge = document.getElementById('detailTypeBadge');
            typeBadge.className = 'badge ' + typeClass;
            typeBadge.textContent = typeText;

            const modeBadge = document.getElementById('detailModeBadge');
            modeBadge.className = 'badge ' + modeClass;
            modeBadge.textContent = modeText;

            document.getElementById('detailSourceType').textContent = typeText;
            document.getElementById('detailCreatedAt').textContent = formatDate(sub.createdAt);
            document.getElementById('detailExpiration').textContent = sub.expiresAt ? formatDate(sub.expiresAt) : '无限期';
            document.getElementById('detailOriginalUrl').textContent = sub.clashUrl;

            // Set default tab based on source type preference, or stick to current if valid
            // Logic: if source is v2ray, default to v2ray tab, else clash
            const defaultType = sub.subscriptionType === 'v2ray' ? 'v2ray' : 'clash';
            switchLinkType(defaultType);
        }

        function showEmptyState() {
            document.getElementById('emptyState').style.display = 'flex';
            document.getElementById('detailView').style.display = 'none';
            currentSelectedId = null;
        }

        async function switchLinkType(type) {
            if (!currentSelectedId) return;
            currentLinkType = type;
            
            // Update Tabs
            document.querySelectorAll('.tab-btn').forEach(btn => {
                btn.classList.toggle('active', btn.dataset.type === type);
            });

            const sub = allSubscriptions.find(s => s.id === currentSelectedId);
            if (!sub) return;

            const shortId = sub.shortIds && sub.shortIds[type];
            const expiry = sub.shortIdsExpiry && sub.shortIdsExpiry[type];

            if (shortId) {
                document.getElementById('detailShortUrl').value = window.location.origin + '/s/' + shortId;
                updateLinkStatus(expiry);
            } else {
                // Auto generate if missing
                generateLink(type);
            }
        }

        async function generateLink(type) {
            const sub = allSubscriptions.find(s => s.id === currentSelectedId);
            
            if (!sub) {
                document.getElementById('detailShortUrl').value = '订阅不存在';
                return;
            }
            
            document.getElementById('detailShortUrl').value = '正在生成链接...';
            document.getElementById('linkProgressBar').style.width = '100%';
            document.getElementById('linkProgressBar').style.background = 'var(--warning)';
            document.getElementById('linkProgressText').textContent = '生成中';

            try {
                const res = await fetch('/api/subscriptions/' + currentSelectedId + '/renew', {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({ 
                        expiration: sub.expiration || '7d',
                        linkType: type
                    })
                });
                
                if (!res.ok) throw new Error('Failed');
                
                const data = await res.json();
                document.getElementById('detailShortUrl').value = data.shortUrl;
                
                // Refresh data
                await loadSubscriptions();
                const updatedSub = allSubscriptions.find(s => s.id === currentSelectedId);
                if (updatedSub) {
                    updateLinkStatus(updatedSub.shortIdsExpiry[type]);
                }
            } catch (e) {
                document.getElementById('detailShortUrl').value = '生成失败';
                document.getElementById('linkProgressBar').style.background = 'var(--danger)';
            }
        }

        function updateLinkStatus(expiry) {
            const bar = document.getElementById('linkProgressBar');
            const text = document.getElementById('linkProgressText');
            
            if (!expiry) {
                bar.style.width = '100%';
                bar.style.background = 'var(--success)';
                text.textContent = '永久有效';
                return;
            }

            const now = Date.now();
            const remaining = expiry - now;
            
            if (remaining <= 0) {
                bar.style.width = '0%';
                bar.style.background = 'var(--danger)';
                text.textContent = '已过期';
                return;
            }

            const days = Math.ceil(remaining / (86400000));
            const total = 7 * 86400000; // Assume 7 days base for visual
            const pct = Math.min(100, (remaining / total) * 100);
            
            bar.style.width = pct + '%';
            bar.style.background = pct < 20 ? 'var(--danger)' : (pct < 50 ? 'var(--warning)' : 'var(--success)');
            
            if (days > 1) text.textContent = \`剩余 \${days} 天\`;
            else {
                const hours = Math.ceil(remaining / 3600000);
                text.textContent = \`剩余 \${hours} 小时\`;
            }
        }

        // --- Actions ---
        function showAddModal() {
            document.getElementById('modalTitle').textContent = '新建订阅';
            document.getElementById('subName').value = '';
            document.getElementById('subClashUrl').value = '';
            document.getElementById('subMode').value = 'permanent';
            onSubscriptionModeChange();
            currentEditId = null;
            document.getElementById('subscriptionModal').classList.add('active');
        }

        async function editSubscription() {
            if (!currentSelectedId) return;
            const sub = allSubscriptions.find(s => s.id === currentSelectedId);
            
            document.getElementById('modalTitle').textContent = '编辑订阅';
            document.getElementById('subName').value = sub.name;
            document.getElementById('subClashUrl').value = sub.clashUrl;
            document.getElementById('subMode').value = sub.subscriptionMode || 'permanent';
            
            // Restore expiration UI state
            if (sub.subscriptionMode === 'temporary') {
                document.getElementById('subTempExpiration').value = sub.expiration || '3d';
            } else {
                // 设置永久订阅的有效期下拉框
                const expSelect = document.getElementById('subPermanentExpiration');
                const exp = sub.expiration || '7d';
                // 检查是否是预设选项
                const options = Array.from(expSelect.options).map(o => o.value);
                if (options.includes(exp)) {
                    expSelect.value = exp;
                } else {
                    expSelect.value = '7d'; // 默认值
                }
            }
            onSubscriptionModeChange();
            
            currentEditId = currentSelectedId;
            document.getElementById('subscriptionModal').classList.add('active');
        }

        async function saveSubscription() {
            const name = document.getElementById('subName').value.trim();
            const url = document.getElementById('subClashUrl').value.trim();
            const mode = document.getElementById('subMode').value;
            
            let expiration;
            if (mode === 'temporary') {
                expiration = document.getElementById('subTempExpiration').value;
            } else {
                expiration = document.getElementById('subPermanentExpiration').value;
            }

            if (!name || !url) {
                showCustomAlert('请填写完整信息');
                return;
            }

            const endpoint = currentEditId ? '/api/subscriptions/' + currentEditId : '/api/subscriptions';
            const method = currentEditId ? 'PUT' : 'POST';

            try {
                const res = await fetch(endpoint, {
                    method,
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({ name, clashUrl: url, expiration, subscriptionMode: mode })
                });
                
                const data = await res.json();
                
                if (!res.ok) throw new Error(data.error || 'Failed');
                
                closeModal();
                
                // 新建订阅时，设置 currentSelectedId 避免 loadSubscriptions 自动选中触发重复生成
                const newSubId = !currentEditId && data.subscription ? data.subscription.id : null;
                if (newSubId) {
                    currentSelectedId = newSubId;
                }
                
                await loadSubscriptions();
                
                // 新建订阅时选中它（此时 loadSubscriptions 不会重复调用 selectSubscription）
                if (newSubId) {
                    selectSubscription(newSubId);
                }
            } catch (e) {
                showCustomAlert('保存失败: ' + e.message);
            }
        }

        async function deleteCurrentSubscription() {
            showCustomConfirm('确定要删除此订阅吗？', async () => {
                try {
                    await fetch('/api/subscriptions/' + currentSelectedId, { method: 'DELETE' });
                    currentSelectedId = null;
                    await loadSubscriptions();
                } catch (e) {
                    showCustomAlert('删除失败');
                }
            });
        }

        async function clearAllSubscriptions() {
            showCustomConfirm('⚠️ 警告：这将清空所有订阅数据，此操作不可恢复！确定继续？', async () => {
                try {
                    const res = await fetch('/api/subscriptions/clear-all', { method: 'POST' });
                    const data = await res.json();
                    console.log('Clear all response:', res.status, data);
                    if (res.ok) {
                        currentSelectedId = null;
                        allSubscriptions = [];
                        renderList();
                        showEmptyState();
                        showCustomAlert(data.message || '已清空所有数据');
                    } else {
                        showCustomAlert('清空失败: ' + (data.error || '未知错误'));
                    }
                } catch (e) {
                    console.error('Clear all error:', e);
                    showCustomAlert('清空失败: ' + e.message);
                }
            });
        }

        // --- Renew/Regenerate ---
        function renewSubscription() {
            openRenewModal('renew');
        }

        function regenerateShortUrl() {
            openRenewModal('regenerate');
        }

        function openRenewModal(action) {
            currentRenewAction = action;
            currentRenewId = currentSelectedId;
            const sub = allSubscriptions.find(s => s.id === currentSelectedId);
            
            if (!sub) {
                showCustomAlert('请先选择一个订阅');
                return;
            }
            
            document.getElementById('renewModalTitle').textContent = action === 'renew' ? '续期链接' : '更换新链接';
            
            if (sub.subscriptionMode === 'temporary') {
                document.getElementById('renewPermanentExpiration').style.display = 'none';
                document.getElementById('renewTemporaryExpiration').style.display = 'block';
            } else {
                document.getElementById('renewPermanentExpiration').style.display = 'block';
                document.getElementById('renewTemporaryExpiration').style.display = 'none';
            }
            
            document.getElementById('renewModal').classList.add('active');
        }

        async function confirmRenew() {
            const sub = allSubscriptions.find(s => s.id === currentRenewId);
            
            if (!sub) {
                showCustomAlert('订阅不存在');
                closeRenewModal();
                return;
            }
            
            let expiration;
            
            if (sub.subscriptionMode === 'temporary') {
                expiration = document.getElementById('renewTempExpiration').value;
            } else {
                expiration = document.getElementById('renewPermanentExp').value;
            }

            const endpoint = \`/api/subscriptions/\${currentRenewId}/\${currentRenewAction}\`;
            
            try {
                const res = await fetch(endpoint, {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({ expiration, linkType: currentLinkType })
                });
                
                if (!res.ok) throw new Error('Failed');
                
                closeRenewModal();
                await loadSubscriptions();
                
                // Refresh view
                const updatedSub = allSubscriptions.find(s => s.id === currentRenewId);
                if (updatedSub) {
                    const shortId = updatedSub.shortIds[currentLinkType];
                    document.getElementById('detailShortUrl').value = window.location.origin + '/s/' + shortId;
                    updateLinkStatus(updatedSub.shortIdsExpiry[currentLinkType]);
                }
            } catch (e) {
                showCustomAlert('操作失败');
            }
        }

        // --- Utils ---
        function closeModal() { document.getElementById('subscriptionModal').classList.remove('active'); }
        function closeRenewModal() { document.getElementById('renewModal').classList.remove('active'); }
        
        function copyShortUrl(e) {
            const input = document.getElementById('detailShortUrl');
            input.select();
            document.execCommand('copy');
            
            const btn = e.target;
            const original = btn.textContent;
            btn.textContent = '已复制';
            btn.style.color = 'var(--success)';
            setTimeout(() => {
                btn.textContent = original;
                btn.style.color = '';
            }, 2000);
        }

        function escapeHtml(text) {
            const div = document.createElement('div');
            div.textContent = text;
            return div.innerHTML;
        }

        function formatDate(ts) {
            return new Date(ts).toLocaleString('zh-CN', { hour12: false });
        }
        
        function formatDateSimple(ts) {
            const d = new Date(ts);
            return \`\${d.getMonth()+1}-\${d.getDate()} \${d.getHours()}:\${d.getMinutes().toString().padStart(2,'0')}\`;
        }

        window.onclick = function(event) {
            if (event.target.classList.contains('modal')) {
                event.target.classList.remove('active');
            }
        }
    </script>
</body>
</html>
`
}

function getAdminHTML() {
  return `<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>短链管理</title>
  <style>
    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif; background: #f5f7fb; margin: 0; padding: 20px; }
    .card { background: white; border-radius: 12px; box-shadow: 0 10px 30px rgba(0,0,0,0.08); padding: 24px; max-width: 960px; margin: 0 auto; }
    h1 { margin: 0 0 8px 0; font-size: 22px; color: #222; }
    .sub { color: #666; margin-bottom: 18px; font-size: 14px; }
    .status { padding: 10px 12px; border-radius: 8px; margin-bottom: 14px; display: none; font-size: 14px; }
    .status.success { background: #e6ffed; color: #1b7f3f; border: 1px solid #b7f5c6; }
    .status.error { background: #ffeaea; color: #b42318; border: 1px solid #f5c2c0; }
    .status.info { background: #e7f3ff; color: #0d4ea6; border: 1px solid #c3defc; }
    table { width: 100%; border-collapse: collapse; margin-top: 12px; }
    th, td { padding: 10px 8px; text-align: left; border-bottom: 1px solid #eef1f6; font-size: 13px; color: #333; }
    th { background: #fafbff; font-weight: 600; }
    .actions button { margin-right: 8px; padding: 6px 10px; border: none; border-radius: 6px; cursor: pointer; font-size: 12px; }
    .btn { background: #667eea; color: white; }
    .btn:hover { opacity: 0.9; }
    .btn-secondary { background: #f1f3f9; color: #333; }
    .toolbar { display: flex; gap: 10px; align-items: center; }
    .pill { display: inline-block; padding: 6px 10px; background: #eef2ff; color: #4543c2; border-radius: 20px; font-size: 12px; margin-left: 10px; }
    .small { color: #777; font-size: 12px; }
    .nowrap { white-space: nowrap; }
  </style>
</head>
<body>
  <div class="card">
    <h1>短链管理</h1>
    <div class="sub">使用 token 访问本页。可续期、删除现有短链。</div>
    <div class="toolbar">
      <button id="refreshBtn" class="actions btn" onclick="loadKeys()">刷新列表</button>
      <span class="pill">默认续期 7 天</span>
    </div>
    <div id="status" class="status"></div>
    <table>
      <thead>
        <tr>
          <th>ID</th>
          <th class="nowrap">到期时间</th>
          <th>原始 Clash 链接</th>
          <th>操作</th>
        </tr>
      </thead>
      <tbody id="tableBody"></tbody>
    </table>
    <div id="pagination" class="small" style="margin-top: 10px;"></div>
    <div class="small" style="margin-top: 12px;">提示：当前列表最多显示 50 条，如需更多可使用 cursor 翻页。</div>
  </div>

  <script>
    const urlParams = new URLSearchParams(location.search);
    const adminToken = urlParams.get('token') || '';
    const statusDiv = document.getElementById('status');
    const tableBody = document.getElementById('tableBody');
    const pagination = document.getElementById('pagination');

    if (!adminToken) {
      showStatus('缺少 token，请在地址栏添加 ?token=你的管理口令', 'error');
    } else {
      loadKeys();
    }

    async function loadKeys(cursor = '') {
      if (!adminToken) return;
      try {
        showStatus('加载中...', 'info');
        const url = cursor ? '/admin/list?cursor=' + encodeURIComponent(cursor) : '/admin/list';
        const resp = await fetch(url, { headers: { 'x-admin-token': adminToken } });
        if (!resp.ok) throw new Error('加载失败');
        const data = await resp.json();
        renderTable(data.keys || []);
        renderPagination(data.cursor, data.list_complete);
        showStatus('加载完成', 'success');
      } catch (e) {
        showStatus(e.message || '加载失败', 'error');
      }
    }

    function renderTable(keys) {
      if (!keys.length) {
        tableBody.innerHTML = '<tr><td colspan="4">暂无数据</td></tr>';
        return;
      }
      tableBody.innerHTML = keys.map(k => {
        const clash = k.metadata && k.metadata.clashUrl ? k.metadata.clashUrl : '-';
        const exp = k.expiration ? formatTs(k.expiration * 1000) : '无';
        return '<tr>' +
          '<td class="nowrap">' + k.id + '</td>' +
          '<td class="nowrap">' + exp + '</td>' +
          '<td style="word-break: break-all;">' + clash + '</td>' +
          '<td class="actions nowrap">' +
            '<button class="btn" onclick="renew(\'' + k.id + '\')">续期</button>' +
            '<button class="btn-secondary" onclick="removeLink(\'' + k.id + '\')">删除</button>' +
          '</td>' +
        '</tr>';
      }).join('');
    }

    function renderPagination(cursor, complete) {
      if (complete) {
        pagination.textContent = '已到达末尾';
      } else if (cursor) {
        pagination.innerHTML = '有更多结果，点击 <button class="btn-secondary" onclick="loadKeys(\'' + cursor + '\')">加载下一页</button>';
      } else {
        pagination.textContent = '';
      }
    }

    async function renew(id) {
      const days = prompt('续期天数', '7');
      if (days === null) return;
      try {
        const resp = await fetch('/admin/renew', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
            'x-admin-token': adminToken
          },
          body: JSON.stringify({ id, days: Number(days) })
        });
        if (!resp.ok) {
          const err = await resp.json().catch(() => ({}));
          throw new Error(err.error || '续期失败');
        }
        showStatus('续期成功', 'success');
        loadKeys();
      } catch (e) {
        showStatus(e.message, 'error');
      }
    }

    async function removeLink(id) {
      if (!confirm('确认删除短链 ' + id + ' ?')) return;
      try {
        const resp = await fetch('/admin/delete', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
            'x-admin-token': adminToken
          },
          body: JSON.stringify({ id })
        });
        if (!resp.ok) {
          const err = await resp.json().catch(() => ({}));
          throw new Error(err.error || '删除失败');
        }
        showStatus('删除成功', 'success');
        loadKeys();
      } catch (e) {
        showStatus(e.message, 'error');
      }
    }

    function formatTs(ts) {
      const d = new Date(ts);
      return d.toISOString().replace('T', ' ').slice(0, 19);
    }

    function showStatus(msg, type) {
      statusDiv.textContent = msg;
      statusDiv.className = 'status ' + type;
      statusDiv.style.display = 'block';
    }
  </script>
</body>
</html>`
}