// 听书播放引擎：模块级单例，持有真正的 <audio>（不进 React 树，也不进任何路由）。
//
// 为什么要脱离组件：音频面板原先挂在 ReaderViewPage 里，路由一变组件卸载，清理
// 逻辑就 removeAttribute('src') + load()，播放当场断掉；手机息屏、系统回收标签页
// 时更没有任何东西证明「这个页面正在播媒体」。把播放器做成常驻单例后：
//   - 路由切换不影响播放；
//   - Media Session 让锁屏/通知栏/耳机按键接管控制（Android Chrome 会据此判定
//     页面处于活跃媒体会话，后台存活率明显更高）；
//   - 定时关闭改由 timeupdate（后台播放时仍触发）+ 低频 ticker 驱动，不再依赖
//     被节流的 setInterval 来「到点暂停」。
//
// 进度上报也在这里：引擎自己知道当前书/章，离开页面、暂停、切章时都能补报一次，
// 不依赖调用方在卸载时回调。
import toast from 'react-hot-toast'

import { readerAPI, type ReaderChapter } from '../../api/reader'
import { useReaderAudioStore, resetReaderAudio } from '../../stores/readerAudio'
import { useReaderSettingsStore } from '../../stores/readerSettings'
import { readerCoverSrc } from '../../utils/readerCover'

/** 播放进度上报节流（毫秒）：退出最多丢 5 秒。 */
const PROGRESS_SAVE_INTERVAL_MS = 5_000
/** -15s / +15s 步长（对齐面板与 legado SEEK_STEP）。 */
const SEEK_STEP = 15

export interface LoadChapterInput {
  bookId: string
  bookName: string
  cover: string
  chapters: ReaderChapter[]
  chapterIndex: number
  /** 当前章的音轨地址（已签名）。 */
  track: string
  /**
   * 音轨是否为 HLS 播放列表（服务端下发）。
   * 代理地址是 base64 的 /api/reader/media?u=...，前端无法再从后缀判断格式，
   * 必须用这个标志决定走 hls.js 还是原生 <audio>。
   */
  hls?: boolean
  transcoding: boolean
  openCredits: number
  closeCredits: number
  /** 恢复进度（秒）；0 表示从头。 */
  initialPos: number
}

class ReaderAudioEngine {
  private audio: HTMLAudioElement
  /** hls.js 实例（只用到 destroy）。 */
  private hls: { destroy: () => void } | null = null
  /** 元数据就绪后是否已经套用过进度/片头跳转。 */
  private restored = false
  /** 本章是否已经触发过片尾跳过，避免 timeupdate 反复触发。 */
  private skippedEnd = false
  /** 最近一次播放位置（秒）：节流窗口外补报进度时要用。 */
  private lastTime = 0
  private lastSavedAt = 0
  /** 上一次落库的进度标识（书|章|秒），相同则不重复请求。 */
  private savedKey = ''
  /** 定时关闭截止时间戳（毫秒），0 表示未开启。 */
  private timerDeadline = 0
  /** 暂停开始的毫秒时间戳，0 表示当前在播（定时倒计时只在播放中走）。 */
  private pausedAt = 0
  private timerTicker: number | null = null
  /** 一次性的初始进度，等 metadata 就绪后消费。 */
  private pendingInitialPos = 0
  /** 是否已经套用过「上次的定时设置」，只在首次加载时套一次。 */
  private timerBooted = false
  /** 正在拆卸音源（避免拆卸触发的 pause 事件被当成用户暂停）。 */
  private detaching = false
  /** 加载批次号：动态 import hls.js 期间被新的加载打断时用来丢弃旧结果。 */
  private loadToken = 0
  /** 预取缓存：章序号 → 已解析的音轨。命中的切章可以同步开播，不用等网络。 */
  private prefetched = new Map<number, { track: string; transcoding: boolean; hls: boolean }>()
  /** 预取在途的章序号，避免同一章重复请求。 */
  private prefetching = new Set<number>()
  /** 预热下一章字节的隐藏播放器（只下载，从不 play()）。 */
  private warmer: HTMLAudioElement | null = null
  /** warmer 当前装载的音轨，避免重复赋值。 */
  private warmedTrack = ''

  constructor() {
    const audio = new Audio()
    audio.preload = 'metadata'
    this.audio = audio
    this.bindAudio()
    this.bindLifecycle()
    this.bindSettings()
    this.bindMediaSession()
  }

  // ─── 对外 API ─────────────────────────────────────────────────────────

  /**
   * 加载并播放一章。同一本书同一章重复调用（阅读页 effect 重跑、目录同步回写）
   * 会被忽略，避免把正在播的进度重置掉。
   */
  loadChapter(input: LoadChapterInput): void {
    const s = useReaderAudioStore.getState()
    if (
      s.bookId === input.bookId &&
      s.chapterIndex === input.chapterIndex &&
      s.track === input.track &&
      (s.status === 'loading' || s.status === 'playing' || s.status === 'paused')
    ) {
      return
    }
    // 换章前把上一章的最后位置补报掉（此时 store 里还是上一章的上下文）
    this.commitProgress()
    // 换书：预取的音轨属于上一本，全部作废
    if (s.bookId !== input.bookId) this.clearPrefetch()
    this.applyChapter(input)
  }

  /** 真正把一章装上播放器（同步部分）：预取命中的续播也走这里。 */
  private applyChapter(input: LoadChapterInput): void {
    const chapterTitle = input.chapters[input.chapterIndex]?.title ?? ''
    useReaderAudioStore.setState({
      bookId: input.bookId,
      bookName: input.bookName,
      cover: input.cover,
      chapters: input.chapters,
      chapterIndex: input.chapterIndex,
      chapterTitle,
      track: input.track,
      transcoding: input.transcoding,
      openCredits: input.openCredits,
      closeCredits: input.closeCredits,
      hasNext: this.computeHasNext(input.chapters, input.chapterIndex),
      status: 'loading',
      error: '',
      cur: 0,
      dur: 0,
    })

    this.restored = false
    this.skippedEnd = false
    this.lastTime = 0
    this.lastSavedAt = 0
    this.savedKey = ''
    this.pendingInitialPos = Math.max(0, input.initialPos)

    // 进场套用上次的定时设置（对应 legado 起朗读服务时 setTimer(AppConfig.ttsTimer)）
    if (!this.timerBooted) {
      this.timerBooted = true
      const preset = useReaderSettingsStore.getState().audioTimerMinutes
      if (preset > 0) this.applyTimer(preset)
    }

    void this.attachSource(input.track, input.hls === true)
    // 提前解析下一章的音轨并在后台预热字节：息屏自动续播时才能立刻接上
    const nextIndex = this.neighborChapterIndex(1)
    if (nextIndex !== null) this.prefetchChapter(nextIndex)
  }

  play(): void {
    void this.audio.play().catch(() => {
      // 自动播放被浏览器拦下（典型是 iOS）：退回暂停态，让用户点按钮手动触发，
      // 而不是一直停在「加载中」。
      if (useReaderAudioStore.getState().status === 'loading') {
        useReaderAudioStore.setState({ status: 'paused' })
      }
    })
  }

  pause(): void {
    this.audio.pause()
    // 还没触发 play 事件时（status 仍是 loading），下面的 pause 事件处理会跳过状态
    // 判定；这里补一次，保证按钮不会一直转圈。
    if (useReaderAudioStore.getState().status === 'loading') {
      if (this.pausedAt === 0) this.pausedAt = Date.now()
      useReaderAudioStore.setState({ status: 'paused' })
      this.setSessionPlaybackState('paused')
    }
  }

  toggle(): void {
    if (this.audio.paused) this.play()
    else this.pause()
  }

  seekBy(delta: number): void {
    const total = Number.isFinite(this.audio.duration)
      ? this.audio.duration
      : this.audio.currentTime + Math.abs(delta)
    this.seekTo(Math.min(Math.max(0, this.audio.currentTime + delta), Math.max(0, total - 0.2)))
  }

  seekTo(seconds: number): void {
    if (!Number.isFinite(seconds)) return
    this.audio.currentTime = Math.max(0, seconds)
    this.lastTime = this.audio.currentTime
    useReaderAudioStore.setState({ cur: this.audio.currentTime })
    this.updateSessionPosition()
  }

  /** 倍速改动写回 settings store，订阅回调负责应用到 <audio>。 */
  setSpeed(v: number): void {
    useReaderSettingsStore.getState().setAudioSpeed(v)
  }

  /** 片头/片尾跳过秒数：立刻生效并按书持久化。 */
  setCredits(open: number, close: number): void {
    useReaderAudioStore.setState({ openCredits: open, closeCredits: close })
    const { bookId } = useReaderAudioStore.getState()
    if (!bookId) return
    readerAPI.saveAudioConfig(bookId, { open_credits: open, close_credits: close }).catch(() => undefined)
  }

  /** 定时关闭：0 表示关闭定时。 */
  applyTimer(minutes: number): void {
    useReaderSettingsStore.getState().setAudioTimerMinutes(minutes)
    useReaderAudioStore.setState({ timerPreset: minutes })
    if (minutes <= 0) {
      this.timerDeadline = 0
      this.pausedAt = 0
      this.stopTimerTicker()
      useReaderAudioStore.setState({ timerLeft: 0, timerActive: false })
      return
    }
    this.timerDeadline = Date.now() + minutes * 60_000
    // 暂停期间不倒计时：记下暂停起点，恢复播放时顺延截止时间
    this.pausedAt = this.audio.paused ? Date.now() : 0
    useReaderAudioStore.setState({ timerLeft: minutes * 60, timerActive: true })
    this.startTimerTicker()
  }

  selectChapter(index: number): void {
    void this.goToChapter(index, 0)
  }

  next(): void {
    const i = this.neighborChapterIndex(1)
    if (i === null) return
    void this.goToChapter(i, 0)
  }

  prev(): void {
    const i = this.neighborChapterIndex(-1)
    if (i === null) return
    void this.goToChapter(i, 0)
  }

  /** 完全停止并清空状态（迷你播放器的关闭按钮）。 */
  stop(): void {
    this.commitProgress()
    this.detachSource()
    this.clearPrefetch()
    this.timerDeadline = 0
    this.pausedAt = 0
    // 下一次开播重新套用「上次的定时设置」，否则关掉再听一本书时定时不会自动开
    this.timerBooted = false
    this.stopTimerTicker()
    this.setSessionMetadata(null)
    this.setSessionPlaybackState('none')
    resetReaderAudio()
  }

  /** 立即补报一次进度（不吃节流窗口）。 */
  commitProgress(): void {
    this.lastSavedAt = 0
    this.persistProgress()
  }

  // ─── 音源装载 ─────────────────────────────────────────────────────────

  /**
   * 装上音源。isHLS 由服务端判定（见 LoadChapterInput.hls）——
   * 代理地址不含 .m3u8 后缀，前端不能再用地址猜格式。
   */
  private async attachSource(src: string, isHLS: boolean): Promise<void> {
    const token = ++this.loadToken
    // 只销毁上一章的 hls，不再 removeAttribute('src') + load()。load() 会把媒体
    // 元素彻底卸载、释放系统音频会话，息屏时紧接着的 play() 就会被浏览器当成
    // 「无用户手势」拦下——表现正是切章卡住、解锁后必须手动点播放。直接覆盖 src，
    // 元素始终持有媒体，会话才接得上。
    this.hls?.destroy()
    this.hls = null
    if (!src) {
      this.audio.removeAttribute('src')
      this.audio.load()
      this.setSessionMetadata(null)
      this.fail('本章没有可播放的音频')
      return
    }
    // 先停住上一章：HLS 分支要 await 动态 import，不先停会有一小段两章叠播
    if (!this.audio.paused) this.audio.pause()
    this.setSessionMetadata(src)
    if (isHLS) {
      const mod = await import('hls.js')
      // 动态 import 期间可能已经切到别的章：丢弃这次结果
      if (token !== this.loadToken) return
      const Hls = mod.default
      if (Hls.isSupported()) {
        const inst = new Hls({ enableWorker: true })
        inst.on(Hls.Events.ERROR, (_evt, data) => {
          if (data.fatal) this.fail('音频加载失败，请检查网络或源文件是否还在')
        })
        inst.loadSource(src)
        inst.attachMedia(this.audio)
        this.hls = inst
        return
      }
      // Safari 原生 HLS
      this.audio.src = src
      return
    }
    this.audio.src = src
  }

  /** 彻底卸载音源（停止播放时用）。换章不走这里，见 attachSource 的说明。 */
  private detachSource(): void {
    this.detaching = true
    this.hls?.destroy()
    this.hls = null
    this.audio.removeAttribute('src')
    this.audio.load()
    this.detaching = false
  }

  // ─── 预取与续播 ───────────────────────────────────────────────────────

  /**
   * 提前解析某章的音轨并预热字节。息屏时 ended 与 play() 之间不能有网络空档，
   * 否则系统收走音频会话、标签页被冻结，浏览器就拒绝自动播放了。
   */
  private prefetchChapter(index: number): void {
    const { bookId, chapters } = useReaderAudioStore.getState()
    if (!bookId || index < 0 || index >= chapters.length || chapters[index].is_volume) return
    if (this.prefetched.has(index) || this.prefetching.has(index)) return
    // 反复跳章时旧的预取会变成垃圾，做个上限兜底
    if (this.prefetched.size > 32) this.prefetched.clear()
    this.prefetching.add(index)
    const forBook = bookId
    readerAPI
      .bookContent(bookId, index)
      .then((ct) => {
        // 期间换了书：结果作废
        if (useReaderAudioStore.getState().bookId !== forBook) return
        const track = ct.tracks?.[0]
        if (ct.type !== 'audio' || !track) return
        this.prefetched.set(index, { track, transcoding: ct.transcoding ?? false, hls: ct.hls ?? false })
        // 要服务端转码的音轨立刻预热（把转码提前跑掉）；直链等到本章快播完再拉字节，
        // 避免用户中途停下时白下整章的流量。
        if (ct.transcoding) this.warmNextBytes(track, ct.hls ?? false)
      })
      .catch(() => undefined)
      .finally(() => this.prefetching.delete(index))
  }

  /** 用隐藏播放器把下一章的字节（以及服务端转码）提前拉起来，减少切章等待。 */
  private warmNextBytes(track: string, isHLS: boolean): void {
    // HLS 交给 hls.js 按需拉流，二次下载没有意义
    if (!track || isHLS || this.warmedTrack === track) return
    this.warmedTrack = track
    if (!this.warmer) {
      const a = new Audio()
      a.preload = 'auto'
      this.warmer = a
    }
    this.warmer.src = track
  }

  /** 本章快播完时把下一章的字节预热起来（30 秒足够开头缓冲）。 */
  private maybeWarmNext(): void {
    const audio = this.audio
    if (!Number.isFinite(audio.duration) || audio.duration <= 0) return
    if (audio.duration - audio.currentTime > 30) return
    const nextIndex = this.neighborChapterIndex(1)
    if (nextIndex === null) return
    const hit = this.prefetched.get(nextIndex)
    if (hit) this.warmNextBytes(hit.track, hit.hls)
  }

  /** 用预取结果接续下一章；命中返回 true（未命中由调用方走异步加载兜底）。 */
  private playPrefetched(index: number): boolean {
    const hit = this.prefetched.get(index)
    if (!hit) return false
    this.prefetched.delete(index)
    const s = useReaderAudioStore.getState()
    this.applyChapter({
      bookId: s.bookId,
      bookName: s.bookName,
      cover: s.cover,
      chapters: s.chapters,
      chapterIndex: index,
      track: hit.track,
      hls: hit.hls,
      transcoding: hit.transcoding,
      openCredits: s.openCredits,
      closeCredits: s.closeCredits,
      initialPos: 0,
    })
    // 立刻在 ended 的同一次事件里发起 play()，保证没有空档。片头跳转由
    // loadedmetadata 处理器完成：音频在 loadedmetadata 之前不会出声，所以
    // 先 play() 也不会漏出片头。HLS 交给 hls.js 承载，无法同帧开播。
    if (!hit.hls) this.play()
    return true
  }

  private clearPrefetch(): void {
    this.prefetched.clear()
    this.prefetching.clear()
    this.warmedTrack = ''
    if (this.warmer) {
      this.warmer.removeAttribute('src')
      this.warmer.load()
    }
  }

  private async goToChapter(index: number, initialPos: number): Promise<void> {
    const { bookId, chapters } = useReaderAudioStore.getState()
    if (!bookId || index < 0 || index >= chapters.length || chapters[index].is_volume) return
    // 命中预取：直接装，不等网络（片尾自动续播大多走这里）
    const hit = this.prefetched.get(index)
    if (hit) {
      useReaderAudioStore.setState({ status: 'loading', error: '' })
      const s = useReaderAudioStore.getState()
      this.loadChapter({
        bookId,
        bookName: s.bookName,
        cover: s.cover,
        chapters,
        chapterIndex: index,
        track: hit.track,
        transcoding: hit.transcoding,
        openCredits: s.openCredits,
        closeCredits: s.closeCredits,
        initialPos,
      })
      return
    }
    useReaderAudioStore.setState({ status: 'loading', error: '' })
    try {
      const ct = await readerAPI.bookContent(bookId, index)
      const track = ct.tracks?.[0]
      if (ct.type !== 'audio' || !track) {
        this.fail('本章没有可播放的音频')
        return
      }
      const s = useReaderAudioStore.getState()
      this.loadChapter({
        bookId,
        bookName: s.bookName,
        cover: s.cover,
        chapters,
        chapterIndex: index,
        track,
        transcoding: ct.transcoding ?? false,
        openCredits: s.openCredits,
        closeCredits: s.closeCredits,
        initialPos,
      })
    } catch (e) {
      this.fail((e as Error).message || '章节加载失败')
    }
  }

  private fail(message: string): void {
    useReaderAudioStore.setState({ status: 'error', error: message })
    this.setSessionPlaybackState('paused')
  }

  // ─── <audio> 事件 ─────────────────────────────────────────────────────

  private bindAudio(): void {
    const audio = this.audio

    audio.addEventListener('play', () => {
      useReaderAudioStore.setState({ status: 'playing' })
      this.setSessionPlaybackState('playing')
      // 恢复播放：把暂停时长顺延到定时截止时间
      if (this.pausedAt > 0) {
        this.timerDeadline += Date.now() - this.pausedAt
        this.pausedAt = 0
      }
    })

    audio.addEventListener('pause', () => {
      if (this.detaching) return
      // 只认「播放中 -> 暂停」这一种。换源/停止时 load() 也会抛出 pause 事件，
      // 那些时刻 status 是 loading/idle，直接忽略；否则会把刚进入的加载态改成暂停，
      // 并给新章节写一条位置为 0 的进度。
      if (useReaderAudioStore.getState().status !== 'playing') return
      if (this.pausedAt === 0) this.pausedAt = Date.now()
      useReaderAudioStore.setState({ status: 'paused' })
      this.setSessionPlaybackState('paused')
      this.commitProgress()
    })

    audio.addEventListener('ended', () => {
      this.lastTime = Number.isFinite(audio.duration) ? audio.duration : this.lastTime
      this.commitProgress()
      if (useReaderAudioStore.getState().hasNext) {
        // 预取命中：在 ended 的同一次事件里同步接上下一章。息屏时这段「零空档」
        // 很关键——空太久系统会收走音频会话、冻结标签页，浏览器随后拒绝自动播放。
        const nextIndex = this.neighborChapterIndex(1)
        if (nextIndex !== null && this.playPrefetched(nextIndex)) return
        this.next()
        return
      }
      // 最后一章播完：ended 不会触发 pause，倒计时/暂停态要在这里自己落定
      if (this.pausedAt === 0) this.pausedAt = Date.now()
      useReaderAudioStore.setState({ status: 'paused' })
      this.setSessionPlaybackState('paused')
    })

    audio.addEventListener('loadedmetadata', () => {
      const total = Number.isFinite(audio.duration) ? audio.duration : 0
      useReaderAudioStore.setState({ dur: total })
      if (!this.restored) {
        const { openCredits } = useReaderAudioStore.getState()
        if (this.pendingInitialPos > 0 && (total === 0 || this.pendingInitialPos < total)) {
          // 有进度：按存档续播（legado: position != 0 时不套用片头）
          audio.currentTime = this.pendingInitialPos
          useReaderAudioStore.setState({ cur: this.pendingInitialPos })
        } else if (openCredits > 0 && (total === 0 || total > openCredits + 1)) {
          // 全新开播：跳到片头结束位置（legado: skipStartMs）
          audio.currentTime = openCredits
          useReaderAudioStore.setState({ cur: openCredits })
        }
        this.pendingInitialPos = 0
      }
      this.restored = true
      audio.playbackRate = useReaderAudioStore.getState().speed
      this.play()
    })

    audio.addEventListener('durationchange', () => {
      const total = Number.isFinite(audio.duration) ? audio.duration : 0
      useReaderAudioStore.setState({ dur: total })
      this.updateSessionPosition()
    })

    audio.addEventListener('timeupdate', () => {
      const t = audio.currentTime
      this.lastTime = t
      useReaderAudioStore.setState({ cur: t })
      this.updateSessionPosition()
      this.reportProgress()
      this.checkCreditsEnd()
      // 后台播放时 timeupdate 仍会触发，这是「到点暂停」最可靠的位置
      this.checkTimer()
      this.maybeWarmNext()
    })

    audio.addEventListener('error', () => {
      const code = audio.error?.code
      this.fail(
        code === MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED
          ? '浏览器无法播放该音频格式，且服务端转码不可用（请检查 ffmpeg 是否已安装）'
          : code === MediaError.MEDIA_ERR_NETWORK
            ? '音频加载失败，请检查网络或源文件是否还在'
            : '音频无法播放',
      )
    })
  }

  // ─── 页面生命周期：只负责补报进度，绝不暂停播放 ───────────────────────

  private bindLifecycle(): void {
    const flush = () => this.commitProgress()
    document.addEventListener('visibilitychange', () => {
      if (document.visibilityState === 'hidden') flush()
    })
    window.addEventListener('pagehide', flush)
  }

  private bindSettings(): void {
    const apply = () => {
      const { audioSpeed } = useReaderSettingsStore.getState()
      this.audio.playbackRate = audioSpeed
      useReaderAudioStore.setState({ speed: audioSpeed })
    }
    apply()
    // 引擎是常驻单例，订阅不需要解除
    useReaderSettingsStore.subscribe(apply)
  }

  // ─── 进度 ─────────────────────────────────────────────────────────────

  private reportProgress(): void {
    const now = Date.now()
    if (now - this.lastSavedAt < PROGRESS_SAVE_INTERVAL_MS) return
    this.lastSavedAt = now
    this.persistProgress()
  }

  private persistProgress(): void {
    const { bookId, chapterIndex, chapterTitle } = useReaderAudioStore.getState()
    if (!bookId || this.lastTime <= 0) return
    const pos = Math.max(0, Math.floor(this.lastTime))
    const key = `${bookId}|${chapterIndex}|${pos}`
    if (key === this.savedKey) return
    this.savedKey = key
    readerAPI.saveProgress(bookId, { chapter_index: chapterIndex, pos, chapter_title: chapterTitle }).catch(() => undefined)
  }

  // ─── 片头片尾 ─────────────────────────────────────────────────────────

  private checkCreditsEnd(): void {
    const { closeCredits, hasNext } = useReaderAudioStore.getState()
    const audio = this.audio
    if (closeCredits <= 0 || this.skippedEnd) return
    if (!Number.isFinite(audio.duration) || audio.duration <= closeCredits + 1) return
    if (audio.currentTime < audio.duration - closeCredits) return
    this.skippedEnd = true
    if (!hasNext) {
      audio.pause()
      audio.currentTime = Math.max(0, audio.duration - 0.5)
      return
    }
    this.next()
  }

  // ─── 定时关闭 ─────────────────────────────────────────────────────────

  /** 剩余秒数：暂停期间以暂停起点为准，倒计时不会在暂停时溜走。 */
  private timerLeftSeconds(): number {
    if (this.timerDeadline === 0) return 0
    const now = this.pausedAt > 0 ? this.pausedAt : Date.now()
    return Math.max(0, Math.round((this.timerDeadline - now) / 1000))
  }

  private checkTimer(): void {
    const s = useReaderAudioStore.getState()
    if (!s.timerActive || this.timerDeadline === 0) return
    const left = this.timerLeftSeconds()
    if (left !== s.timerLeft) useReaderAudioStore.setState({ timerLeft: left })
    // 暂停中不判到期：恢复播放时截止时间已经顺延过
    if (left <= 0 && this.pausedAt === 0) {
      this.timerDeadline = 0
      this.stopTimerTicker()
      useReaderAudioStore.setState({ timerLeft: 0, timerActive: false })
      this.audio.pause()
      toast('定时结束，已暂停播放')
    }
  }

  private startTimerTicker(): void {
    this.stopTimerTicker()
    this.timerTicker = window.setInterval(() => this.checkTimer(), 1000)
  }

  private stopTimerTicker(): void {
    if (this.timerTicker !== null) {
      window.clearInterval(this.timerTicker)
      this.timerTicker = null
    }
  }

  // ─── Media Session（锁屏 / 通知栏 / 耳机按键） ────────────────────────

  private session(): MediaSession | null {
    if (typeof navigator === 'undefined' || !('mediaSession' in navigator)) return null
    return navigator.mediaSession
  }

  private setSessionMetadata(track: string | null): void {
    const session = this.session()
    if (!session || typeof MediaMetadata === 'undefined') return
    if (track === null) {
      session.metadata = null
      return
    }
    const { bookName, chapterTitle, cover } = useReaderAudioStore.getState()
    const coverSrc = readerCoverSrc(cover)
    const artwork: MediaImage[] = coverSrc
      ? [{ src: new URL(coverSrc, window.location.origin).href, sizes: '512x512' }]
      : []
    try {
      session.metadata = new MediaMetadata({
        title: chapterTitle || bookName || 'MeBox 听书',
        artist: bookName || 'MeBox',
        album: 'MeBox 听书',
        artwork,
      })
    } catch {
      // 个别浏览器对 artwork 类型挑剔，失败不影响播放
    }
  }

  private setSessionPlaybackState(state: MediaSessionPlaybackState): void {
    const session = this.session()
    if (!session) return
    try {
      session.playbackState = state
    } catch {
      // 忽略
    }
  }

  private updateSessionPosition(): void {
    const session = this.session()
    if (!session || typeof session.setPositionState !== 'function') return
    const { dur } = useReaderAudioStore.getState()
    const position = this.audio.currentTime
    if (!Number.isFinite(dur) || dur <= 0 || !Number.isFinite(position)) return
    const rate = this.audio.playbackRate
    try {
      session.setPositionState({
        duration: dur,
        position: Math.min(Math.max(0, position), dur),
        playbackRate: Number.isFinite(rate) && rate > 0 ? rate : 1,
      })
    } catch {
      // position 越界等情况下浏览器会抛错，忽略
    }
  }

  private bindMediaSession(): void {
    const session = this.session()
    if (!session) return
    const handlers: [MediaSessionAction, MediaSessionActionHandler][] = [
      ['play', () => this.play()],
      ['pause', () => this.pause()],
      ['stop', () => this.stop()],
      ['seekbackward', () => this.seekBy(-SEEK_STEP)],
      ['seekforward', () => this.seekBy(SEEK_STEP)],
      ['previoustrack', () => this.prev()],
      ['nexttrack', () => this.next()],
      [
        'seekto',
        (details) => {
          if (typeof details.seekTime === 'number') this.seekTo(details.seekTime)
        },
      ],
    ]
    for (const [action, handler] of handlers) {
      try {
        session.setActionHandler(action, handler)
      } catch {
        // 该动作在当前浏览器不支持时会抛错，逐个忽略
      }
    }
  }

  // ─── 工具 ─────────────────────────────────────────────────────────────

  private neighborChapterIndex(dir: 1 | -1): number | null {
    const { chapters, chapterIndex } = useReaderAudioStore.getState()
    for (let i = chapterIndex + dir; i >= 0 && i < chapters.length; i += dir) {
      if (!chapters[i].is_volume) return i
    }
    return null
  }

  private computeHasNext(chapters: ReaderChapter[], index: number): boolean {
    for (let i = index + 1; i < chapters.length; i++) {
      if (!chapters[i].is_volume) return true
    }
    return false
  }
}

let engine: ReaderAudioEngine | null = null

/**
 * 取全局听书引擎（首次调用时才构造，避免没听过书的应用也创建一个 <audio>）。
 */
export function getReaderAudioEngine(): ReaderAudioEngine {
  if (!engine) engine = new ReaderAudioEngine()
  return engine
}