/**
 * 在线播放器的会话存储。
 *
 * 用户在解析面板里选了带弹幕的那一档之后，视频**不再发到群里**，而是登记成一个
 * 「播放会话」，再把公网链接回给用户，点开就是播放页。一个会话对应一个目录：
 *
 *   <数据目录>/koishi-plugin-kkk/player/<token>/video.mp4
 *   <数据目录>/koishi-plugin-kkk/player/<token>/danmaku.json
 *
 * 会话本身放在内存的 Map 里，同时把索引写一份 sessions.json —— 宿主重启后
 * 还没过期的会话照常能看，不会因为重启就全部 404。到期由定时器统一清理
 * （删视频 + 删弹幕 + 删索引），所以链接是有寿命的。
 *
 * 注意：本文件**不要**在模块顶层 import karin 的业务模块（Common / Config 之类），
 * 那些模块在 import 时就会去读兼容层运行时状态，而插件入口是
 * bindRuntime 之前就 require 本模块的，顶层引入会直接抛异常把插件带崩。
 * 需要用到它们时一律在函数里动态 import。
 */
import crypto from 'node:crypto'
import fs from 'node:fs'
import path from 'node:path'

import { logger } from 'node-karin'

/** 播放页里的一条弹幕（已折算成统一格式） */
export interface PlayerDanmakuItem {
  /** 出现时间（毫秒） */
  time: number
  /** 类型：1/2/3 滚动，4 底部，5 顶部 */
  mode: number
  /** 字号：18 小 / 25 标准 / 36 大 */
  size: number
  /** 颜色（十进制 RGB888） */
  color: number
  /** 内容 */
  text: string
}

/** 一个播放会话 */
export interface PlayerSession {
  /** 播放令牌（链接里的那一段） */
  token: string
  /** 作品标题（播放页显示用） */
  title: string
  /** 来源平台：bilibili / douyin */
  platform: string
  /** 会话目录 */
  dir: string
  /** 视频文件绝对路径 */
  filePath: string
  /** 视频大小（字节） */
  sizeBytes: number
  /**
   * **单独的音轨文件**（可选）。
   *
   * 用户要求「默认不要服务器合并音频，浏览器里同时播放就行」：B站是分离的音视频流，
   * 以前要先用 ffmpeg 合成一条 mp4（慢、吃 CPU），现在**默认不合成** ——
   * 视频流和音频流各存一份，播放页用 `<video muted>` + `<audio>` 同时播放。
   * 只有用户点「服务器合并后下载」时才按需合成（见 server.ts 的 merged 路由）。
   * 抖音那种本身就带音轨的视频没有这个字段。
   */
  audioPath?: string
  /** 音轨大小（字节） */
  audioSizeBytes?: number
  /** 已经按需合成好的文件（会话目录里的文件名，例如 merged.mp4），第一次合并后记下来 */
  merged?: string
  /** 弹幕条数 */
  danmakuCount: number
  /** 创建时间 */
  createdAt: number
  /** 失效时间（到点删文件） */
  expireAt: number
  /**
   * 这条链接只有本机 / 内网能打开（管理员没配「播放器公网地址」）。
   *
   * 播放页上要显式写出来：用户打不开的时候得知道是「没配域名」而不是「插件坏了」。
   */
  localOnly?: boolean
  /* ---------------- 作品信息（播放页上按B站那样展示，拿不到就不显示，绝不编数据） ---------------- */
  /** UP 主 / 作者名 */
  author?: string
  /** 平台原视频链接（播放页上给一个「去 B站看」的入口，没有就不显示） */
  sourceUrl?: string
  /** 封面文件名（在会话目录里，页面上用同源地址 /kkk/player/<token>/cover 取） */
  cover?: string
  /** 播放量 */
  views?: number
  /** 弹幕条数（平台自己统计的那个，和实际存下来的条数可能差一点） */
  platformDanmaku?: number
  /** 点赞 */
  likes?: number
  /** 投币 */
  coins?: number
  /** 收藏 */
  favorites?: number
  /** 分享 */
  shares?: number
  /** 评论 */
  comments?: number
  /** 作品发布时间（毫秒） */
  publishedAt?: number
  /** 视频时长（秒） */
  durationSeconds?: number
  /**
   * 互动视频的**当前这一段**的剧情（B站互动稿才有）。
   *
   * 有它 = 播放页要出「选项」覆盖层：视频放完把这一道题和选项浮在画面上，
   * 用户点了就换到那一段继续播（分段由 getPlayerStorySource 按需下载）。
   */
  story?: PlayerStoryNode
  /** 重启后重建「取节点 / 取分段」能力用的材料（见 {@link PlayerStoryMeta}） */
  storyMeta?: PlayerStoryMeta
}

/**
 * 登记会话时可以带进来的作品信息。
 *
 * 字段和解析链路里已有的结构对齐：
 *   - B站：`infoData.data.data` 的 `title` / `owner.name` / `pic` / `stat` / `ctime` / `duration`
 *   - 抖音：`aweme_detail` 的 `desc` / `author.nickname` / `video.cover` / `statistics` / `create_time`
 * 全部可选：拿不到就留空，页面上不显示这一项。
 */
export interface PlayerWorkInfo {
  title?: string
  author?: string
  /**
   * **平台上的原视频链接**（B站：https://www.bilibili.com/video/BV…；抖音：分享链接）。
   *
   * 播放页上要显示它：用户在这个页面里看到「本页链接」没有任何意义（你已经在上面了），
   * 有意义的是「原视频在哪」—— 想去发弹幕、想看评论区、想分享给朋友，都得回平台。
   */
  sourceUrl?: string
  /** 封面的远程地址（登记时下载到会话目录，页面用同源地址取） */
  coverUrl?: string
  views?: number
  platformDanmaku?: number
  likes?: number
  coins?: number
  favorites?: number
  shares?: number
  comments?: number
  publishedAt?: number
  durationSeconds?: number
}

/* ------------------------------------------------------------------ *
 * 互动视频（B站互动稿）在播放页里的剧情数据
 * ------------------------------------------------------------------ */

/** 播放页上的一个剧情选项 */
export interface PlayerStoryChoice {
  /** 选项标签：A / B / C…（B站 下发的前缀已经洗掉，标签是我们按顺序排的） */
  label: string
  /** 选项文字（已经洗过，直接显示） */
  text: string
  /** 选了之后要播的那一段 cid（前端拿它去请求 /segment/<cid>） */
  cid: number
  /** 请求下一组选项时要带的边 id */
  edgeId: number
}

/** 播放页上的一个剧情节点（= 一段视频 + 一道题） */
export interface PlayerStoryNode {
  /** 这一段的 cid */
  cid: number
  /** 题目（B站 有时给空串） */
  question: string
  /** 结局段（没有选项可选） */
  isLeaf: boolean
  choices: PlayerStoryChoice[]
}

/**
 * 剧情数据的**实时来源**（登记会话时由平台注入）。
 *
 * 为什么不落盘：剧情节点要现问接口、分段视频要现下载，都是「平台侧的能力」，存不进 JSON。
 * 插件重启后这里就是空的 —— 播放页会退化成普通播放页（视频照常能看），这是有意的降级：
 * 宁可没有选项，也不能给出一排点了没反应的按钮。
 */
/**
 * 互动剧情的「重建材料」。
 *
 * 平台侧那套「取节点 / 取分段」的能力是内存里的回调，宿主一重启就没了 ——
 * 于是播放页的选项按钮会消失（/story 404）。把这几项存进会话索引，重启后用工厂现造一份回来。
 */
export interface PlayerStoryMeta {
  /** 稿件 bvid */
  bvid: string
  /** 根节点（第一段）的 cid */
  cid: number
  /** 登记时是不是登录态（分段取流要用它挑分支） */
  islogin: boolean
}

/** 分段准备的进度上报：stage 是阶段名（见 SegmentStage），bytes/total 是当前这一步的字节数 */
export type SegmentReporter = (info: { stage: SegmentStage; bytes: number; total: number }) => void

/**
 * 分段准备的阶段（播放页按它显示不同的文案）：
 * - `queued`     排队中（同一条会话同一个分段只会下一次，连点的人会看到这个）
 * - `video`      正在下画面
 * - `audio`      正在下声音
 * - `merging`    正在合成（ffmpeg -c copy，通常一两秒）
 * - `ready`      好了，可以换源播放
 * - `failed`     失败（下载不动 / 合成失败）
 */
export type SegmentStage = 'queued' | 'video' | 'audio' | 'merging' | 'ready' | 'failed'

export interface PlayerStorySource {
  /** 取某个节点：不带 edgeId = 这一段自己的题目；带 = 从 cid 走这条边之后落地的节点 */
  node?: (params: { cid: number; edgeId?: number }) => Promise<PlayerStoryNode | null>
  /**
   * 按需准备某一段的视频（下载 + 合成），返回本地文件路径。
   *
   * `report` 用来把「下载了多少 / 在干嘛」交出去 —— 播放页点完选项要显示加载进度，
   * 而它只拿得到这里报的数（页面读不到服务器的终端进度条）。
   */
  segment?: (cid: number, report?: SegmentReporter) => Promise<{ filepath: string; audioPath?: string } | null>
  /**
   * 取某一段的弹幕。
   *
   * 互动视频**每段是独立的 cid，弹幕池也各是各的** —— 不按 cid 取的话，
   * 切段之后画面上飘的还是第一段那批弹幕（用户实测反馈就是这个）。
   */
  danmaku?: (cid: number) => Promise<PlayerDanmakuItem[] | null>
}

/** 把可能为空的数字洗干净（拿不到就 undefined，别在页面上显示 NaN/undefined） */
function optionalNumber (value: unknown): number | undefined {
  const num = Number(value)
  return Number.isFinite(num) && num >= 0 ? num : undefined
}

/** 有效期上下限（分钟）：配置里写歪了也按这个夹一下 */
export const PLAYER_EXPIRE_MIN_MINUTES = 1
export const PLAYER_EXPIRE_MAX_MINUTES = 1440

/** 定时清理的间隔：一分钟扫一次，够用又不费电 */
const SWEEP_INTERVAL_MS = 60 * 1000

/** 合法的令牌：只允许小写字母和数字 —— 顺带把路径穿越挡在门外 */
export const PLAYER_TOKEN_PATTERN = /^[0-9a-z]{8,64}$/

/**
 * 剧情来源表：token → 平台注入的取节点 / 取分段的能力。
 *
 * 刻意放在 store（而不是 player/index.ts）：server.ts 要用它，而 index.ts 又要 import server.ts，
 * 放 index 会形成环。这里只存「回调」，不含任何 HTTP 逻辑。
 */
const storySources = new Map<string, PlayerStorySource>()

/** 绑定一条会话的剧情来源（登记时调用；会话删除时一起清掉） */
export function bindPlayerStorySource (token: string, source: PlayerStorySource): void {
  if (isValidPlayerToken(token)) storySources.set(String(token), source)
}

/** 重启后用来「现造一份剧情来源」的工厂（由平台在加载时注册） */
export type PlayerStorySourceFactory = (meta: PlayerStoryMeta) => PlayerStorySource | null
let storySourceFactory: PlayerStorySourceFactory | null = null

/** 注册剧情来源工厂（平台模块加载时调一次） */
export function setPlayerStorySourceFactory (factory: PlayerStorySourceFactory | null): void {
  storySourceFactory = factory
}

/**
 * 取一条会话的剧情来源。
 *
 * 内存里没有就用 {@link PlayerStoryMeta} **现造一份**：宿主一重启，回调就没了，
 * 不重建的话播放页会「选项按钮直接消失、/story 404」（用户实测就是这么撞上的）。
 */
export function getPlayerStorySource (token: unknown): PlayerStorySource | undefined {
  if (!isValidPlayerToken(token)) return undefined
  const key = String(token)
  const bound = storySources.get(key)
  if (bound) return bound
  const meta = sessions.get(key)?.storyMeta
  if (!meta || !storySourceFactory) return undefined
  try {
    const rebuilt = storySourceFactory(meta)
    if (!rebuilt) return undefined
    storySources.set(key, rebuilt)
    logger.info('[在线播放] 已按会话里的信息重建互动剧情来源（host 重启后照常能选剧情）')
    return rebuilt
  } catch (error: any) {
    logger.warn('[在线播放] 重建互动剧情来源失败: ' + String(error?.message ?? error))
    return undefined
  }
}

let storeDir = ''
let indexFile = ''
let sweeper: ReturnType<typeof setInterval> | null = null
const sessions = new Map<string, PlayerSession>()

/** 令牌是否合法（路由层第一道校验，非法直接 404，别去碰文件系统） */
export function isValidPlayerToken (token: unknown): boolean {
  return typeof token === 'string' && PLAYER_TOKEN_PATTERN.test(token)
}

/** 播放器根目录（会话目录都挂在它下面） */
export function playerStoreDir (): string {
  return storeDir
}

/** 夹一下有效期（分钟） */
export function normalizeExpireMinutes (value: unknown): number {
  const num = Number(value)
  if (!Number.isFinite(num)) return 60
  return Math.min(PLAYER_EXPIRE_MAX_MINUTES, Math.max(PLAYER_EXPIRE_MIN_MINUTES, Math.floor(num)))
}

/** 删文件复用 Common.removeFile（它会按 removeCache 配置决定删不删，force=true 时必删） */
async function removeFileQuietly (file: string): Promise<void> {
  try {
    const { Common } = await import('../karin/module/utils/Common')
    await Common.removeFile(file, true)
  } catch (error: any) {
    logger.debug('[在线播放] 删除文件失败（忽略）: ' + String(error?.message ?? error))
  }
}

/** 把内存里的会话索引写回磁盘；写失败只记日志，不影响播放本身 */
function persistIndex (): void {
  if (!indexFile) return
  try {
    fs.writeFileSync(indexFile, JSON.stringify([...sessions.values()], null, 2))
  } catch (error: any) {
    logger.debug('[在线播放] 写入会话索引失败（忽略）: ' + String(error?.message ?? error))
  }
}

/** 校验一条从磁盘读回来的会话记录（字段坏了就当没有） */
function normalizeSession (raw: any): PlayerSession | null {
  if (!raw || !isValidPlayerToken(raw.token)) return null
  const filePath = typeof raw.filePath === 'string' ? raw.filePath : ''
  if (!filePath) return null
  return {
    token: String(raw.token),
    title: String(raw.title ?? ''),
    platform: String(raw.platform ?? ''),
    dir: typeof raw.dir === 'string' && raw.dir ? raw.dir : path.dirname(filePath),
    filePath,
    audioPath: typeof raw.audioPath === 'string' && raw.audioPath ? raw.audioPath : undefined,
    audioSizeBytes: Number.isFinite(Number(raw.audioSizeBytes)) ? Number(raw.audioSizeBytes) : undefined,
    merged: typeof raw.merged === 'string' && raw.merged ? raw.merged : undefined,
    sizeBytes: Number(raw.sizeBytes) || 0,
    danmakuCount: Number(raw.danmakuCount) || 0,
    createdAt: Number(raw.createdAt) || Date.now(),
    expireAt: Number(raw.expireAt) || Date.now(),
    localOnly: raw.localOnly === true ? true : undefined,
    // 作品信息（可选）：重启后也要能还原
    author: raw.author ? String(raw.author) : undefined,
    cover: raw.cover ? String(raw.cover) : undefined,
    views: optionalNumber(raw.views),
    platformDanmaku: optionalNumber(raw.platformDanmaku),
    likes: optionalNumber(raw.likes),
    coins: optionalNumber(raw.coins),
    favorites: optionalNumber(raw.favorites),
    shares: optionalNumber(raw.shares),
    comments: optionalNumber(raw.comments),
    publishedAt: optionalNumber(raw.publishedAt),
    durationSeconds: optionalNumber(raw.durationSeconds),
    // 互动剧情：**必须还原** —— 不还原的话宿主重启后播放页就没有选项了（/story 404）
    story: raw.story && typeof raw.story === 'object' ? normalizeStoryNode(raw.story as PlayerStoryNode) : undefined,
    storyMeta: normalizeStoryMeta(raw.storyMeta)
  }
}

/**
 * 读 JSON 文件（顺手吃掉 BOM）。
 *
 * Windows 上用 PowerShell 的 `Set-Content -Encoding utf8` 之类写出来的文件会带 U+FEFF，
 * `JSON.parse` 会直接报 `Unexpected token ''` —— 表现就是「会话索引读不回来」，
 * 真实部署里踩到过，所以入口统一吃掉。
 */
function readJsonFile (file: string): any {
  const text = fs.readFileSync(file, 'utf-8').replace(/^\uFEFF/, '')
  return JSON.parse(text)
}

/** 读会话索引（宿主重启后恢复还没过期的会话） */
function loadIndex (): void {
  if (!indexFile || !fs.existsSync(indexFile)) return
  try {
    const list = readJsonFile(indexFile)
    if (!Array.isArray(list)) return
    for (const item of list) {
      const session = normalizeSession(item)
      if (!session) continue
      if (!fs.existsSync(session.filePath)) continue
      sessions.set(session.token, session)
    }
    if (sessions.size) logger.info('[在线播放] 已恢复 ' + sessions.size + ' 个未过期的播放会话')
  } catch (error: any) {
    logger.warn('[在线播放] 读取会话索引失败: ' + String(error?.message ?? error))
  }
}

/**
 * 初始化存储：确定目录、建目录、读回索引、扫一遍过期。
 * @param dir 播放器根目录（一般是 <数据目录>/koishi-plugin-kkk/player）
 */
export function setupPlayerStore (dir: string): void {
  storeDir = dir
  indexFile = path.join(dir, 'sessions.json')
  sessions.clear()
  try {
    fs.mkdirSync(dir, { recursive: true })
  } catch (error: any) {
    logger.error('[在线播放] 创建播放器目录失败: ' + String(error?.message ?? error))
  }
  loadIndex()
  // 启动时先扫一遍（不阻塞启动：删文件是异步的）
  void sweepExpiredPlayers().catch(() => undefined)
}

/** 生成一个随机令牌：用 crypto 随机串，不用自增（自增可被枚举，等于把别人的视频公开） */
function createToken (): string {
  return crypto.randomBytes(18).toString('hex')
}

/**
 * 把一个下好的视频登记成播放会话。
 *
 * 视频会被**移动**到会话目录（同一分区是改名，几乎不耗时；跨分区退回复制 + 删源文件），
 * 这样会话目录是自包含的：到期删目录就等于把视频和弹幕一起清掉了。
 * @param input 视频路径、标题、平台、弹幕、有效期（分钟）、作品信息（可选）
 * @returns 会话；登记失败返回 null（调用方负责退回原来的发送流程）
 */
export function registerPlayerSession (input: {
  videoPath: string
  /**
   * 单独的音轨文件（可选，见 {@link PlayerSession.audioPath}）。
   * 给了就一起搬进会话目录，播放页同时播放；没给就是「视频自带音轨」。
   */
  audioPath?: string
  title?: string
  platform?: string
  danmaku?: PlayerDanmakuItem[]
  expireMinutes?: number
  /** 作品信息：标题 / UP 主 / 播放量…（播放页上按B站那样展示用） */
  work?: PlayerWorkInfo
  /** 已经下载到本地的封面文件（会复制进会话目录） */
  coverPath?: string
  /** 链接是否只有本机 / 内网能打开（没配「播放器公网地址」），播放页会提示一句 */
  localOnly?: boolean
  /**
   * 互动视频的剧情（B站互动稿才有）：当前这一段的题目与选项 + 按需取节点/取分段的能力。
   * 给了它就等于「这条链接是个互动播放页」。
   */
  story?: { node: PlayerStoryNode; source?: PlayerStorySource }
  /** 重建材料：宿主重启后播放页还能自己把剧情取回来（不然选项按钮就没了） */
  storyMeta?: PlayerStoryMeta
}): PlayerSession | null {
  if (!storeDir) {
    logger.warn('[在线播放] 存储尚未初始化，无法登记播放会话')
    return null
  }
  const source = String(input.videoPath ?? '')
  try {
    if (!source || !fs.existsSync(source) || !fs.statSync(source).isFile()) {
      logger.warn('[在线播放] 视频文件不存在，无法登记播放会话: ' + source)
      return null
    }
    const token = createToken()
    const dir = path.join(storeDir, token)
    fs.mkdirSync(dir, { recursive: true })

    const target = path.join(dir, 'video.mp4')
    try {
      fs.renameSync(source, target)
    } catch {
      // 跨分区 / 被占用：复制一份再把源文件删掉（临时目录本来也是要清的）
      fs.copyFileSync(source, target)
      fs.rmSync(source, { force: true })
    }

    /**
     * 单独的音轨：也**搬**进会话目录（和视频同一套逻辑：同分区改名、跨分区复制 + 删源）。
     * 搬不动就当作「没有独立音轨」，不影响视频本身能播。
     */
    let audioTarget: string | undefined
    if (input.audioPath && fs.existsSync(input.audioPath)) {
      const candidate = path.join(dir, 'audio.m4a')
      try {
        try {
          fs.renameSync(input.audioPath, candidate)
        } catch {
          fs.copyFileSync(input.audioPath, candidate)
          fs.rmSync(input.audioPath, { force: true })
        }
        audioTarget = candidate
      } catch (error: any) {
        logger.warn('[在线播放] 音轨文件搬进会话目录失败（将只播视频流）: ' + String(error?.message ?? error))
      }
    }

    const danmaku = Array.isArray(input.danmaku) ? input.danmaku : []
    fs.writeFileSync(path.join(dir, 'danmaku.json'), JSON.stringify({ total: danmaku.length, items: danmaku }))

    /**
     * 互动剧情：把「当前这一段」的题目 / 选项写进会话目录（和弹幕同一套做法）。
     * 剧情来源（回调）只常驻内存，重启后取不到 —— 那时页面退化成普通播放页。
     */
    let story: PlayerStoryNode | undefined
    if (input.story?.node) {
      story = normalizeStoryNode(input.story.node)
      try {
        fs.writeFileSync(path.join(dir, 'story.json'), JSON.stringify(story))
      } catch (error: any) {
        logger.debug('[在线播放] 剧情数据落盘失败（不影响播放）: ' + String(error?.message ?? error))
      }
    }

    // 封面：复制进会话目录，页面用同源地址取（不引外链，断网/内网也能看）
    let cover: string | undefined
    if (input.coverPath && fs.existsSync(input.coverPath)) {
      try {
        const ext = path.extname(input.coverPath).toLowerCase() || '.jpg'
        cover = 'cover' + (/^\.(jpg|jpeg|png|webp|gif)$/.test(ext) ? ext : '.jpg')
        fs.copyFileSync(input.coverPath, path.join(dir, cover))
      } catch (error: any) {
        cover = undefined
        logger.debug('[在线播放] 封面复制失败（忽略）: ' + String(error?.message ?? error))
      }
    }

    const now = Date.now()
    const work = input.work ?? {}
    const session: PlayerSession = {
      token,
      title: String(input.title || work.title || ''),
      platform: String(input.platform ?? ''),
      dir,
      filePath: target,
      sizeBytes: Number(fs.statSync(target).size) || 0,
      audioPath: audioTarget,
      audioSizeBytes: audioTarget ? (Number(fs.statSync(audioTarget).size) || 0) : undefined,
      danmakuCount: danmaku.length,
      createdAt: now,
      expireAt: now + normalizeExpireMinutes(input.expireMinutes) * 60 * 1000,
      localOnly: input.localOnly === true ? true : undefined,
      author: work.author ? String(work.author) : undefined,
      sourceUrl: work.sourceUrl ? String(work.sourceUrl) : undefined,
      cover,
      views: optionalNumber(work.views),
      platformDanmaku: optionalNumber(work.platformDanmaku),
      likes: optionalNumber(work.likes),
      coins: optionalNumber(work.coins),
      favorites: optionalNumber(work.favorites),
      shares: optionalNumber(work.shares),
      comments: optionalNumber(work.comments),
      publishedAt: optionalNumber(work.publishedAt),
      durationSeconds: optionalNumber(work.durationSeconds),
      story,
      storyMeta: normalizeStoryMeta(input.storyMeta)
    }
    sessions.set(token, session)
    if (story && input.story?.source) bindPlayerStorySource(token, input.story.source)
    persistIndex()
    logger.mark('[在线播放] 已登记播放会话 ' + token + '（' + (session.title || '无标题')
      + (session.author ? ' / ' + session.author : '') + '，' + danmaku.length + ' 条弹幕，'
      + (session.sizeBytes / 1024 / 1024).toFixed(2) + ' MB，有效期 '
      + normalizeExpireMinutes(input.expireMinutes) + ' 分钟）')
    return session
  } catch (error: any) {
    logger.error('[在线播放] 登记播放会话失败: ' + String(error?.stack ?? error))
    try {
      // 登记到一半失败：把可能已经搬过去的文件删掉，别留垃圾
      if (source && !fs.existsSync(source)) fs.rmSync(source, { force: true })
    } catch { /* 忽略 */ }
    return null
  }
}

/** 取会话（顺带做一次过期校验：过期了当场清掉并返回 undefined） */
export function getPlayerSession (token: unknown): PlayerSession | undefined {
  if (!isValidPlayerToken(token)) return undefined
  const session = sessions.get(String(token))
  if (!session) return undefined
  if (session.expireAt <= Date.now()) {
    void deletePlayerSession(session.token)
    return undefined
  }
  return session
}

/**
 * 读弹幕数据（每次从磁盘读：弹幕可能上万条，没必要常驻内存）。
 *
 * @param cid 互动视频的某一段；不给 = 会话自己那一段（`danmaku.json`），
 *            给了 = 那一段缓存下来的 `danmaku-<cid>.json`
 */
export function readPlayerDanmaku (token: unknown, cid?: number): { total: number, items: PlayerDanmakuItem[] } | null {
  const session = getPlayerSession(token)
  if (!session) return null
  try {
    const file = cid && isValidStoryCid(cid) && String(cid) !== String(session.story?.cid)
      ? 'danmaku-' + cid + '.json'
      : 'danmaku.json'
    const raw = readJsonFile(path.join(session.dir, file))
    const items = Array.isArray(raw) ? raw : (Array.isArray(raw?.items) ? raw.items : [])
    return { total: Array.isArray(raw?.items) ? (Number(raw.total) || items.length) : items.length, items }
  } catch (error: any) {
    logger.debug('[在线播放] 读取弹幕失败: ' + String(error?.message ?? error))
    return { total: 0, items: [] }
  }
}

/** 某一段的弹幕缓存还在不在（在就直接发，不去问接口） */
export function hasPlayerSegmentDanmaku (token: unknown, cid: number): boolean {
  const session = getPlayerSession(token)
  if (!session || !isValidStoryCid(cid)) return false
  try {
    return fs.statSync(path.join(session.dir, 'danmaku-' + cid + '.json')).isFile()
  } catch {
    return false
  }
}

/** 把某一段的弹幕写进会话目录（下次点回来就不必再问接口） */
export function writePlayerSegmentDanmaku (token: unknown, cid: number, items: PlayerDanmakuItem[]): void {
  const session = getPlayerSession(token)
  if (!session || !isValidStoryCid(cid)) return
  try {
    fs.writeFileSync(path.join(session.dir, 'danmaku-' + cid + '.json'), JSON.stringify({ total: items.length, items }))
  } catch (error: any) {
    logger.debug('[在线播放] 分段弹幕落盘失败（不影响播放）: ' + String(error?.message ?? error))
  }
}

/** 取封面文件（会话目录里的同源图片；没有就返回 null，路由回 404） */
export function resolvePlayerCover (token: unknown): { path: string, type: string } | null {
  const session = getPlayerSession(token)
  if (!session?.cover) return null
  try {
    const file = path.join(session.dir, session.cover)
    if (!fs.statSync(file).isFile()) return null
    const ext = path.extname(file).toLowerCase()
    const type = ext === '.png'
      ? 'image/png'
      : ext === '.webp'
        ? 'image/webp'
        : ext === '.gif' ? 'image/gif' : 'image/jpeg'
    return { path: file, type }
  } catch {
    return null
  }
}

/** 洗一遍剧情节点：字段缺 / 类型歪都不要紧，别把脏数据发给页面 */
function normalizeStoryNode (node: PlayerStoryNode): PlayerStoryNode {
  const raw = Array.isArray(node?.choices) ? node.choices : []
  const choices: PlayerStoryChoice[] = raw
    .filter((choice) => isValidStoryCid(choice?.cid))
    .map((choice, index) => ({
      label: String(choice?.label ?? '').trim() || String(index + 1),
      text: String(choice?.text ?? '').trim() || ('选项 ' + (index + 1)),
      cid: Number(choice.cid),
      edgeId: Number(choice?.edgeId) || 0
    }))
  return {
    cid: Number(node?.cid) || 0,
    question: String(node?.question ?? ''),
    // 选项全被过滤掉 = 这道题没法往下走，按结局处理（前端会显示「走到结局」）
    isLeaf: node?.isLeaf === true || choices.length === 0,
    choices
  }
}

/** 洗一遍重建材料（字段缺 / 歪都不要紧，缺了就当没有剧情） */
function normalizeStoryMeta (raw: any): PlayerStoryMeta | undefined {
  const bvid = String(raw?.bvid ?? '').trim()
  const cid = Number(raw?.cid)
  if (!bvid || !Number.isFinite(cid) || cid <= 0) return undefined
  return { bvid, cid, islogin: raw?.islogin === true }
}

/** 读剧情数据（会话目录里的 story.json；没有就 null） */
export function readPlayerStory (token: unknown): PlayerStoryNode | null {
  const session = getPlayerSession(token)
  if (!session) return null
  try {
    const raw = readJsonFile(path.join(session.dir, 'story.json'))
    return raw && typeof raw === 'object' ? normalizeStoryNode(raw as PlayerStoryNode) : null
  } catch (error: any) {
    logger.debug('[在线播放] 读取剧情失败: ' + String(error?.message ?? error))
    return null
  }
}

/** cid 只允许正整数：它会拼进文件名，必须把路径穿越挡死 */
export function isValidStoryCid (cid: unknown): boolean {
  const value = Number(cid)
  return Number.isInteger(value) && value > 0 && value < 1e12
}

/**
 * 分段文件的两种：画面 `seg-<cid>.mp4` / 音轨 `seg-<cid>.m4a`。
 *
 * B站的音视频是分开的两条流，播放页也是两个元素同时播（用户要求不合成），
 * 所以分段得跟着存两份、分开取。
 */
export type SegmentKind = 'video' | 'audio'

/** 取某一分段的文件（会话目录里的 seg-<cid>.mp4 / .m4a；没有就 null，路由再去按需下载） */
export function resolvePlayerSegment (
  token: unknown,
  cid: number,
  kind: SegmentKind = 'video'
): { path: string, size: number } | null {
  const session = getPlayerSession(token)
  if (!session || !isValidStoryCid(cid)) return null
  try {
    const file = path.join(session.dir, 'seg-' + cid + (kind === 'audio' ? '.m4a' : '.mp4'))
    const stat = fs.statSync(file)
    return stat.isFile() ? { path: file, size: stat.size } : null
  } catch {
    return null
  }
}

/**
 * 把「按需下好的某一段」搬进会话目录（seg-<cid>.mp4），下一次直接命中。
 *
 * 和登记会话时搬视频同一套逻辑：同分区改名、跨分区复制 + 删源；
 * 搬进会话目录还有个好处 —— 到期清目录时它会跟着一起消失，不用单独记账。
 */
export function adoptPlayerSegment (
  token: unknown,
  cid: number,
  sourcePath: string,
  kind: SegmentKind = 'video'
): { path: string, size: number } | null {
  const session = getPlayerSession(token)
  if (!session || !isValidStoryCid(cid)) return null
  if (!sourcePath || !fs.existsSync(sourcePath)) return null
  const target = path.join(session.dir, 'seg-' + cid + (kind === 'audio' ? '.m4a' : '.mp4'))
  try {
    try {
      fs.renameSync(sourcePath, target)
    } catch {
      fs.copyFileSync(sourcePath, target)
      fs.rmSync(sourcePath, { force: true })
    }
    const size = Number(fs.statSync(target).size) || 0
    logger.mark('[在线播放] 互动分段' + (kind === 'audio' ? '音轨' : '画面') + '已就绪 cid=' + cid
      + '（' + (size / 1024 / 1024).toFixed(1) + 'MB）')
    return { path: target, size }
  } catch (error: any) {
    logger.warn('[在线播放] 互动分段搬进会话目录失败: ' + String(error?.message ?? error))
    return null
  }
}

/** 取视频文件信息（不存在就返回 null，路由据此回 404） */
export function resolvePlayerVideo (token: unknown): { path: string, size: number } | null {
  const session = getPlayerSession(token)
  if (!session) return null
  try {
    const stat = fs.statSync(session.filePath)
    if (!stat.isFile()) return null
    return { path: session.filePath, size: stat.size }
  } catch {
    return null
  }
}

/**
 * 取单独的音轨文件（没有独立音轨就返回 null，路由回 404）。
 *
 * 独立音轨 = 解析时没让服务器合成，播放页用 `<audio>` 和视频一起播（见 PlayerSession.audioPath）。
 */
export function resolvePlayerAudio (token: unknown): { path: string, size: number } | null {
  const session = getPlayerSession(token)
  const audioPath = session?.audioPath
  if (!audioPath) return null
  try {
    const stat = fs.statSync(audioPath)
    if (!stat.isFile()) return null
    return { path: audioPath, size: stat.size }
  } catch {
    return null
  }
}

/** 记住「按需合成的文件」文件名（它会留在会话目录里，到期一起清掉） */
export function markPlayerMerged (token: string, fileName: string): void {
  const session = sessions.get(String(token))
  if (!session) return
  session.merged = fileName
  persistIndex()
}

/** 已经合成好的合并文件路径（没有就 null） */
export function resolvePlayerMerged (token: unknown): { path: string, size: number } | null {
  const session = getPlayerSession(token)
  if (!session?.merged) return null
  try {
    const file = path.join(session.dir, session.merged)
    const stat = fs.statSync(file)
    if (!stat.isFile()) return null
    return { path: file, size: stat.size }
  } catch {
    return null
  }
}

/** 删掉一个会话的文件：先按 Common.removeFile 删视频，再把整个会话目录清掉 */
async function removePlayerFiles (session: PlayerSession): Promise<void> {
  await removeFileQuietly(session.filePath)
  try {
    fs.rmSync(session.dir, { recursive: true, force: true })
  } catch (error: any) {
    logger.debug('[在线播放] 删除会话目录失败（忽略）: ' + String(error?.message ?? error))
  }
}

/** 删掉一个会话：索引和文件一起清 */
export async function deletePlayerSession (token: string): Promise<boolean> {
  const session = sessions.get(token)
  if (!session) return false
  sessions.delete(token)
  storySources.delete(String(token))
  persistIndex()
  await removePlayerFiles(session)
  return true
}

/**
 * 扫一遍过期会话并删除。
 *
 * 返回 Promise 是刻意的：调用方（定时器）不需要等，但测试要能等到「文件真的删掉了」。
 * @param now 判定用的当前时间（默认 Date.now()，测试里可以传一个「未来」的时刻强制触发）
 * @returns 删掉了几个
 */
export async function sweepExpiredPlayers (now = Date.now()): Promise<number> {
  const expired = [...sessions.values()].filter((session) => session.expireAt <= now)
  if (!expired.length) return 0
  for (const session of expired) {
    sessions.delete(session.token)
    storySources.delete(session.token)
    logger.info('[在线播放] 链接已过期，清理会话 ' + session.token + '（' + session.title + '）')
    await removePlayerFiles(session)
  }
  persistIndex()
  return expired.length
}

/** 当前所有有效会话（诊断 / 测试用） */
export function listPlayerSessions (): PlayerSession[] {
  return [...sessions.values()]
}

/** 启动过期清理定时器（每分钟一次）；重复调用不会叠加 */
export function startPlayerSweeper (intervalMs = SWEEP_INTERVAL_MS): void {
  if (sweeper) return
  sweeper = setInterval(() => {
    sweepExpiredPlayers().catch((error: any) => {
      logger.debug('[在线播放] 过期清理出错（忽略）: ' + String(error?.message ?? error))
    })
  }, intervalMs)
  sweeper.unref?.()
}

/** 停掉定时器（插件卸载时调用，不然热重载会越攒越多） */
export function stopPlayerSweeper (): void {
  if (!sweeper) return
  clearInterval(sweeper)
  sweeper = null
}