import { useEffect, useMemo, useRef, useState } from 'react'
import type { Key, ReactNode } from 'react'
import {
  App as AntApp,
  Button,
  Form,
  Input,
  InputNumber,
  Modal,
  Select,
  Space,
  Statistic,
  Switch,
  Table,
  Tabs,
  Tag,
  Tooltip,
  Typography,
} from 'antd'
import type { ColumnsType } from 'antd/es/table'
import {
  ClipboardList,
  ClipboardPaste,
  Copy,
  FolderOpen,
  History,
  ListChecks,
  Pencil,
  Play,
  Plus,
  RefreshCw,
  Save,
  ShieldCheck,
  ShoppingCart,
  Square,
  Settings,
  Trash2,
  Zap,
} from 'lucide-react'
import {
  CheckCookies,
  DefaultConfig,
  Exchange,
  GetInstanceInfo,
  GetLogFilePath,
  GetLogs,
  GetLogStats,
  GetRecords,
  GetVersion,
  IsRunning,
  ListPrizes,
  OpenLogDir,
  PreviewAccounts,
  QueryScores,
  SetLogLevel,
  StartMonitor,
  StopMonitor,
} from '../wailsjs/go/gui/App'
import { ClipboardGetText, ClipboardSetText, EventsOn } from '../wailsjs/runtime/runtime'

const configStorageBase = 'huya-go.gui.config.v2'
const cookieStorageBase = 'huya-go.gui.cookies.v1'
const prizeCacheStorageBase = 'huya-go.gui.prizes.v1'
const leadDefaultMigrationBase = 'huya-go.gui.lead-default.v1'
// 旧版本默认把提前量写成 2500ms、线程写成 5 或 2。
// 现已调优为单实例 30 账号免排队出击（默认 30 并发）。
const legacyDefaultLeadMs = 2500
const concurrencyDefaultMigrationBase = 'huya-go.gui.concurrency-v30.v1'
const defaultConcurrency = 30
const legacyDefaultSID = 2203
const defaultSID = 2277
const sidDefaultMigrationBase = 'huya-go.gui.sid-v2277.v1'
const defaultMainSplit = 62
const splitStorageKeyBase = 'huya-go.gui.main-split.v1'

// 界面本地存储保留的日志上限，与后端的增量拉取配合使用。
const maxClientLogs = 1000

// 多开时按实例给本地存储分片：两个实例各存各的账号与配置，互不覆盖。
let storageSuffix = ''

function scopedKey(base: string): string {
  return storageSuffix ? `${base}@${storageSuffix}` : base
}

function applyStorageScope(instanceID: string) {
  const id = (instanceID || '').trim()
  storageSuffix = !id || id === 'default' ? '' : id
}

// 日志等级筛选项（仅作用于界面显示，不影响后端记录）。
const logFilterOptions = [
  { value: 'all', label: '全部等级' },
  { value: 'debug', label: 'debug' },
  { value: 'info', label: 'info' },
  { value: 'success', label: 'success' },
  { value: 'warn', label: 'warn' },
  { value: 'error', label: 'error' },
]

type UiConfig = {
  transport: string
  wssHost: string
  sid: number
  pid: number
  name: string
  // category 是类目筛选（类目 id 字符串，空串=全部），只影响监控时的自动选品范围。
  category: string
  targetText: string
  maxPrice: number
  minLeft: number
  cookieText: string
  selectedAccountLines: number[]
  delayMs: number
  concurrency: number
  // windowSeconds 是抢购窗口秒数（窗口模式下跑到「开抢+窗口」才收工）。
  windowSeconds: number
  stopAfterSuccess: boolean
  stopAccountAfterSuccess: boolean
  prewarm: boolean
  directExchange: boolean
  sharePrizeList: boolean
  autoSelect: boolean
  refreshAfterSuccess: boolean
  leadMs: number
  // timeSync 表示定时前用 pingSignal 校准服务端时间，并把 startAt 视为服务端时间。
  timeSync: boolean
  frequentBackoffMs: number
  errorBackoffMs: number
  timeoutSec: number
  startAt: string
}

type CookieCheckStatus = 'valid' | 'expired' | 'unknown' | 'invalid'

type CookieCheckResult = {
  line: number
  uid: number
  status: CookieCheckStatus
  message?: string
  statusCode?: number
  checkedAt: number
}

type AccountPreview = {
  line: number
  uid: number
  valid: boolean
  error?: string
  // checkStatus 是服务端登录态检查结果；valid 仅表示本地能解析出 uid。
  checkStatus?: CookieCheckStatus
  checkMessage?: string
  checkedAt?: number
}

type CookieEntry = {
  id: string
  text: string
  uid: number
  valid: boolean
  error?: string
  checkStatus?: CookieCheckStatus
  checkMessage?: string
  checkedAt?: number
  updatedAt: number
}

type LogEntry = {
  id: number
  time: string
  level: string
  category: string
  account: string
  message: string
}

type LogStats = {
  level: string
  filePath: string
  dir: string
  dropped: number
  count: number
}

type InstanceInfo = {
  name: string
  id: string
  dataDir: string
  logDir: string
  logFile: string
}

type PrizeInfo = {
  id: number
  sid?: number
  name: string
  score?: number
  new_score?: number
  num?: number
  left_num?: number
  status?: number
  percent?: string
  is_show_num?: number
  img?: string
  // tags 是类目 id（逗号分隔）：99=限量返场、101=精英专享（以服务端下发的类目字典为准）。
  tags?: string
  publish_time?: number
  start_time?: number
  end_time?: number
  daily_start?: string
  daily_end?: string
}

type PrizeTag = {
  id: number
  name: string
  weight?: number
}

type CategoryStat = {
  id: number
  name: string
  count?: number
  left?: number
  total?: number
}

type PrizeCache = {
  prizes: PrizeInfo[]
  categories?: PrizeTag[]
  categoryStats?: CategoryStat[]
  updatedAt: number
  sid?: number
}

type ScoreResult = {
  uid: number
  score: number
  resp?: {
    status?: number
    msg?: string
  }
  error?: string
}

type UserPrizeInfo = {
  id?: number
  name?: string
  score?: number
  new_score?: number
  status?: number
  create_time?: number
  order_id?: string
  img?: string
  prize_id?: number
  item_id?: number
  exchange_date?: number
}

type RecordResult = {
  uid: number
  records?: UserPrizeInfo[]
  resp?: {
    msg?: string
  }
  error?: string
}

type ExchangeInfo = {
  pid?: number
  exchange_score?: number
  exchangeScore?: number
  desc?: string
}

type ActPreCondition = {
  tip?: string
}

type ExchangeResp = {
  status?: number
  msg?: string
  order_id?: string
  orderId?: string
  exchange_info?: ExchangeInfo
  exchangeInfo?: ExchangeInfo
  act_pre_condition?: ActPreCondition
  actPreCondition?: ActPreCondition
}

type ExchangeResult = {
  uid: number
  resp?: ExchangeResp
  category?: string
  message?: string
  error?: string
}

type MonitorResult = {
  key?: string
  loop?: number
  uid: number
  target_index?: number
  targetIndex?: number
  action?: string
  category?: string
  message?: string
  done?: boolean
  prize?: PrizeInfo
  exchange?: ExchangeResp
  score?: ScoreResult['resp']
  records?: RecordResult['resp']
  error?: string
}

type RecordRow = UserPrizeInfo & {
  key: string
  uid: number
}

// exchangeSummary 汇总某个账号本次运行里的兑换结果，供「兑换结果」列展示。
type ExchangeSummary = {
  success?: MonitorResult
  failed?: MonitorResult
  attempts: number
  skipped: number
}

function isExchangeAttempt(action?: string): boolean {
  return action === 'exchange' || action === 'exchange_error'
}

function exchangeOrderID(exchange?: ExchangeResp): string {
  return exchange?.order_id || exchange?.orderId || ''
}

type SavedConfig = Omit<UiConfig, 'cookieText' | 'selectedAccountLines'>

type ScheduleCountdown = {
  targetAt: number
  fireAt: number
}

function getExchangeInfo(resp?: ExchangeResp): ExchangeInfo {
  return resp?.exchange_info || resp?.exchangeInfo || {}
}

function getPreCondition(resp?: ExchangeResp): ActPreCondition {
  return resp?.act_pre_condition || resp?.actPreCondition || {}
}

function priceOf(row?: PrizeInfo): number {
  if (!row) return 0
  return row.new_score || row.score || 0
}

// categoryIDsOf 解析奖品 tag14 里的类目 id（服务端可能下发多个，逗号分隔）。
function categoryIDsOf(row?: PrizeInfo): number[] {
  return String(row?.tags || '')
    .split(',')
    .map((item) => Number(item.trim()))
    .filter((id) => Number.isFinite(id) && id > 0)
}

// categoryNamesOf 把类目 id 翻译成类目名；字典里没有时用「类目<id>」兜底。
function categoryNamesOf(row: PrizeInfo | undefined, categories: PrizeTag[]): string[] {
  return categoryIDsOf(row).map((id) => categories.find((tag) => Number(tag.id) === id)?.name || `类目${id}`)
}

function formatDateTime(seconds?: number): string {
  if (!seconds || seconds <= 0) return ''
  const date = new Date(seconds * 1000)
  const pad = (value: number) => String(value).padStart(2, '0')
  return `${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`
}

function formatCountdown(ms: number): string {
  if (ms <= 0) return ''
  const total = Math.floor(ms / 1000)
  const hours = Math.floor(total / 3600)
  const minutes = Math.floor((total % 3600) / 60)
  const seconds = total % 60
  const pad = (value: number) => String(value).padStart(2, '0')
  return `${pad(hours)}:${pad(minutes)}:${pad(seconds)}`
}

// saleStateOf 描述商品的上下架状态：限量返场是「预告上架」，页面的倒计时来自 start_time。
function saleStateOf(row: PrizeInfo | undefined, now: Date): { onSale: boolean; label: string; countdown: string } {
  const start = Number(row?.start_time || 0)
  if (!start || start <= 0) {
    return { onSale: true, label: '', countdown: '' }
  }
  const remains = start * 1000 - now.getTime()
  if (remains > 0) {
    return { onSale: false, label: `${formatDateTime(start)} 上架`, countdown: formatCountdown(remains) }
  }
  return { onSale: true, label: '', countdown: '' }
}

type InventoryInfo = {
  left?: number
  total?: number
  percent?: string
  estimated: boolean
}

function inventoryOf(row?: PrizeInfo): InventoryInfo {
  if (!row) return { estimated: false }
  const total = Number(row.num || 0)
  const percent = normalizePercent(row.percent)
  const rawLeft = Number(row.left_num || 0)
  if (rawLeft > 0 || percent === '0%') {
    return {
      left: rawLeft,
      total: total > 0 ? total : undefined,
      percent,
      estimated: false,
    }
  }
  if (total > 0 && percent) {
    const percentValue = Number(percent.replace('%', ''))
    if (Number.isFinite(percentValue)) {
      return {
        left: Math.floor((total * percentValue) / 100),
        total,
        percent,
        estimated: true,
      }
    }
  }
  return {
    total: total > 0 ? total : undefined,
    percent,
    estimated: false,
  }
}

function normalizePercent(value?: string): string | undefined {
  const text = String(value || '').trim()
  if (!text) return undefined
  const numeric = Number(text.replace('%', ''))
  if (!Number.isFinite(numeric)) return text
  return `${numeric}%`
}

function inventoryText(row?: PrizeInfo): string {
  const info = inventoryOf(row)
  const left = info.left === undefined ? '-' : `${info.estimated ? '约 ' : ''}${info.left}`
  const total = info.total === undefined ? '-' : String(info.total)
  return `剩余 ${left} / 总量 ${total}${info.percent ? ` · ${info.percent}` : ''}`
}

function summarizeInventory(items: PrizeInfo[]): string {
  let left = 0
  let total = 0
  let leftKnown = 0
  let totalKnown = 0
  items.forEach((item) => {
    const info = inventoryOf(item)
    if (info.left !== undefined) {
      left += info.left
      leftKnown += 1
    }
    if (info.total !== undefined) {
      total += info.total
      totalKnown += 1
    }
  })
  if (leftKnown === 0 && totalKnown === 0) return '库存未公开'
  return `剩余 ${leftKnown ? left : '-'} / 总量 ${totalKnown ? total : '-'}`
}

function formatUnixTime(value?: number): string {
  const ts = Number(value || 0)
  if (!ts) return ''
  // 服务端返回秒级时间戳，兼容毫秒。
  const ms = ts > 1e12 ? ts : ts * 1000
  return new Date(ms).toLocaleString('zh-CN', { hour12: false })
}

function statusTag(status?: number, error?: string): ReactNode {
  if (error) return <Tag color="error">失败</Tag>
  if (status === 200) return <Tag color="success">成功</Tag>
  if (status) return <Tag color="warning">{status}</Tag>
  return <Tag>待处理</Tag>
}

function categoryTag(category?: string): ReactNode {
  const map: Record<string, { color: string; label: string }> = {
    ready: { color: 'blue', label: '预热' },
    success: { color: 'success', label: '成功' },
    not_found: { color: 'default', label: '未命中' },
    not_open: { color: 'processing', label: '未开放' },
    too_frequent: { color: 'warning', label: '频控' },
    not_enough: { color: 'error', label: '不足' },
    already_done: { color: 'purple', label: '已兑' },
    off_shelf: { color: 'error', label: '下架' },
    sold_out: { color: 'error', label: '抢完' },
    condition: { color: 'geekblue', label: '条件' },
    failed: { color: 'warning', label: '失败' },
    error: { color: 'error', label: '异常' },
    // protocol 是回包结构异常（缺 tRsp/tResp），单独归类便于排查服务端错误信封。
    protocol: { color: 'error', label: '协议异常' },
    // session_lost 是「账号未绑定」这类瞬时会话失效，通常下一轮就能恢复。
    session_lost: { color: 'volcano', label: '会话失效' },
  }
  if (!category) return <Tag>待处理</Tag>
  const item = map[category] || { color: 'default', label: category }
  return <Tag color={item.color}>{item.label}</Tag>
}

function normalizeCookieCheckStatus(value: unknown): CookieCheckStatus | undefined {
  const status = String(value || '').trim()
  if (status === 'valid' || status === 'expired' || status === 'unknown' || status === 'invalid') {
    return status
  }
  return undefined
}

function isCookieCheckUnusable(status?: CookieCheckStatus): boolean {
  return status === 'expired' || status === 'unknown' || status === 'invalid'
}

function cookieCheckTag(status?: CookieCheckStatus, message?: string): ReactNode {
  const config: Record<CookieCheckStatus | 'unchecked', { color: string; label: string }> = {
    valid: { color: 'success', label: '可用' },
    expired: { color: 'error', label: '失效' },
    unknown: { color: 'error', label: '失效' },
    invalid: { color: 'error', label: '无效' },
    unchecked: { color: 'default', label: '未检查' },
  }
  const item = config[status || 'unchecked']
  const tag = <Tag color={item.color}>{item.label}</Tag>
  return message ? <Tooltip title={message}>{tag}</Tooltip> : tag
}

function readSavedConfig(): Partial<SavedConfig> {
  try {
    const configKey = scopedKey(configStorageBase)
    const saved = JSON.parse(localStorage.getItem(configKey) || '{}') as Partial<SavedConfig>
    let dirty = false

    // v0.5.0 移除了轮次和全局降速器配置，顺手清掉本地旧字段。
    const legacyFields = saved as Record<string, unknown>
    for (const key of ['loops', 'adaptiveThrottle', 'disableAdaptiveThrottle']) {
      if (key in legacyFields) {
        delete legacyFields[key]
        dirty = true
      }
    }

    const leadMigrationKey = scopedKey(leadDefaultMigrationBase)
    if (!localStorage.getItem(leadMigrationKey)) {
      if (Number(saved.leadMs || 0) === legacyDefaultLeadMs) {
        saved.leadMs = 0
        dirty = true
      }
      localStorage.setItem(leadMigrationKey, '1')
    }

    const concurrencyMigrationKey = scopedKey(concurrencyDefaultMigrationBase)
    if (!localStorage.getItem(concurrencyMigrationKey)) {
      if (Number(saved.concurrency || 0) <= 5) {
        saved.concurrency = defaultConcurrency
        dirty = true
      }
      localStorage.setItem(concurrencyMigrationKey, '1')
    }

    const sidMigrationKey = scopedKey(sidDefaultMigrationBase)
    if (!localStorage.getItem(sidMigrationKey)) {
      if (Number(saved.sid || 0) === legacyDefaultSID || !saved.sid) {
        saved.sid = defaultSID
        dirty = true
      }
      localStorage.setItem(sidMigrationKey, '1')
    }

    if (dirty) {
      // 迁移必须立即落盘，否则下一次 readSavedConfig 又会读回旧值。
      localStorage.setItem(configKey, JSON.stringify(saved))
    }
    return saved
  } catch {
    return {}
  }
}

function writeSavedConfigPatch(patch: Partial<SavedConfig>) {
  localStorage.setItem(scopedKey(configStorageBase), JSON.stringify({ ...readSavedConfig(), ...patch }))
}

function readSavedCookies(): CookieEntry[] {
  try {
    const items = JSON.parse(localStorage.getItem(scopedKey(cookieStorageBase)) || '[]') as Partial<CookieEntry>[]
    return items
      .map((item, index) => ({
        id: item.id || `ck-${Date.now()}-${index}`,
        text: String(item.text || '').trim(),
        uid: Number(item.uid || 0),
        valid: Boolean(item.valid),
        error: item.error,
        checkStatus: normalizeCookieCheckStatus(item.checkStatus),
        checkMessage: String(item.checkMessage || '').trim() || undefined,
        checkedAt: Number(item.checkedAt || 0) || undefined,
        updatedAt: Number(item.updatedAt || Date.now()),
      }))
      .filter((item) => item.text)
  } catch {
    return []
  }
}

function writeSavedCookies(items: CookieEntry[]) {
  localStorage.setItem(scopedKey(cookieStorageBase), JSON.stringify(items))
}

function readSavedPrizeCache(): PrizeCache {
  try {
    const cache = JSON.parse(localStorage.getItem(scopedKey(prizeCacheStorageBase)) || '{}') as Partial<PrizeCache>
    const prizes = Array.isArray(cache.prizes)
      ? cache.prizes.filter((item) => Number(item?.id || 0) > 0 && String(item?.name || '').trim())
      : []
    return {
      prizes: prizes as PrizeInfo[],
      categories: Array.isArray(cache.categories) ? (cache.categories as PrizeTag[]) : [],
      categoryStats: Array.isArray(cache.categoryStats) ? (cache.categoryStats as CategoryStat[]) : [],
      updatedAt: Number(cache.updatedAt || 0),
      sid: Number(cache.sid || 0) || undefined,
    }
  } catch {
    return { prizes: [], categories: [], categoryStats: [], updatedAt: 0 }
  }
}

function writeSavedPrizeCache(
  prizes: PrizeInfo[],
  sid: number,
  categories: PrizeTag[] = [],
  categoryStats: CategoryStat[] = [],
) {
  localStorage.setItem(
    scopedKey(prizeCacheStorageBase),
    JSON.stringify({
      prizes,
      categories,
      categoryStats,
      sid,
      updatedAt: Date.now(),
    }),
  )
}

function normalizeCookieText(text: string): string {
  const normalized = text
    .replace(/\r\n?/g, '\n')
    .replace(/\\r\\n|\\r|\\n/g, '\n')

  const withLineBreaks =
    normalized.includes('\n') || !/\/r\/n|\/r/.test(normalized)
      ? normalized
      : normalized.replace(/\/r\/n|\/r|\/n/g, '\n')

  return withLineBreaks
    .split('\n')
    .map((line) => line.trim())
    .filter(Boolean)
    .join('\n')
}

function cookieTextFromEntries(items: CookieEntry[]): string {
  return items
    .map((item) => item.text.trim())
    .filter(Boolean)
    .join('\n')
}

function newCookieID(): string {
  return `ck-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
}

function pickConfig(values: Partial<UiConfig>): UiConfig {
  return {
    transport: values.transport || 'wss',
    wssHost: values.wssHost || '',
    sid: Number(values.sid || defaultSID),
    pid: Number(values.pid || 0),
    name: values.name || '',
    category: values.category || '',
    targetText: values.targetText || '',
    maxPrice: Number(values.maxPrice || 0),
    minLeft: Number(values.minLeft || 0),
    cookieText: values.cookieText || '',
    selectedAccountLines: values.selectedAccountLines || [],
    delayMs: Number(values.delayMs || 120),
    concurrency: Number(values.concurrency || defaultConcurrency),
    windowSeconds: Number(values.windowSeconds || 30),
    stopAfterSuccess: Boolean(values.stopAfterSuccess),
    stopAccountAfterSuccess: values.stopAccountAfterSuccess !== false,
    prewarm: values.prewarm !== false,
    directExchange: values.directExchange !== false,
    sharePrizeList: values.sharePrizeList !== false,
    autoSelect: Boolean(values.autoSelect),
    refreshAfterSuccess: values.refreshAfterSuccess !== false,
    leadMs: Number(values.leadMs || 0),
    timeSync: values.timeSync !== false,
    frequentBackoffMs: Number(values.frequentBackoffMs || 300),
    errorBackoffMs: Number(values.errorBackoffMs || 300),
    timeoutSec: Number(values.timeoutSec || 15),
    startAt: values.startAt || '',
  }
}

function normalizeMonitorResult(row: MonitorResult): MonitorResult {
  return {
    ...row,
    key: `monitor-${row.loop || 0}-${row.uid}-${Date.now()}-${Math.random()}`,
  }
}

// mergeLogs 按自增 ID 合并日志：实时事件与初始拉取可能交错，按 ID 去重并保持顺序。
function mergeLogs(prev: LogEntry[], incoming: LogEntry[]): LogEntry[] {
  if (incoming.length === 0) return prev
  const lastID = prev.length > 0 ? prev[prev.length - 1].id : 0
  const fresh = incoming.filter((item) => Number(item.id || 0) > lastID)
  if (fresh.length === 0) return prev
  fresh.sort((a, b) => a.id - b.id)
  return [...prev, ...fresh].slice(-maxClientLogs)
}

export default function Dashboard() {
  const { message, modal } = AntApp.useApp()
  const [form] = Form.useForm<UiConfig>()
  const previewedCookieText = useRef('')
  const watchedTransport = Form.useWatch('transport', form)
  const watchedPID = Form.useWatch('pid', form)
  const watchedName = Form.useWatch('name', form)
  const watchedCookieText = Form.useWatch('cookieText', form)
  const watchedStartAt = Form.useWatch('startAt', form)
  const [loading, setLoading] = useState('')
  const [running, setRunning] = useState(false)
  const [accounts, setAccounts] = useState<AccountPreview[]>([])
  const [selectedAccountLines, setSelectedAccountLines] = useState<Key[]>([])
  const [prizes, setPrizes] = useState<PrizeInfo[]>([])
  const [prizeCategories, setPrizeCategories] = useState<PrizeTag[]>([])
  const [categoryStats, setCategoryStats] = useState<CategoryStat[]>([])
  // activeCategory 是当前选中的类目（空串=全部）；监控时的自动选品也按它过滤。
  const [activeCategory, setActiveCategory] = useState('')
  const [selectedPrizeKeys, setSelectedPrizeKeys] = useState<Key[]>([])
  const [productSearch, setProductSearch] = useState('')
  const [scores, setScores] = useState<ScoreResult[]>([])
  const [records, setRecords] = useState<RecordResult[]>([])
  const [panelTab, setPanelTab] = useState<string>('logs')
  const [recordModalData, setRecordModalData] = useState<{
    open: boolean
    account?: AccountPreview
    loading: boolean
    records: UserPrizeInfo[]
    error?: string
  }>({ open: false, loading: false, records: [] })
  const [results, setResults] = useState<MonitorResult[]>([])
  const [logs, setLogs] = useState<LogEntry[]>([])
  const [now, setNow] = useState(new Date())
  const [scheduleCountdown, setScheduleCountdown] = useState<ScheduleCountdown | null>(null)
  const [settingsOpen, setSettingsOpen] = useState(false)
  const [cookieManagerOpen, setCookieManagerOpen] = useState(false)
  const [cookieEditOpen, setCookieEditOpen] = useState(false)
  const [editingCookie, setEditingCookie] = useState<CookieEntry | null>(null)
  const [cookieDraft, setCookieDraft] = useState('')
  const [cookieEntries, setCookieEntries] = useState<CookieEntry[]>([])
  const [prizeCacheUpdatedAt, setPrizeCacheUpdatedAt] = useState(0)
  const [configLoaded, setConfigLoaded] = useState(false)
  const [logPath, setLogPath] = useState('')
  const [logStats, setLogStats] = useState<LogStats | null>(null)
  const [logFilter, setLogFilter] = useState('all')
  const [debugLog, setDebugLog] = useState(false)
  const [instanceInfo, setInstanceInfo] = useState<InstanceInfo | null>(null)
  const [appVersion, setAppVersion] = useState('')
  const [mainSplit, setMainSplit] = useState<number>(() => {
    try {
      const saved = Number(localStorage.getItem(scopedKey(splitStorageKeyBase)))
      if (saved >= 30 && saved <= 85) return saved
    } catch {}
    return defaultMainSplit
  })
  const [isDraggingSplit, setIsDraggingSplit] = useState(false)
  const mainGridRef = useRef<HTMLElement>(null)

  const handleSplitMouseDown = (e: React.MouseEvent) => {
    e.preventDefault()
    setIsDraggingSplit(true)

    const container = mainGridRef.current
    if (!container) return

    const rect = container.getBoundingClientRect()

    const onMouseMove = (moveEvent: MouseEvent) => {
      const offsetX = moveEvent.clientX - rect.left
      const percent = Math.min(85, Math.max(30, (offsetX / rect.width) * 100))
      setMainSplit(percent)
    }

    const onMouseUp = () => {
      setIsDraggingSplit(false)
      window.removeEventListener('mousemove', onMouseMove)
      window.removeEventListener('mouseup', onMouseUp)
      setMainSplit((latest) => {
        try {
          localStorage.setItem(scopedKey(splitStorageKeyBase), String(Math.round(latest)))
        } catch {}
        return latest
      })
    }

    window.addEventListener('mousemove', onMouseMove)
    window.addEventListener('mouseup', onMouseUp)
  }

  const handleSplitDoubleClick = () => {
    setMainSplit(defaultMainSplit)
    try {
      localStorage.setItem(scopedKey(splitStorageKeyBase), String(defaultMainSplit))
    } catch {}
    message.info('已恢复默认左右宽度 (62%)')
  }

  const applyCookieEntries = async (entries: CookieEntry[], persist = true, refreshLatest = false) => {
    const normalizedEntries = entries
      .map((entry) => ({
        ...entry,
        text: normalizeCookieText(entry.text).split('\n')[0] || '',
      }))
      .filter((entry) => entry.text)

    const cookieText = cookieTextFromEntries(normalizedEntries)
    previewedCookieText.current = cookieText
    form.setFieldsValue({ cookieText })
    setSelectedPrizeKeys([])

    if (!cookieText) {
      setCookieEntries([])
      setAccounts([])
      setSelectedAccountLines([])
      if (persist) writeSavedCookies([])
      return []
    }

    const previews = (await PreviewAccounts(cookieText)) as AccountPreview[]
    const enriched = normalizedEntries.map((entry, index) => {
      const preview = previews.find((item) => item.line === index + 1)
      return {
        ...entry,
        uid: preview?.uid || 0,
        valid: Boolean(preview?.valid),
        error: preview?.error,
      }
    })
    setCookieEntries(enriched)
    const enrichedPreviews = (previews || []).map((preview) => {
      const entry = enriched[preview.line - 1]
      return {
        ...preview,
        checkStatus: entry?.checkStatus,
        checkMessage: entry?.checkMessage,
        checkedAt: entry?.checkedAt,
      }
    })
    setAccounts(enrichedPreviews)
    const selectableLines = enrichedPreviews
      .filter((item) => item.valid && !isCookieCheckUnusable(item.checkStatus))
      .map((item) => item.line)
    setSelectedAccountLines(selectableLines)
    if (persist) writeSavedCookies(enriched)
    if (refreshLatest && selectableLines.length > 0) {
      window.setTimeout(() => queryPrizes(true, selectableLines), 0)
    }
    return enriched
  }

  useEffect(() => {
    let mounted = true
    Promise.all([
      DefaultConfig(),
      GetLogs(0),
      IsRunning(),
      GetLogFilePath(),
      GetInstanceInfo(),
      GetLogStats(),
      GetVersion(),
    ])
      .then(([defaults, logItems, isRunning, savedLogPath, info, stats, version]) => {
        if (!mounted) return
        const instance = info as InstanceInfo | null
        // 本地存储必须按实例分片后再读取，否则多开时两个实例会共用同一份账号与配置。
        applyStorageScope(instance?.id || '')
        setInstanceInfo(instance)
        setAppVersion(String(version || ''))
        setLogStats((stats || null) as LogStats | null)
        setDebugLog(String((stats as LogStats | null)?.level || '') === 'debug')

        const savedCookies = readSavedCookies()
        const savedPrizeCache = readSavedPrizeCache()
        const savedConfig = readSavedConfig()
        form.setFieldsValue({
          ...(defaults as UiConfig),
          ...savedConfig,
          cookieText: cookieTextFromEntries(savedCookies),
        })
        setCookieEntries(savedCookies)
        setActiveCategory(String(savedConfig.category || ''))
        setPrizes(savedPrizeCache.prizes)
        setPrizeCategories(savedPrizeCache.categories || [])
        setCategoryStats(savedPrizeCache.categoryStats || [])
        setPrizeCacheUpdatedAt(savedPrizeCache.updatedAt)
        setLogs((prev) => mergeLogs(prev, (logItems || []) as LogEntry[]))
        setLogPath(String(savedLogPath || instance?.logFile || ''))
        setRunning(Boolean(isRunning))
        setConfigLoaded(true)
        if (savedCookies.length > 0) {
          applyCookieEntries(savedCookies, true, true).catch((err: unknown) => message.error(String(err)))
        }
      })
      .catch((err: unknown) => message.error(String(err)))

    const offLog = EventsOn('gui:log', (entry: LogEntry) => {
      setLogs((prev) => mergeLogs(prev, [entry]))
    })
    const offResult = EventsOn('gui:monitor-result', (result: MonitorResult) => {
      setResults((prev) => [normalizeMonitorResult(result), ...prev].slice(0, 300))
    })
    const offState = EventsOn(
      'gui:monitor-state',
      (state: { running?: boolean; message?: string }) => {
        const nextRunning = Boolean(state?.running)
        setRunning(nextRunning)
        if (!nextRunning) setScheduleCountdown(null)
        if (state?.message) message.info(state.message)
      },
    )
    const tick = window.setInterval(() => setNow(new Date()), 250)

    return () => {
      mounted = false
      offLog()
      offResult()
      offState()
      window.clearInterval(tick)
    }
  }, [form, message])

  useEffect(() => {
    if ((watchedCookieText || '') === previewedCookieText.current) return
    setAccounts([])
    setSelectedAccountLines([])
    setSelectedPrizeKeys([])
  }, [watchedCookieText])

  useEffect(() => {
    if (!configLoaded) return
    writeSavedConfigPatch({ startAt: String(form.getFieldValue('startAt') || '') })
  }, [configLoaded, form, watchedStartAt])

  const validAccounts = useMemo(
    () => accounts.filter((item) => item.valid && !isCookieCheckUnusable(item.checkStatus)),
    [accounts],
  )
  const cookieCheckStats = useMemo(() => {
    const stats = { valid: 0, expired: 0, unknown: 0, invalid: 0, unchecked: 0 }
    cookieEntries.forEach((entry) => {
      if (entry.checkStatus === 'valid') stats.valid += 1
      else if (entry.checkStatus === 'expired') stats.expired += 1
      else if (entry.checkStatus === 'unknown') stats.unknown += 1
      else if (entry.checkStatus === 'invalid') stats.invalid += 1
      else stats.unchecked += 1
    })
    return stats
  }, [cookieEntries])
  const failedCookieCount = cookieCheckStats.expired + cookieCheckStats.unknown + cookieCheckStats.invalid
  const importedCookieCount = useMemo(
    () => normalizeCookieText(watchedCookieText || '').split('\n').filter(Boolean).length,
    [watchedCookieText],
  )
  const selectedAccountCount = selectedAccountLines.length
  const selectedPrizeID =
    selectedPrizeKeys.length === 1 ? Number(selectedPrizeKeys[0]) || undefined : undefined

  const scoreMap = useMemo(() => {
    const map = new Map<number, ScoreResult>()
    scores.forEach((item) => map.set(item.uid, item))
    return map
  }, [scores])

  const latestResultByUID = useMemo(() => {
    const map = new Map<number, MonitorResult>()
    results.forEach((item) => {
      if (!map.has(item.uid)) map.set(item.uid, item)
    })
    return map
  }, [results])

  // 本次运行里各账号的兑换结果（results 为最新在前）。
  const exchangeByUID = useMemo(() => {
    const map = new Map<number, ExchangeSummary>()
    results.forEach((item) => {
      if (item.action === 'skip_duplicate') {
        const entry = map.get(item.uid) ?? { attempts: 0, skipped: 0 }
        entry.skipped += 1
        map.set(item.uid, entry)
        return
      }
      if (!isExchangeAttempt(item.action)) return
      const entry = map.get(item.uid) ?? { attempts: 0, skipped: 0 }
      entry.attempts += 1
      if (item.category === 'success') {
        if (!entry.success) entry.success = item
      } else if (!entry.failed) {
        entry.failed = item
      }
      map.set(item.uid, entry)
    })
    return map
  }, [results])

  const recordsByUID = useMemo(() => {
    const map = new Map<number, RecordResult>()
    records.forEach((item) => map.set(item.uid, item))
    return map
  }, [records])

  // 用服务端兑换记录兜底，界面刷新后也能看出该账号是否已抢到当前奖品。
  const recordHitByUID = useMemo(() => {
    const map = new Map<number, UserPrizeInfo>()
    const pid = Number(watchedPID || 0)
    const name = String(watchedName || '').trim()
    if (pid <= 0 && !name) return map
    records.forEach((item) => {
      ;(item.records || []).forEach((record) => {
        const hitPID = pid > 0 && Number(record.prize_id || 0) === pid
        const hitName = name !== '' && String(record.name || '').includes(name)
        if (!hitPID && !hitName) return
        const prev = map.get(item.uid)
        if (!prev || Number(record.create_time || 0) > Number(prev.create_time || 0)) {
          map.set(item.uid, record)
        }
      })
    })
    return map
  }, [records, watchedPID, watchedName])

  const successCount = useMemo(
    () => new Set(results.filter((item) => item.category === 'success').map((item) => item.uid)).size,
    [results],
  )
  const errorCount = useMemo(
    () =>
      results.filter((item) =>
        ['error', 'failed', 'not_enough', 'off_shelf', 'sold_out', 'condition', 'protocol'].includes(
          item.category || '',
        ),
      ).length,
    [results],
  )
  const pendingCount = Math.max(selectedAccountCount - successCount, 0)

  const currentPrize = useMemo(() => {
    const fromSelection = prizes.find((item) => item.id === selectedPrizeID)
    if (fromSelection) return fromSelection
    const pid = Number(watchedPID || 0)
    return prizes.find((item) => item.id === pid)
  }, [prizes, selectedPrizeID, watchedPID])

  const filteredPrizes = useMemo(() => {
    const keyword = productSearch.trim().toLowerCase()
    const categoryID = Number(activeCategory || 0)
    return prizes.filter((item) => {
      if (categoryID > 0 && !categoryIDsOf(item).includes(categoryID)) return false
      if (!keyword) return true
      const text = [item.name, String(item.id), String(priceOf(item)), ...categoryNamesOf(item, prizeCategories)]
        .join(' ')
        .toLowerCase()
      return text.includes(keyword)
    })
  }, [prizes, productSearch, activeCategory, prizeCategories])
  const inventorySummary = useMemo(() => summarizeInventory(filteredPrizes), [filteredPrizes])

  // 类目页签与服务端下发的类目字典同序（限量返场/精英专享），数量优先用服务端统计。
  const categoryItems = useMemo(() => {
    const items = [{ key: '', label: `全部 ${prizes.length}` }]
    prizeCategories.forEach((tag) => {
      const id = Number(tag.id)
      const stat = categoryStats.find((item) => Number(item.id) === id)
      const count = stat?.count ?? prizes.filter((item) => categoryIDsOf(item).includes(id)).length
      items.push({ key: String(id), label: `${tag.name} ${count}` })
    })
    return items
  }, [prizeCategories, categoryStats, prizes])

  // 日志筛选只在界面上生效；后端的 debug 开关由「调试日志」按钮控制。
  const visibleLogs = useMemo(
    () => (logFilter === 'all' ? logs : logs.filter((item) => item.level === logFilter)),
    [logs, logFilter],
  )

  const config = (selectedLines: Key[] = selectedAccountLines) => ({
    ...pickConfig(form.getFieldsValue(true)),
    category: activeCategory,
    selectedAccountLines: selectedLines.map(Number).filter((line) => line > 0),
  })

  const runAction = async <T,>(
    key: string,
    action: () => Promise<T>,
    onDone?: (data: T) => void,
  ) => {
    setLoading(key)
    try {
      const data = await action()
      onDone?.(data)
      message.success('完成')
    } catch (err: unknown) {
      message.error(String(err))
    } finally {
      setLoading('')
    }
  }

  const upsertCookieLines = async (lines: string[]) => {
    const normalizedText = normalizeCookieText(lines.join('\n'))
    const nextLines = normalizedText.split('\n').filter(Boolean)
    if (nextLines.length === 0) return { added: 0, updated: 0 }

    const previews = (await PreviewAccounts(nextLines.join('\n'))) as AccountPreview[]
    const nextEntries = [...cookieEntries]
    let added = 0
    let updated = 0

    nextLines.forEach((text, index) => {
      const preview = previews.find((item) => item.line === index + 1)
      const uid = preview?.uid || 0
      const valid = Boolean(preview?.valid)
      const existingIndex =
        valid && uid > 0
          ? nextEntries.findIndex((item) => item.valid && item.uid === uid)
          : nextEntries.findIndex((item) => item.text === text)
      const entry: CookieEntry = {
        id: existingIndex >= 0 ? nextEntries[existingIndex].id : newCookieID(),
        text,
        uid,
        valid,
        error: preview?.error,
        updatedAt: Date.now(),
      }
      if (existingIndex >= 0) {
        nextEntries[existingIndex] = entry
        updated += 1
      } else {
        nextEntries.push(entry)
        added += 1
      }
    })

    await applyCookieEntries(nextEntries, true, true)
    return { added, updated }
  }

  const importCookiesFromClipboard = async () => {
    setLoading('clipboard')
    try {
      const clipboardText = await ClipboardGetText()
      const cookieText = normalizeCookieText(clipboardText || '')
      if (!cookieText) {
        message.warning('剪贴板没有可导入的 CK')
        return
      }
      const result = await upsertCookieLines(cookieText.split('\n'))
      message.success(`已导入 ${result.added} 条，更新 ${result.updated} 条 CK`)
    } catch (err: unknown) {
      message.error(`剪贴板导入失败: ${String(err)}`)
    } finally {
      setLoading('')
    }
  }

  const openNewCookie = () => {
    setEditingCookie(null)
    setCookieDraft('')
    setCookieEditOpen(true)
  }

  const openEditCookie = (entry: CookieEntry) => {
    setEditingCookie(entry)
    setCookieDraft(entry.text)
    setCookieEditOpen(true)
  }

  const saveCookieDraft = async () => {
    const normalizedText = normalizeCookieText(cookieDraft)
    if (!normalizedText) {
      message.warning('CK 不能为空')
      return
    }
    setLoading('cookie-save')
    try {
      if (editingCookie) {
        const text = normalizedText.split('\n')[0]
        const nextEntries = cookieEntries.map((entry) =>
          entry.id === editingCookie.id
            ? {
                ...entry,
                text,
                checkStatus: undefined,
                checkMessage: undefined,
                checkedAt: undefined,
                updatedAt: Date.now(),
              }
            : entry,
        )
        await applyCookieEntries(nextEntries, true, true)
        message.success('CK 已更新')
      } else {
        const result = await upsertCookieLines(normalizedText.split('\n'))
        message.success(`已新增 ${result.added} 条，更新 ${result.updated} 条 CK`)
      }
      setCookieEditOpen(false)
      setCookieDraft('')
      setEditingCookie(null)
    } catch (err: unknown) {
      message.error(String(err))
    } finally {
      setLoading('')
    }
  }

  const deleteCookie = async (entry: CookieEntry) => {
    await applyCookieEntries(cookieEntries.filter((item) => item.id !== entry.id))
    message.success('CK 已删除')
  }

  const clearCookies = () => {
    modal.confirm({
      title: '清空 CK',
      content: '确认删除所有已保存 CK？',
      okText: '清空',
      cancelText: '取消',
      okButtonProps: { danger: true },
      onOk: async () => {
        await applyCookieEntries([])
        message.success('CK 已清空')
      },
    })
  }

  const reloadSavedCookies = async () => {
    const savedCookies = readSavedCookies()
    await applyCookieEntries(savedCookies, true, true)
    message.success('已重新载入本地 CK')
  }

  // 检查走服务端 getUserScore；失效结果连续确认 3 次，避免偶发「账号未绑定」误判。
  const checkCookies = async () => {
    if (running) {
      message.warning('抢购运行中，请先停止再检查 CK')
      return
    }
    if (cookieEntries.length === 0) {
      message.warning('没有可检查的 CK')
      return
    }
    setLoading('cookie-check')
    try {
      const snapshot = cookieEntries
      const results = (await CheckCookies(config())) as CookieCheckResult[]
      const byLine = new Map<number, CookieCheckResult>()
      const byUID = new Map<number, CookieCheckResult>()
      results.forEach((item) => {
        byLine.set(Number(item.line || 0), item)
        if (Number(item.uid || 0) > 0) byUID.set(Number(item.uid), item)
      })

      const nextEntries = snapshot.map((entry, index) => {
        const result = byLine.get(index + 1) || (entry.uid > 0 ? byUID.get(entry.uid) : undefined)
        if (!result) return entry
        return {
          ...entry,
          uid: Number(result.uid || entry.uid || 0),
          checkStatus: normalizeCookieCheckStatus(result.status),
          checkMessage: result.status === 'valid' ? '' : String(result.message || '').trim(),
          checkedAt: Number(result.checkedAt || Date.now()),
        }
      })

      const stats = { valid: 0, expired: 0, unknown: 0, invalid: 0 }
      nextEntries.forEach((entry) => {
        if (entry.checkStatus === 'valid') stats.valid += 1
        else if (entry.checkStatus === 'expired') stats.expired += 1
        else if (entry.checkStatus === 'unknown') stats.unknown += 1
        else if (entry.checkStatus === 'invalid') stats.invalid += 1
      })
      const failed = stats.expired + stats.unknown + stats.invalid

      setCookieEntries(nextEntries)
      writeSavedCookies(nextEntries)
      setAccounts((prev) =>
        prev.map((account) => {
          const result = byLine.get(account.line) || (account.uid > 0 ? byUID.get(account.uid) : undefined)
          if (!result) return account
          return {
            ...account,
            checkStatus: normalizeCookieCheckStatus(result.status),
            checkMessage: result.status === 'valid' ? '' : String(result.message || '').trim(),
            checkedAt: Number(result.checkedAt || Date.now()),
          }
        }),
      )

      const failedLines = new Set(
        nextEntries
          .map((entry, index) => (isCookieCheckUnusable(entry.checkStatus) ? index + 1 : 0))
          .filter((line) => line > 0),
      )
      setSelectedAccountLines((prev) => prev.filter((line) => !failedLines.has(Number(line))))

      const summary = `检查完成：可用 ${stats.valid}，失效 ${failed}`
      if (failed > 0) {
        message.warning(summary)
      } else {
        message.success(summary)
      }
    } catch (err: unknown) {
      message.error(`检查 CK 失败: ${String(err)}`)
    } finally {
      setLoading('')
    }
  }

  const clearExpiredCookies = () => {
    if (failedCookieCount === 0) return
    modal.confirm({
      title: '清理失效 CK',
      content: `确认删除 ${failedCookieCount} 条失效 CK？未检查的 CK 会保留。`,
      okText: '清理',
      cancelText: '取消',
      okButtonProps: { danger: true },
      onOk: async () => {
        const remaining = cookieEntries.filter((entry) => !isCookieCheckUnusable(entry.checkStatus))
        await applyCookieEntries(remaining, true, false)
        message.success(`已清理 ${failedCookieCount} 条失效 CK`)
      },
    })
  }

  function queryPrizes(quiet = false, selectedLines: Key[] = selectedAccountLines) {
    if (!String(form.getFieldValue('cookieText') || '').trim()) {
      if (!quiet) message.warning('Cookie 不能为空')
      return
    }
    if (selectedLines.length === 0) {
      if (!quiet) message.warning('请先选择账号')
      return
    }
    setLoading('list')
    ListPrizes(config(selectedLines))
      .then((data) => {
        const result = data as {
          prizes?: PrizeInfo[]
          categories?: PrizeTag[]
          categoryStats?: CategoryStat[]
        }
        const nextPrizes = result?.prizes || []
        if (nextPrizes.length === 0) {
          if (!quiet) message.warning('当前 CK 未返回可选商品')
          return
        }
        const nextCategories = result?.categories || []
        const nextStats = result?.categoryStats || []
        const updatedAt = Date.now()
        setPrizes(nextPrizes)
        setPrizeCategories(nextCategories)
        setCategoryStats(nextStats)
        setActiveCategory((prev) =>
          prev && nextCategories.some((tag) => String(tag.id) === prev) ? prev : '',
        )
        setPrizeCacheUpdatedAt(updatedAt)
        writeSavedPrizeCache(nextPrizes, Number(form.getFieldValue('sid') || 0), nextCategories, nextStats)
        setSelectedPrizeKeys((prev) =>
          prev.filter((key) => nextPrizes.some((item) => item.id === Number(key))),
        )
        if (!quiet) {
          const summary = nextStats.map((item) => `${item.name} ${item.count ?? 0}`).join(' / ')
          message.success(summary ? `商品已刷新：${summary}` : '商品已刷新')
        }
      })
      .catch((err: unknown) => {
        if (!quiet) message.error(String(err))
      })
      .finally(() => {
        setLoading('')
      })
  }

  const productListUpdatedAt = prizeCacheUpdatedAt
    ? new Date(prizeCacheUpdatedAt).toLocaleString('zh-CN', { hour12: false })
    : ''

  const clearPrizeCache = () => {
    modal.confirm({
      title: '清空商品缓存',
      content: '确认清空本地缓存的商品列表？',
      okText: '清空',
      cancelText: '取消',
      okButtonProps: { danger: true },
      onOk: () => {
        localStorage.removeItem(scopedKey(prizeCacheStorageBase))
        setPrizes([])
        setPrizeCategories([])
        setCategoryStats([])
        setActiveCategory('')
        setSelectedPrizeKeys([])
        setPrizeCacheUpdatedAt(0)
        message.success('商品缓存已清空')
      }
    })
  }

  const saveSettings = () => {
    const values = config()
    const saved: SavedConfig = {
      transport: values.transport,
      wssHost: values.wssHost,
      sid: values.sid,
      pid: values.pid,
      name: values.name,
      category: values.category,
      targetText: values.targetText,
      maxPrice: values.maxPrice,
      minLeft: values.minLeft,
      delayMs: values.delayMs,
      concurrency: values.concurrency,
      windowSeconds: values.windowSeconds,
      stopAfterSuccess: values.stopAfterSuccess,
      stopAccountAfterSuccess: values.stopAccountAfterSuccess,
      prewarm: values.prewarm,
      directExchange: values.directExchange,
      sharePrizeList: values.sharePrizeList,
      autoSelect: values.autoSelect,
      refreshAfterSuccess: values.refreshAfterSuccess,
      leadMs: values.leadMs,
      timeSync: values.timeSync,
      frequentBackoffMs: values.frequentBackoffMs,
      errorBackoffMs: values.errorBackoffMs,
      timeoutSec: values.timeoutSec,
      startAt: values.startAt,
    }
    localStorage.setItem(scopedKey(configStorageBase), JSON.stringify(saved))
    message.success('已保存')
  }

  const applyPrizeSelection = (keys: Key[]) => {
    const normalized = keys.map(Number).filter((item) => item > 0)
    setSelectedPrizeKeys(normalized)
    const selected = prizes.filter((item) => normalized.includes(item.id))
    if (selected.length === 0) {
      form.setFieldsValue({ pid: 0, name: '', targetText: '' })
      return
    }
    form.setFieldsValue({
      pid: selected[0].id,
      name: selected[0].name,
      // pid/名称已经代表第一个奖品，这里只补其余奖品，避免同一奖品被提交两次。
      targetText: selected.slice(1).map((item) => String(item.id)).join('\n'),
      autoSelect: false,
    })
  }

  const startMonitor = (scheduled: boolean) => {
    const values = config()
    if (values.selectedAccountLines.length === 0) {
      message.warning('请先选择账号')
      return undefined
    }
    const countdown = scheduled ? buildScheduleCountdown(values.startAt, values.leadMs, now) : null
    if (scheduled && !countdown) {
      message.warning('请先填写定时目标时间（HH:mm:ss）')
      return undefined
    }
    if (!scheduled) {
      values.startAt = ''
      setScheduleCountdown(null)
    }
    setResults([])
    return runAction('monitor', () => StartMonitor(values), () => {
      setRunning(true)
      setScheduleCountdown(countdown)
    })
  }

  const directExchange = () => {
    const values = config()
    if (values.selectedAccountLines.length === 0) {
      message.warning('请先选择账号')
      return undefined
    }
    if (Number(values.pid || 0) <= 0) {
      message.warning('请先在左侧商品列表中选择要兑换的商品')
      return undefined
    }
    return runAction(
      'exchange',
      () => Exchange(values),
      (data) => {
        const items = (data || []) as ExchangeResult[]
        setResults(
          items.map((item, index) => ({
            key: `exchange-${item.uid}-${index}-${Date.now()}`,
            uid: item.uid,
            action: 'exchange',
            category: item.category || (item.error ? 'error' : 'failed'),
            message: item.message || item.error || item.resp?.msg || '',
            exchange: item.resp,
          })),
        )
        const success = items.filter((item) => item.category === 'success').length
        message.info(`直接兑换：成功 ${success}/${items.length}`)
      },
    )
  }

  const openLogDir = () => runAction('logdir', () => OpenLogDir())

  const copyLogPath = async () => {
    if (!logPath) return
    await ClipboardSetText(logPath)
    message.success('已复制日志路径')
  }

  // 调试日志开关：打开后后端会把逐条网络请求也写进日志（debug 级）。
  const toggleDebugLog = async (checked: boolean) => {
    const level = await SetLogLevel(checked ? 'debug' : 'info')
    setDebugLog(level === 'debug')
    setLogStats((prev) => (prev ? { ...prev, level } : prev))
    message.success(level === 'debug' ? '已开启 debug 日志（含逐条网络请求）' : '已恢复 info 日志')
  }

  const selectAllAccounts = () => {
    setSelectedAccountLines(validAccounts.map((item) => item.line))
  }

  const clearAccounts = () => {
    setSelectedAccountLines([])
  }

  const viewAccountRecords = async (account: AccountPreview) => {
    const cached = recordsByUID.get(account.uid)
    if (cached && cached.records && cached.records.length > 0) {
      setRecordModalData({
        open: true,
        account,
        loading: false,
        records: cached.records,
        error: cached.error,
      })
      return
    }

    setRecordModalData({
      open: true,
      account,
      loading: true,
      records: cached?.records || [],
      error: undefined,
    })

    try {
      const values = config()
      const singleConfig = {
        ...values,
        selectedAccountLines: [account.line],
      }
      const data = await GetRecords(singleConfig)
      const res = (data || [])[0]
      const fetchedRecords = res?.records || []
      setRecordModalData({
        open: true,
        account,
        loading: false,
        records: fetchedRecords,
        error:
          res?.error || (res?.resp?.status && res.resp.status !== 200 ? res.resp.msg : undefined),
      })
      if (res) {
        setRecords((prev) => [...prev.filter((p) => p.uid !== account.uid), res])
      }
    } catch (err: unknown) {
      setRecordModalData({
        open: true,
        account,
        loading: false,
        records: [],
        error: String(err),
      })
    }
  }

  const accountColumns: ColumnsType<AccountPreview> = useMemo(
    () => [
      {
        title: '账号',
        width: 130,
        render: (_, row) => (
          <div>
            <strong>{row.uid || `第${row.line}行`}</strong>
            <div className="muted">
              {isCookieCheckUnusable(row.checkStatus)
                ? row.checkMessage || 'CK 已失效'
                : row.valid
                  ? row.checkStatus === 'valid'
                    ? 'CK 可用'
                    : '已加入任务'
                  : row.error || '未选择'}
            </div>
          </div>
        ),
      },
      {
        title: '凭据',
        width: 85,
        render: (_, row) =>
          row.checkStatus ? (
            cookieCheckTag(row.checkStatus, row.checkMessage)
          ) : row.valid ? (
            <Tag color="green">已加载</Tag>
          ) : (
            <Tag>无效</Tag>
          ),
      },
      {
        title: '商品',
        width: 120,
        ellipsis: true,
        render: () => currentPrize?.name || watchedName || '未选择',
      },
      {
        title: '积分',
        width: 70,
        render: (_, row) => scoreMap.get(row.uid)?.score ?? '-',
      },
      {
        title: '兑换结果',
        width: 150,
        render: (_, row) => {
          const exchange = exchangeByUID.get(row.uid)
          if (exchange?.success) {
            const orderID = exchangeOrderID(exchange.success.exchange)
            return (
              <div>
                <Tag color="success">已抢到</Tag>
                <div className="muted">{exchange.success.prize?.name || currentPrize?.name || ''}</div>
                {orderID ? (
                  <div className="muted" title={orderID}>
                    单号 {orderID}
                  </div>
                ) : null}
              </div>
            )
          }
          if (exchange?.failed) {
            return (
              <div>
                <Tag color="error">未成功</Tag>
                <div className="muted">
                  {exchange.failed.error ||
                    exchange.failed.message ||
                    exchange.failed.exchange?.msg ||
                    '兑换失败'}
                </div>
                {exchange.attempts > 1 ? (
                  <div className="muted">已尝试 {exchange.attempts} 次</div>
                ) : null}
              </div>
            )
          }
          const record = recordHitByUID.get(row.uid)
          if (record) {
            return (
              <div>
                <Tag color="blue">已兑换</Tag>
                <div className="muted">{record.name || ''}</div>
                {record.order_id ? (
                  <div className="muted" title={record.order_id}>
                    单号 {record.order_id}
                  </div>
                ) : null}
              </div>
            )
          }
          return (
            <div>
              <Tag color={running ? 'processing' : 'default'}>{running ? '抢购中' : '待抢购'}</Tag>
              {exchange?.skipped ? <div className="muted">已跳过重复兑换</div> : null}
            </div>
          )
        },
      },
      {
        title: '状态',
        width: 80,
        render: (_, row) => categoryTag(latestResultByUID.get(row.uid)?.category),
      },
      {
        title: '最后结果',
        width: 130,
        ellipsis: true,
        render: (_, row) => {
          const result = latestResultByUID.get(row.uid)
          return result?.error || result?.message || result?.exchange?.msg || ''
        },
      },
      {
        title: '兑换记录',
        width: 90,
        render: (_, row) => {
          const rec = recordsByUID.get(row.uid)
          const count = rec?.records?.length || 0
          return (
            <Button
              size="small"
              icon={<History size={13} />}
              onClick={(e) => {
                e.stopPropagation()
                viewAccountRecords(row)
              }}
            >
              {count > 0 ? `记录 (${count})` : '记录'}
            </Button>
          )
        },
      },
    ],
    [
      currentPrize?.name,
      exchangeByUID,
      latestResultByUID,
      recordHitByUID,
      recordsByUID,
      running,
      scoreMap,
      watchedName,
    ],
  )

  const cookieColumns: ColumnsType<CookieEntry> = useMemo(
    () => [
      {
        title: '账号',
        width: 140,
        render: (_, row) => (
          <div>
            <strong>{row.uid || '-'}</strong>
            <div className="muted">
              {isCookieCheckUnusable(row.checkStatus) ? 'CK 已失效' : row.valid ? '可解析 UID' : row.error || '待校验'}
            </div>
          </div>
        ),
      },
      {
        title: '格式',
        width: 78,
        render: (_, row) => (row.valid ? <Tag color="green">有效</Tag> : <Tag color="default">无效</Tag>),
      },
      {
        title: 'CK 状态',
        width: 190,
        render: (_, row) => (
          <div>
            {cookieCheckTag(row.checkStatus, row.checkMessage)}
            {row.checkStatus && row.checkStatus !== 'valid' && row.checkMessage ? (
              <div className="muted ck-check-message" title={row.checkMessage}>
                {row.checkMessage}
              </div>
            ) : null}
            {row.checkedAt ? (
              <div className="muted">检查于 {new Date(row.checkedAt).toLocaleString('zh-CN', { hour12: false })}</div>
            ) : null}
          </div>
        ),
      },
      {
        title: 'CK',
        ellipsis: true,
        render: (_, row) => <code className="ck-text-preview">{row.text}</code>,
      },
      {
        title: '更新时间',
        width: 170,
        render: (_, row) => new Date(row.updatedAt).toLocaleString('zh-CN', { hour12: false }),
      },
      {
        title: '操作',
        width: 150,
        render: (_, row) => (
          <Space size={6}>
            <Button size="small" icon={<Pencil size={14} />} onClick={() => openEditCookie(row)}>
              编辑
            </Button>
            <Button size="small" danger icon={<Trash2 size={14} />} onClick={() => deleteCookie(row)}>
              删除
            </Button>
          </Space>
        ),
      },
    ],
    [cookieEntries],
  )

  const prizeColumns: ColumnsType<PrizeInfo> = useMemo(
    () => [
      { title: 'PID', dataIndex: 'id', width: 92 },
      { title: '名称', dataIndex: 'name', minWidth: 220, ellipsis: true },
      { title: '库存', minWidth: 190, render: (_, row) => inventoryText(row) },
      { title: '价格', width: 84, render: (_, row) => priceOf(row) || '-' },
    ],
    [],
  )

  const scoreColumns: ColumnsType<ScoreResult> = useMemo(
    () => [
      { title: 'UID', dataIndex: 'uid', width: 140 },
      { title: '可用积分', dataIndex: 'score', width: 110 },
      { title: '状态', width: 90, render: (_, row) => statusTag(row.resp?.status, row.error) },
      { title: '消息', render: (_, row) => row.error || row.resp?.msg || '' },
    ],
    [],
  )

  const totalRecordCount = useMemo(() => {
    return records.reduce((sum, item) => sum + (item.records?.length || 0), 0)
  }, [records])

  const recordRows = useMemo<RecordRow[]>(() => {
    const rows: RecordRow[] = []
    records.forEach((item) => {
      if (!item.records?.length) {
        const emptyMsg =
          item.error ||
          (item.resp?.status && item.resp.status !== 200 ? item.resp.msg : '（无兑换记录）')
        rows.push({
          key: `${item.uid}-empty`,
          uid: item.uid,
          name: emptyMsg,
        })
        return
      }
      item.records.forEach((record, index) => {
        rows.push({
          key: `${item.uid}-${index}-${record.id || 'record'}`,
          uid: item.uid,
          ...record,
        })
      })
    })
    return rows
  }, [records])

  const recordColumns: ColumnsType<RecordRow> = useMemo(
    () => [
      { title: 'UID', dataIndex: 'uid', width: 140 },
      {
        title: '名称',
        dataIndex: 'name',
        minWidth: 200,
        ellipsis: true,
        render: (name, row) => (
          <Space orientation="horizontal" size={6}>
            {row.img ? (
              <img
                src={row.img}
                alt={name}
                style={{ width: 24, height: 24, borderRadius: 4, objectFit: 'cover' }}
              />
            ) : null}
            <span>{name}</span>
          </Space>
        ),
      },
      {
        title: '积分',
        width: 90,
        render: (_, row) =>
          row.new_score || row.score ? `${row.new_score || row.score} 分` : '-',
      },
      {
        title: '状态',
        dataIndex: 'status',
        width: 84,
        render: (status) =>
          status === 200 || !status ? <Tag color="success">成功</Tag> : <Tag>{status}</Tag>,
      },
      {
        title: '订单号',
        dataIndex: 'order_id',
        minWidth: 220,
        render: (orderId) =>
          orderId ? (
            <div className="order-id-cell">
              <span>{orderId}</span>
              <Button
                type="text"
                size="small"
                icon={<Copy size={12} />}
                title="复制单号"
                onClick={() => {
                  navigator.clipboard.writeText(orderId)
                  message.success('已复制单号')
                }}
              />
            </div>
          ) : (
            '-'
          ),
      },
      { title: '时间', width: 160, render: (_, row) => formatUnixTime(row.create_time) },
    ],
    [message],
  )

  const resultColumns: ColumnsType<MonitorResult> = useMemo(
    () => [
      { title: '轮次', dataIndex: 'loop', width: 70 },
      { title: 'UID', dataIndex: 'uid', width: 132 },
      { title: '动作', dataIndex: 'action', width: 112 },
      { title: '分类', width: 90, render: (_, row) => categoryTag(row.category) },
      {
        title: '奖品',
        minWidth: 220,
        ellipsis: true,
        render: (_, row) => row.prize?.name || getExchangeInfo(row.exchange).desc || '',
      },
      {
        title: '消息',
        render: (_, row) =>
          row.error ||
          row.message ||
          row.exchange?.msg ||
          getPreCondition(row.exchange).tip ||
          row.exchange?.order_id ||
          row.exchange?.orderId ||
          '',
      },
    ],
    [],
  )

  const panelTabs = [
    {
      key: 'logs',
      label: '日志',
      children: (
        <div className="log-pane">
          <div className="log-tools">
            <span className="log-path" title={logPath || '日志文件不可用'}>
              {instanceInfo ? `${instanceInfo.name} · ` : ''}
              {logPath || '日志文件不可用'}
            </span>
            <Space size={6}>
              <Tooltip title="打开日志目录">
                <Button
                  size="small"
                  icon={<FolderOpen size={14} />}
                  disabled={!logPath}
                  onClick={openLogDir}
                />
              </Tooltip>
              <Tooltip title="复制日志路径">
                <Button size="small" icon={<Copy size={14} />} disabled={!logPath} onClick={copyLogPath} />
              </Tooltip>
            </Space>
          </div>
          <div className="log-tools">
            <Select
              size="small"
              value={logFilter}
              style={{ width: 116 }}
              onChange={setLogFilter}
              options={logFilterOptions}
            />
            <Space size={8}>
              <Button
                size="small"
                icon={<Copy size={13} />}
                disabled={visibleLogs.length === 0}
                onClick={() => {
                  const text = visibleLogs
                    .map(
                      (l) =>
                        `${l.time} [${l.category}][${l.level}]${l.account ? `[账号:${l.account}]` : ''} ${l.message}`,
                    )
                    .join('\n')
                  navigator.clipboard.writeText(text)
                  message.success(`已复制 ${visibleLogs.length} 条日志`)
                }}
              >
                复制
              </Button>
              <Button size="small" disabled={logs.length === 0} onClick={() => setLogs([])}>
                清空
              </Button>
              <Tooltip title="开启后记录逐条网络请求（debug 级）">
                <Switch
                  size="small"
                  checked={debugLog}
                  checkedChildren="调试"
                  unCheckedChildren="常规"
                  onChange={toggleDebugLog}
                />
              </Tooltip>
              <span className="log-path">共 {logs.length} 条</span>
            </Space>
          </div>
          {logStats && logStats.dropped > 0 ? (
            <div className="log-path">日志队列已丢弃 {logStats.dropped} 条（磁盘写入压力过大）</div>
          ) : null}
          <LogView logs={visibleLogs} />
        </div>
      ),
    },
    {
      key: 'results',
      label: '结果',
      children: (
        <Table
          size="small"
          rowKey={(row) => row.key || `${row.uid}-${row.loop}`}
          columns={resultColumns}
          dataSource={results}
          pagination={{ pageSize: 12, showSizeChanger: false }}
          scroll={{ x: 820, y: 520 }}
        />
      ),
    },
    {
      key: 'stats',
      label: '统计',
      children: (
        <div className="stats-pane">
          <Statistic title="成功账号" value={successCount} />
          <Statistic title="异常事件" value={errorCount} />
          <Statistic title="待处理账号" value={pendingCount} />
          <Statistic title="日志条数" value={logs.length} />
          <Statistic title="丢弃日志" value={logStats?.dropped || 0} />
        </div>
      ),
    },
    {
      key: 'records',
      label: `兑换记录${totalRecordCount > 0 ? ` (${totalRecordCount})` : ''}`,
      children: (
        <Table
          size="small"
          rowKey={(row) => row.key}
          columns={recordColumns}
          dataSource={recordRows}
          pagination={{ pageSize: 12, showSizeChanger: false }}
          scroll={{ x: 740, y: 520 }}
          locale={{ emptyText: '暂无兑换记录，可勾选账号后点击上方「兑换记录」按钮或账号行的「记录」按钮进行查询' }}
        />
      ),
    },
  ]

  return (
    <Form form={form} component={false}>
      <div className="app-shell">
        <aside className="product-sidebar">
          <div className="sidebar-head">
            <div>
              <Typography.Title level={4}>虎牙抢购</Typography.Title>
              <Typography.Text type="secondary">实时库存 · 多账号 · 定时触发</Typography.Text>
            </div>
            <Tag>{appVersion || '…'}</Tag>
          </div>

          <Button
            type="primary"
            block
            icon={<RefreshCw size={16} />}
            loading={loading === 'list'}
            disabled={selectedAccountCount === 0}
            onClick={() => queryPrizes()}
          >
            用 CK 刷新商品
          </Button>

          <Input.Search
            allowClear
            className="product-search"
            value={productSearch}
            onChange={(event) => setProductSearch(event.target.value)}
            onSearch={setProductSearch}
          />

          {categoryItems.length > 1 ? (
            <Tabs
              className="category-tabs"
              size="small"
              activeKey={activeCategory}
              onChange={(key) => setActiveCategory(String(key))}
              items={categoryItems}
            />
          ) : null}

          <CurrentProduct prize={currentPrize} now={now} categories={prizeCategories} />

          <div className="inventory-line">
            <span>商品缓存 {filteredPrizes.length} 个</span>
            <span>{inventorySummary}</span>
            <span>{productListUpdatedAt ? `更新 ${productListUpdatedAt}` : '未缓存'}</span>
          </div>

          <div className="product-list">
            {filteredPrizes.length === 0 ? (
              <div className="product-empty">
                <strong>暂无商品缓存</strong>
                <span>导入有效 CK 后刷新最新商品</span>
              </div>
            ) : (
              filteredPrizes.map((item) => {
                const sale = saleStateOf(item, now)
                return (
                  <button
                    type="button"
                    className={`product-row ${selectedPrizeKeys.includes(item.id) ? 'selected' : ''}`}
                    key={item.id}
                    onClick={() => applyPrizeSelection([item.id])}
                  >
                    <div className="product-thumb">
                      {item.img ? (
                        <img src={item.img} alt="" />
                      ) : (
                        <span>{String(item.id).slice(-2)}</span>
                      )}
                    </div>
                    <div className="product-meta">
                      <strong>{item.name}</strong>
                      <div className="product-tags">
                        <Tag color="gold">{priceOf(item)} 积分</Tag>
                        {categoryNamesOf(item, prizeCategories).map((name) => (
                          <Tag key={name} color="purple">
                            {name}
                          </Tag>
                        ))}
                        {sale.onSale ? (
                          <InventoryTags prize={item} compact />
                        ) : (
                          <Tag color="orange">{sale.label}</Tag>
                        )}
                      </div>
                      {sale.onSale ? null : (
                        <span className="product-hint">{sale.countdown} 后上架</span>
                      )}
                    </div>
                  </button>
                )
              })
            )}
          </div>
        </aside>

        <main className="desk">
          <header className="topbar">
            <div className="tab-strip">
              <Button type="primary">抢购控制台</Button>
              <Button onClick={() => setCookieManagerOpen(true)}>CK 管理</Button>
            </div>
            <CountdownBadge countdown={scheduleCountdown} now={now} running={running} />
            <Space size={12}>
              <Tooltip
                title={instanceInfo?.dataDir ? `实例数据目录: ${instanceInfo.dataDir}` : '实例信息未就绪'}
              >
                <Tag color="blue">{instanceInfo?.name || '默认实例'}</Tag>
              </Tooltip>
              <Tag>{String(watchedTransport || 'wss').toUpperCase()}</Tag>
              <Button icon={<Settings size={16} />} onClick={() => setSettingsOpen(true)}>
                设置
              </Button>
              <Tag color={running ? 'processing' : 'default'}>{running ? '运行中' : '空闲'}</Tag>
            </Space>
          </header>

          <section className="statusbar">
            <span>服务器</span>
            <strong className="status-time">{formatClock(now)}</strong>
            <span>账号</span>
            <strong className="status-count status-account-count">
              {selectedAccountCount}/{validAccounts.length}
            </strong>
            <span>成功</span>
            <strong className="status-count green">{successCount}</strong>
            <span>异常</span>
            <strong className="status-count red">{errorCount}</strong>
            <span>待处理</span>
            <strong className="status-count">{pendingCount}</strong>
          </section>

          <section className="actionbar">
            <Space wrap>
              <Button
                danger
                type="primary"
                icon={<ShoppingCart size={16} />}
                loading={loading === 'monitor'}
                disabled={running || selectedAccountCount === 0}
                onClick={() => startMonitor(false)}
              >
                立即抢购
              </Button>
              <Button
                className="green-button"
                type="primary"
                icon={<Play size={16} />}
                loading={loading === 'monitor'}
                disabled={running || selectedAccountCount === 0}
                onClick={() => startMonitor(true)}
              >
                开启定时
              </Button>
              <Button
                icon={<Zap size={16} />}
                loading={loading === 'exchange'}
                disabled={running || selectedAccountCount === 0}
                onClick={directExchange}
              >
                直接兑换
              </Button>
              <Button
                icon={<ClipboardPaste size={16} />}
                loading={loading === 'clipboard'}
                onClick={importCookiesFromClipboard}
              >
                剪贴板导入 CK
              </Button>
              <Button
                icon={<RefreshCw size={16} />}
                loading={loading === 'score'}
                disabled={selectedAccountCount === 0}
                onClick={() => {
                  const values = config()
                  if (values.selectedAccountLines.length === 0) {
                    message.warning('请先选择账号')
                    return
                  }
                  runAction('score', () => QueryScores(values), (data) =>
                    setScores((data || []) as ScoreResult[]),
                  )
                }}
              >
                查询积分
              </Button>
              <Button
                icon={<ShieldCheck size={16} />}
                loading={loading === 'cookie-check'}
                disabled={running || cookieEntries.length === 0}
                onClick={checkCookies}
              >
                CK 有效性
              </Button>
              <Button
                icon={<ClipboardList size={16} />}
                loading={loading === 'records'}
                disabled={selectedAccountCount === 0}
                onClick={() => {
                  const values = config()
                  if (values.selectedAccountLines.length === 0) {
                    message.warning('请先选择账号')
                    return
                  }
                  runAction('records', () => GetRecords(values), (data) => {
                    const list = (data || []) as RecordResult[]
                    setRecords(list)
                    setPanelTab('records')
                    const total = list.reduce((sum, item) => sum + (item.records?.length || 0), 0)
                    message.success(`查询完成：${list.length} 个账号，共 ${total} 条兑换记录`)
                  })
                }}
              >
                兑换记录
              </Button>
              <Button
                icon={<Square size={16} />}
                disabled={!running}
                onClick={async () => {
                  await StopMonitor()
                  setRunning(false)
                  setScheduleCountdown(null)
                }}
              >
                停止
              </Button>
            </Space>
            <Space className="schedule-target">
              <span className="muted">定时目标</span>
              <Form.Item name="startAt" noStyle>
                <ScheduleTimeInput />
              </Form.Item>
            </Space>
          </section>

          <section
            className={`main-grid ${isDraggingSplit ? 'dragging-split' : ''}`}
            ref={mainGridRef}
          >
            <div
              className="account-panel"
              style={{
                width: `calc(${mainSplit}% - 11px)`,
                flexShrink: 0,
              }}
            >
              <div className="panel-head">
                <Typography.Title level={5}>账号作战表</Typography.Title>
                <Space>
                  <Tag>{validAccounts.length} 个账号</Tag>
                  <Tag color="blue">已选 {selectedAccountCount}</Tag>
                  <Button size="small" icon={<ListChecks size={14} />} onClick={selectAllAccounts}>
                    全选
                  </Button>
                  <Button size="small" icon={<Square size={14} />} onClick={clearAccounts}>
                    清空
                  </Button>
                  <Tooltip title="保存设置">
                    <Button size="small" icon={<Save size={14} />} onClick={saveSettings} />
                  </Tooltip>
                </Space>
              </div>
              <Table
                size="small"
                rowKey={(row) => row.line}
                rowSelection={{
                  selectedRowKeys: selectedAccountLines,
                  onChange: setSelectedAccountLines,
                  getCheckboxProps: (row) => ({
                    disabled: !row.valid || isCookieCheckUnusable(row.checkStatus),
                  }),
                }}
                columns={accountColumns}
                dataSource={accounts}
                pagination={false}
                rowClassName={(row) =>
                  exchangeByUID.get(row.uid)?.success ? 'account-row-success' : ''
                }
                scroll={{ x: 'max-content', y: 560 }}
              />
            </div>

            <div
              className={`main-resizer ${isDraggingSplit ? 'active' : ''}`}
              onMouseDown={handleSplitMouseDown}
              onDoubleClick={handleSplitDoubleClick}
              title="按住左右拖动调整宽度，双击恢复默认"
            >
              <div className="resizer-bar" />
            </div>

            <div
              className="side-log-panel"
              style={{
                flex: 1,
                minWidth: 0,
              }}
            >
              <div className="panel-tools">
                <Tabs activeKey={panelTab} onChange={setPanelTab} items={panelTabs} size="small" />
              </div>
            </div>
          </section>

        </main>
      </div>
      <Form.Item name="name" hidden>
        <Input />
      </Form.Item>
      <Form.Item name="targetText" hidden>
        <Input />
      </Form.Item>
      <Form.Item name="cookieText" hidden>
        <Input />
      </Form.Item>
      <Modal
        title="CK 管理"
        open={cookieManagerOpen}
        width="min(1080px, calc(100vw - 48px))"
        style={{ maxWidth: 'calc(100vw - 24px)' }}
        styles={{
          body: {
            maxHeight: 'calc(100vh - 180px)',
            overflowY: 'auto',
            overflowX: 'hidden',
          },
        }}
        onCancel={() => setCookieManagerOpen(false)}
        footer={null}
      >
        <div className="ck-manager">
          <div className="ck-manager-tools">
            <Space wrap>
              <Button type="primary" icon={<Plus size={16} />} onClick={openNewCookie}>
                新增 CK
              </Button>
              <Button
                icon={<ClipboardPaste size={16} />}
                loading={loading === 'clipboard'}
                onClick={importCookiesFromClipboard}
              >
                剪贴板导入
              </Button>
              <Button icon={<RefreshCw size={16} />} onClick={reloadSavedCookies}>
                重新载入
              </Button>
              <Button
                icon={<ShieldCheck size={16} />}
                loading={loading === 'cookie-check'}
                disabled={running || cookieEntries.length === 0}
                onClick={checkCookies}
              >
                检查 CK 有效性
              </Button>
            </Space>
            <Space wrap>
              <Tag>{cookieEntries.length} 条 CK</Tag>
              <Tag color="green">{cookieCheckStats.valid} 可用</Tag>
              {failedCookieCount > 0 ? <Tag color="error">{failedCookieCount} 失效</Tag> : null}
              {cookieCheckStats.unchecked > 0 ? <Tag>{cookieCheckStats.unchecked} 未检查</Tag> : null}
              <Button
                danger
                icon={<Trash2 size={16} />}
                disabled={failedCookieCount === 0}
                onClick={clearExpiredCookies}
              >
                清理失效
              </Button>
              <Button
                danger
                icon={<Trash2 size={16} />}
                disabled={cookieEntries.length === 0}
                onClick={clearCookies}
              >
                清空
              </Button>
            </Space>
          </div>
          <Table
            size="small"
            rowKey={(row) => row.id}
            columns={cookieColumns}
            dataSource={cookieEntries}
            pagination={{ pageSize: 8, showSizeChanger: false }}
            scroll={{ x: 1000, y: 430 }}
          />
        </div>
      </Modal>
      <Modal
        title={editingCookie ? '编辑 CK' : '新增 CK'}
        open={cookieEditOpen}
        okText="保存"
        cancelText="取消"
        confirmLoading={loading === 'cookie-save'}
        onOk={saveCookieDraft}
        onCancel={() => {
          setCookieEditOpen(false)
          setCookieDraft('')
          setEditingCookie(null)
        }}
      >
        <Input.TextArea
          rows={editingCookie ? 5 : 8}
          spellCheck={false}
          value={cookieDraft}
          onChange={(event) => setCookieDraft(event.target.value)}
        />
      </Modal>
      <Modal
        title="设置"
        open={settingsOpen}
        width={760}
        onCancel={() => setSettingsOpen(false)}
        footer={[
          <Button key="close" onClick={() => setSettingsOpen(false)}>
            关闭
          </Button>,
          <Button
            key="save"
            type="primary"
            icon={<Save size={16} />}
            onClick={() => {
              saveSettings()
              setSettingsOpen(false)
            }}
          >
            保存
          </Button>,
        ]}
      >
        <div className="settings-modal">
          <div className="settings-grid">
            <Form.Item name="transport" label="传输">
              <Select
                options={[
                  { value: 'wss', label: 'WSS' },
                  { value: 'http', label: 'HTTP' },
                ]}
              />
            </Form.Item>
            <Form.Item name="wssHost" label="WSS Host">
              <Input allowClear placeholder="留空自动解析" />
            </Form.Item>
            <div className="settings-summary settings-wide">
              <Typography.Text type="secondary">CK 来源</Typography.Text>
              <strong>
                {importedCookieCount > 0
                  ? `已导入 ${validAccounts.length}/${importedCookieCount} 个有效账号`
                  : '未导入 CK'}
              </strong>
            </div>
            <div className="settings-summary settings-wide">
              <Typography.Text type="secondary">商品缓存</Typography.Text>
              <Space size={8}>
                <strong>
                  {prizes.length > 0
                    ? `${prizes.length} 个 · ${productListUpdatedAt || '未知时间'}`
                    : '未缓存'}
                </strong>
                <Button size="small" disabled={prizes.length === 0} onClick={clearPrizeCache}>
                  清空
                </Button>
              </Space>
            </div>
          </div>
          <div className="settings-param-grid">
            <Form.Item name="sid" label="SID">
              <InputNumber min={1} />
            </Form.Item>
            <Form.Item name="pid" label="PID">
              <InputNumber min={0} />
            </Form.Item>
            <Form.Item name="maxPrice" label="最高积分">
              <InputNumber min={0} />
            </Form.Item>
            <Form.Item name="minLeft" label="最少库存">
              <InputNumber min={0} />
            </Form.Item>
            <Form.Item name="windowSeconds" label="窗口秒" tooltip="跑到「开抢 + 窗口秒数」才收工；账号会在整个窗口内独立重试，直到成功、窗口结束或收到停止指令">
              <InputNumber min={1} max={600} addonAfter="s" />
            </Form.Item>
            <Form.Item name="delayMs" label="延时">
              <InputNumber min={10} max={60000} addonAfter="ms" />
            </Form.Item>
            <Form.Item name="concurrency" label="线程" tooltip="同时在途请求上限，默认 30。保证单实例 30 账号在开抢首波 300ms 错峰期间全员免排队出击；5 实例多开整机并发在途约 150">
              <InputNumber min={1} max={100} />
            </Form.Item>
            <Form.Item name="leadMs" label="提前" tooltip="留空或 0 = 按服务端时钟校准误差动态计算（通常几十毫秒）；填了就用固定提前量">
              <InputNumber min={0} max={10000} addonAfter="ms" placeholder="0=动态" />
            </Form.Item>
          </div>
          <div className="settings-switch-grid">
            <Form.Item
              name="prewarm"
              label="预热"
              valuePropName="checked"
              tooltip="默认开启。开抢前 10 秒在后台异步建连，开抢前 5 秒就绪待命，享受首发零延迟；独立协程运行，绝不阻塞发令枪"
            >
              <Switch />
            </Form.Item>
            <Form.Item name="directExchange" label="直兑" valuePropName="checked">
              <Switch />
            </Form.Item>
            <Form.Item name="sharePrizeList" label="共享列表" valuePropName="checked">
              <Switch />
            </Form.Item>
            <Form.Item name="autoSelect" label="自动选品" valuePropName="checked">
              <Switch />
            </Form.Item>
            <Form.Item name="stopAccountAfterSuccess" label="账号成功停" valuePropName="checked">
              <Switch />
            </Form.Item>
            <Form.Item name="refreshAfterSuccess" label="成功刷新" valuePropName="checked">
              <Switch />
            </Form.Item>
            <Form.Item name="timeSync" label="时间校准" valuePropName="checked" tooltip="定时前用 pingSignal 校准服务端时间，按钟差对齐触发时刻">
              <Switch />
            </Form.Item>
          </div>
        </div>
      </Modal>
      <Modal
        title={
          <Space>
            <span>兑换记录明细</span>
            {recordModalData.account ? (
              <Tag color="blue">UID: {recordModalData.account.uid}</Tag>
            ) : null}
            {!recordModalData.loading ? (
              <Tag color={recordModalData.records.length > 0 ? 'green' : 'default'}>
                共 {recordModalData.records.length} 条
              </Tag>
            ) : null}
          </Space>
        }
        open={recordModalData.open}
        width="min(860px, calc(100vw - 48px))"
        footer={null}
        onCancel={() => setRecordModalData((prev) => ({ ...prev, open: false }))}
      >
        {recordModalData.loading ? (
          <div style={{ textAlign: 'center', padding: '36px 0' }}>
            <Typography.Text type="secondary">正在向虎牙服务器查询该账号兑换记录...</Typography.Text>
          </div>
        ) : recordModalData.error ? (
          <div style={{ padding: '16px 0' }}>
            <Tag color="error">查询失败</Tag>
            <span>{recordModalData.error}</span>
          </div>
        ) : recordModalData.records.length === 0 ? (
          <div style={{ textAlign: 'center', padding: '36px 0' }}>
            <Typography.Text type="secondary">暂无兑换记录（该账号在当前活动下尚无成功订单）</Typography.Text>
          </div>
        ) : (
          <Table
            size="small"
            className="record-modal-table"
            rowKey={(r, idx) => `${r.id || idx}-${r.order_id || ''}`}
            dataSource={recordModalData.records}
            pagination={{ pageSize: 8, showSizeChanger: false }}
            columns={[
              {
                title: '商品',
                dataIndex: 'name',
                render: (name, r) => (
                  <Space orientation="horizontal" size={8}>
                    {r.img ? (
                      <img
                        src={r.img}
                        alt={name}
                        style={{ width: 32, height: 32, borderRadius: 4, objectFit: 'cover' }}
                      />
                    ) : null}
                    <div>
                      <strong>{name || '未知商品'}</strong>
                      {r.prize_id ? <div className="muted">PID: {r.prize_id}</div> : null}
                    </div>
                  </Space>
                ),
              },
              {
                title: '消耗积分',
                width: 110,
                render: (_, r) => <Tag color="orange">{r.new_score || r.score || 0} 积分</Tag>,
              },
              {
                title: '订单号',
                dataIndex: 'order_id',
                width: 260,
                render: (orderId) =>
                  orderId ? (
                    <div className="order-id-cell">
                      <span>{orderId}</span>
                      <Button
                        type="text"
                        size="small"
                        icon={<Copy size={12} />}
                        title="复制单号"
                        onClick={() => {
                          navigator.clipboard.writeText(orderId)
                          message.success('已复制单号')
                        }}
                      />
                    </div>
                  ) : (
                    '-'
                  ),
              },
              {
                title: '兑换时间',
                width: 170,
                render: (_, r) => formatUnixTime(r.create_time),
              },
              {
                title: '状态',
                width: 80,
                render: () => <Tag color="success">成功</Tag>,
              },
            ]}
          />
        )}
      </Modal>
    </Form>
  )
}

function InventoryTags({ prize, compact = false }: { prize?: PrizeInfo; compact?: boolean }) {
  const info = inventoryOf(prize)
  const left = info.left === undefined ? '-' : `${info.estimated ? '约 ' : ''}${info.left}`
  const total = info.total === undefined ? '-' : String(info.total)
  return (
    <span className={`inventory-tags${compact ? ' compact' : ''}`}>
      <Tag color={info.left === 0 ? 'red' : 'green'}>剩余 {left}</Tag>
      <Tag>总量 {total}</Tag>
      {info.percent ? <Tag color="blue">{info.percent}</Tag> : null}
    </span>
  )
}

function CurrentProduct({
  prize,
  now,
  categories,
}: {
  prize?: PrizeInfo
  now: Date
  categories: PrizeTag[]
}) {
  const name = prize?.name || '未从 CK 列表选择'
  const sale = saleStateOf(prize, now)
  return (
    <div className="current-product">
      <span>当前商品</span>
      <strong>{name}</strong>
      <div className="current-product-tags">
        {prize ? (
          <>
            <Tag color="gold">{priceOf(prize)} 积分</Tag>
            <Tag>PID {prize.id}</Tag>
            {categoryNamesOf(prize, categories).map((item) => (
              <Tag key={item} color="purple">
                {item}
              </Tag>
            ))}
            {sale.onSale ? <InventoryTags prize={prize} /> : <Tag color="orange">{sale.label}</Tag>}
          </>
        ) : (
          <Tag>CK 商品源</Tag>
        )}
      </div>
    </div>
  )
}

function CountdownBadge({
  countdown,
  now,
  running,
}: {
  countdown: ScheduleCountdown | null
  now: Date
  running: boolean
}) {
  if (!running || !countdown) return <div className="countdown-slot" />

  const remaining = countdown.fireAt - now.getTime()
  const ready = remaining <= 0

  return (
    <div className={`countdown-badge${ready ? ' ready' : ''}`}>
      <span>{ready ? '开抢中' : '距开抢'}</span>
      <strong>{ready ? '00:00:00.000' : formatCountdownDuration(remaining)}</strong>
      <small>目标 {formatTimeOfDay(new Date(countdown.targetAt))}</small>
    </div>
  )
}

function buildScheduleCountdown(
  startAt: string,
  leadMs: number,
  base: Date,
): ScheduleCountdown | null {
  const parts = parseScheduleTime(startAt)
  if (parts.every((part) => part === null)) return null

  const [hour, minute, second] = parts.map((part) => Math.max(0, Number(part || 0)))
  const target = new Date(base)
  target.setHours(Math.min(hour, 23), Math.min(minute, 59), Math.min(second, 59), 0)
  if (target.getTime() <= base.getTime()) {
    target.setDate(target.getDate() + 1)
  }
  const lead = Math.max(0, Number(leadMs || 0))
  return {
    targetAt: target.getTime(),
    fireAt: target.getTime() - lead,
  }
}

function formatCountdownDuration(ms: number): string {
  const safeMs = Math.max(0, Math.floor(ms))
  const hours = Math.floor(safeMs / 3600000)
  const minutes = Math.floor((safeMs % 3600000) / 60000)
  const seconds = Math.floor((safeMs % 60000) / 1000)
  const milliseconds = safeMs % 1000
  return `${padNumber(hours)}:${padNumber(minutes)}:${padNumber(seconds)}.${padNumber(
    milliseconds,
    3,
  )}`
}

function formatTimeOfDay(value: Date): string {
  return `${padNumber(value.getHours())}:${padNumber(value.getMinutes())}:${padNumber(
    value.getSeconds(),
  )}`
}

type ScheduleTimePart = number | null

function ScheduleTimeInput({
  value,
  onChange,
}: {
  value?: string
  onChange?: (value: string) => void
}) {
  const [parts, setParts] = useState<[ScheduleTimePart, ScheduleTimePart, ScheduleTimePart]>([
    null,
    null,
    null,
  ])

  useEffect(() => {
    const parsed = parseScheduleTime(value || '')
    setParts(parsed)
    const normalized = formatScheduleTime(parsed)
    if (value && normalized && value !== normalized) {
      onChange?.(normalized)
    }
  }, [value])

  const updatePart = (index: number, nextValue: number | string | null) => {
    const next = [...parts] as [ScheduleTimePart, ScheduleTimePart, ScheduleTimePart]
    next[index] =
      nextValue === null || nextValue === ''
        ? null
        : Math.max(0, Math.floor(Number(nextValue) || 0))
    setParts(next)
    onChange?.(formatScheduleTime(next))
  }

  return (
    <div className="schedule-time-input">
      <InputNumber
        controls={false}
        min={0}
        max={23}
        precision={0}
        placeholder="时"
        value={parts[0]}
        onChange={(next) => updatePart(0, next)}
      />
      <span className="time-separator">:</span>
      <InputNumber
        controls={false}
        min={0}
        max={59}
        precision={0}
        placeholder="分"
        value={parts[1]}
        onChange={(next) => updatePart(1, next)}
      />
      <span className="time-separator">:</span>
      <InputNumber
        controls={false}
        min={0}
        max={59}
        precision={0}
        placeholder="秒"
        value={parts[2]}
        onChange={(next) => updatePart(2, next)}
      />
    </div>
  )
}

function parseScheduleTime(value: string): [ScheduleTimePart, ScheduleTimePart, ScheduleTimePart] {
  const match = value.trim().match(/(?:^|\s)(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?$/)
  if (!match) return [null, null, null]
  return [
    Math.min(Number(match[1]), 23),
    Math.min(Number(match[2]), 59),
    Math.min(Number(match[3] || 0), 59),
  ]
}

function formatScheduleTime(parts: [ScheduleTimePart, ScheduleTimePart, ScheduleTimePart]): string {
  if (parts.every((part) => part === null)) return ''
  const [hour, minute, second] = parts.map((part) => Math.max(0, Number(part || 0)))
  return `${padNumber(Math.min(hour, 23))}:${padNumber(Math.min(minute, 59))}:${padNumber(
    Math.min(second, 59),
  )}`
}

function padNumber(value: number, size = 2): string {
  return String(value).padStart(size, '0')
}

function parseLogTime(rawTime?: string): { local: string; huya?: string } {
  if (!rawTime) return { local: '' }
  const match = rawTime.match(/^(.*?)\(H(.*?)\)$/)
  if (match) {
    return { local: match[1], huya: match[2] }
  }
  return { local: rawTime }
}

function LogView({ logs }: { logs: LogEntry[] }) {
  return (
    <div className="log-view">
      {logs.map((item) => {
        const { local, huya } = parseLogTime(item.time)
        return (
          <div className={`log-line level-${item.level}`} key={item.id}>
            <span className="log-local-time">{local}</span>
            {huya ? (
              <Tag color="cyan" className="log-huya-tag">
                H:{huya}
              </Tag>
            ) : null}
            <Tag className="log-level-tag">{item.level}</Tag>
            <code>
              {item.category ? `[${item.category}]` : ''}
              {item.account ? `[账号:${item.account}]` : ''} {item.message}
            </code>
          </div>
        )
      })}
    </div>
  )
}

function formatClock(value: Date): string {
  const pad = (num: number, size = 2) => String(num).padStart(size, '0')
  return `${value.getFullYear()}-${pad(value.getMonth() + 1)}-${pad(value.getDate())} ${pad(
    value.getHours(),
  )}:${pad(value.getMinutes())}:${pad(value.getSeconds())}.${pad(value.getMilliseconds(), 3)}`
}