"use strict";
const fs = require("fs");
const path = require("path");
const config = require("./config");
const logger = require("./logger");
const store = require("./store");
const media = require("./media");
const { fileHash, atomicWriteSync } = require("./util");

/* ==================== 缓存状态管理（全局共享，因为切片只依赖歌曲） ==================== */
const cacheStatus = new Map(); // file -> 'pending'|'ready'|'error'
const retryCount = new Map(); // file -> number
const segmentsCache = new Map(); // file -> segments[]
const inFlight = new Set(); // 正在转码中的 file（避免重复入队）

let cacheTotalSize = 0;
let onCacheChange = null; // 回调：cache-status 变化广播

function setCacheChangeListener(fn) {
  onCacheChange = fn;
}
function getCacheTotalSize() {
  return cacheTotalSize;
}
function addCacheSize(n) {
  cacheTotalSize += n;
}

function setStatus(file, status) {
  cacheStatus.set(file, status);
  store.setCacheStatus(file, status);
  if (onCacheChange) onCacheChange(file, status);
}
function getStatus(file) {
  return cacheStatus.get(file) || "unknown";
}

function getSegments(file) {
  if (segmentsCache.has(file)) return segmentsCache.get(file);
  const segs = media.loadSongSegments(file);
  if (segs) segmentsCache.set(file, segs);
  return segs;
}
function invalidateSegments(file) {
  segmentsCache.delete(file);
}

// 触发预生成（带去重与重试上限）
// 说明：pending 表示“待生成”，不阻止入队；用 inFlight 防止重复入队
function triggerPreGenerate(file) {
  if (cacheStatus.get(file) === "ready") return;
  if (inFlight.has(file)) return;
  const retries = retryCount.get(file) || 0;
  if (retries >= config.MAX_RETRIES) {
    logger.warn(`[PRESEG] 跳过（已重试 ${config.MAX_RETRIES} 次）: ${file}`);
    setStatus(file, "error");
    return;
  }
  retryCount.set(file, retries + 1);
  inFlight.add(file);
  setStatus(file, "pending");

  const filePath = path.join(config.AUDIO_DIR, file);
  media
    .triggerPreGenerate(filePath, file)
    .then((res) => {
      inFlight.delete(file);
      if (res && res.size) cacheTotalSize += res.size;
      invalidateSegments(file);
      retryCount.delete(file);
      setStatus(file, "ready");
      if (onCacheSizeCheck) onCacheSizeCheck();
    })
    .catch(() => {
      inFlight.delete(file);
      setStatus(file, "error");
    });
}

let onCacheSizeCheck = null;
function setCacheSizeCheck(fn) {
  onCacheSizeCheck = fn;
}

// 启动时扫描已有缓存
function initCaches(songs) {
  cacheTotalSize = media.scanExistingCaches(songs);
  for (const song of songs) {
    const dir = media.getCacheDir(song.file);
    if (fs.existsSync(dir)) {
      const segs = media.loadSongSegments(song.file);
      if (segs) {
        cacheStatus.set(song.file, "ready");
        store.setCacheStatus(song.file, "ready");
        continue;
      }
    }
    cacheStatus.set(song.file, "pending");
    store.setCacheStatus(song.file, "pending");
  }
}

/* ==================== 缓存清理 ==================== */
function enforceCacheSizeLimit(allFiles) {
  if (cacheTotalSize <= config.MAX_CACHE_SIZE) return;
  logger.info(`[CACHE] ${(cacheTotalSize / 1024 / 1024).toFixed(1)}MB 超限，开始清理`);

  // 收集所有流正在播放/窗口内的歌曲，作为保护集
  const protectedFiles = new Set();
  for (const s of streams.values()) {
    for (const f of s.protectedFiles()) protectedFiles.add(f);
  }

  const items = [];
  const dirs = fs.readdirSync(config.HLS_CACHE_DIR);
  for (const entry of dirs) {
    const dir = path.join(config.HLS_CACHE_DIR, entry);
    try {
      if (!fs.statSync(dir).isDirectory()) continue;
    } catch (_) {
      continue;
    }
    let origFile = allFiles.find((f) => fileHash(f) === entry);
    const size = require("./util").getDirSize(dir);
    const song = origFile ? store.getSongByFile(origFile) : null;
    items.push({
      dir,
      size,
      origFile,
      isProtected: origFile ? protectedFiles.has(origFile) : false,
      heat: song ? song.heat || 0 : 0,
    });
  }
  items.sort((a, b) => {
    if (a.isProtected !== b.isProtected) return a.isProtected ? 1 : -1;
    return a.heat - b.heat;
  });
  for (const item of items) {
    if (cacheTotalSize <= config.MAX_CACHE_SIZE) break;
    logger.info(`[CACHE] 清理: ${path.basename(item.dir)} (${(item.size / 1024 / 1024).toFixed(1)}MB)`);
    fs.rmSync(item.dir, { recursive: true, force: true });
    cacheTotalSize = Math.max(0, cacheTotalSize - item.size);
    if (item.origFile) {
      invalidateSegments(item.origFile);
      setStatus(item.origFile, "pending");
    }
  }
}

/* ==================== LiveStream ==================== */
const streams = new Map(); // id -> LiveStream

class LiveStream {
  constructor(id, name) {
    this.id = id;
    this.name = name;
    this.liveSegments = []; // { duration, path, songId(file), songFile }
    this.mediaSequence = 0;
    this.currentIdx = 0; // 在播放列表行中的索引
    this.currentSongSegmentIdx = 0;
    this.timer = null;
    this.outDir = path.join(config.HLS_OUTPUT_DIR, id);
    fs.mkdirSync(this.outDir, { recursive: true });
  }

  get m3u8Path() {
    return path.join(this.outDir, "index.m3u8");
  }

  // 当前受保护的歌曲文件（窗口内 + 接下来2首）
  protectedFiles() {
    const set = new Set();
    for (const seg of this.liveSegments) set.add(seg.songFile);
    const rows = store.getPlaylistRows(this.id);
    for (let i = 0; i < Math.min(3, rows.length); i++) {
      const idx = (this.currentIdx + i) % rows.length;
      if (rows[idx]) set.add(rows[idx].file);
    }
    return set;
  }

  playlistRows() {
    return store.getPlaylistRows(this.id);
  }

  ensureNotEmpty() {
    let rows = this.playlistRows();
    if (rows.length === 0) {
      const songs = store.getAllSongs();
      if (songs.length > 0) {
        const pick = songs[Math.floor(Math.random() * songs.length)];
        store.addToPlaylist(this.id, pick.id);
        this.currentIdx = 0;
        this.currentSongSegmentIdx = 0;
        rows = this.playlistRows();
      }
    }
    return rows;
  }

  clampIdx(rows) {
    if (rows.length === 0) {
      this.currentIdx = 0;
      this.currentSongSegmentIdx = 0;
      return;
    }
    if (this.currentIdx < 0) this.currentIdx = 0;
    if (this.currentIdx >= rows.length) {
      this.currentIdx = 0;
      this.currentSongSegmentIdx = 0;
    }
  }

  advance() {
    const allSongs = store.getAllSongs();
    if (allSongs.length === 0) return;

    let rows = this.ensureNotEmpty();
    if (rows.length === 0) return;

    let safety = rows.length + 2;
    while (safety-- > 0) {
      this.clampIdx(rows);
      const row = rows[this.currentIdx];
      if (!row) return;
      const file = row.file;

      const status = getStatus(file);
      if (status !== "ready") {
        if (status !== "pending") triggerPreGenerate(file);
        this.currentIdx = (this.currentIdx + 1) % rows.length;
        this.currentSongSegmentIdx = 0;
        continue;
      }

      const segments = getSegments(file);
      if (!segments || segments.length === 0) {
        this.currentIdx = (this.currentIdx + 1) % rows.length;
        this.currentSongSegmentIdx = 0;
        continue;
      }

      // 歌曲播完 → 从播放列表移除该条目
      if (this.currentSongSegmentIdx >= segments.length) {
        const finishedName = file;
        store.removePlaylistEntry(this.id, row.entry_id);
        invalidateSegments(file);
        this.currentSongSegmentIdx = 0;

        rows = this.ensureNotEmpty();
        if (rows.length === 0) return;
        this.clampIdx(rows);
        if (onPlaylistChange) onPlaylistChange(this.id);
        if (onSongFinished) onSongFinished(this.id, finishedName);

        const nf = rows[this.currentIdx] && rows[this.currentIdx].file;
        if (nf && getStatus(nf) !== "ready") triggerPreGenerate(nf);
        continue;
      }

      // 正常追加切片
      const seg = segments[this.currentSongSegmentIdx];
      const songId = fileHash(file);
      this.liveSegments.push({
        duration: seg.duration,
        path: path.posix.join("/hls_cache", songId, seg.fileName),
        songId,
        songFile: file,
      });
      while (this.liveSegments.length > config.SLIDE_WINDOW_SIZE) {
        this.liveSegments.shift();
        this.mediaSequence++;
      }
      this.currentSongSegmentIdx++;
      this.writePlaylist();
      store.setStreamState(this.id, { media_seq: this.mediaSequence });
      return;
    }
    logger.warn(`[LIVE:${this.id}] 所有歌曲均不可用`);
  }

  writePlaylist() {
    if (this.liveSegments.length === 0) {
      atomicWriteSync(
        this.m3u8Path,
        `#EXTM3U\n#EXT-X-VERSION:3\n#EXT-X-TARGETDURATION:${config.HLS_TIME + 1}\n` +
          `#EXT-X-INDEPENDENT-SEGMENTS\n#EXT-X-MEDIA-SEQUENCE:0\n`
      );
      return;
    }
    const maxDur = this.liveSegments.reduce((m, s) => Math.max(m, s.duration), config.HLS_TIME);
    const targetDur = Math.max(config.HLS_TIME + 1, Math.ceil(maxDur) + 1);
    let content = "#EXTM3U\n#EXT-X-VERSION:3\n";
    content += `#EXT-X-TARGETDURATION:${targetDur}\n`;
    content += "#EXT-X-INDEPENDENT-SEGMENTS\n";
    content += `#EXT-X-MEDIA-SEQUENCE:${this.mediaSequence}\n`;
    for (let i = 0; i < this.liveSegments.length; i++) {
      if (config.USE_DISCONTINUITY && i > 0 && this.liveSegments[i].songId !== this.liveSegments[i - 1].songId) {
        content += "#EXT-X-DISCONTINUITY\n";
      }
      content += `#EXTINF:${this.liveSegments[i].duration.toFixed(3)},\n${this.liveSegments[i].path}\n`;
    }
    atomicWriteSync(this.m3u8Path, content);
  }

  start() {
    if (this.timer) clearInterval(this.timer);
    let attempts = 0;
    const target = Math.floor(config.SLIDE_WINDOW_SIZE / 2);
    while (this.liveSegments.length < target && attempts < config.SLIDE_WINDOW_SIZE * 2) {
      const prev = this.liveSegments.length;
      this.advance();
      attempts++;
      if (this.liveSegments.length === prev && this.liveSegments.length === 0) break;
    }
    this.timer = setInterval(() => this.advance(), config.LIVE_TICK_INTERVAL);
    logger.info(
      `[LIVE:${this.id}] 已启动 | 切片 ${config.HLS_TIME}s | 窗口 ${config.SLIDE_WINDOW_SIZE} 段 | 预填充 ${this.liveSegments.length} 段`
    );
  }

  stop() {
    if (this.timer) {
      clearInterval(this.timer);
      this.timer = null;
    }
    logger.info(`[LIVE:${this.id}] 已停止`);
  }

  resetCursor() {
    this.currentSongSegmentIdx = 0;
  }

  next() {
    const rows = this.playlistRows();
    if (rows.length === 0) return null;
    this.currentIdx = (this.currentIdx + 1) % rows.length;
    this.currentSongSegmentIdx = 0;
    const f = rows[this.currentIdx].file;
    if (getStatus(f) !== "ready") triggerPreGenerate(f);
    return f;
  }
  prev() {
    const rows = this.playlistRows();
    if (rows.length === 0) return null;
    this.currentIdx = (this.currentIdx - 1 + rows.length) % rows.length;
    this.currentSongSegmentIdx = 0;
    const f = rows[this.currentIdx].file;
    if (getStatus(f) !== "ready") triggerPreGenerate(f);
    return f;
  }
  jump(index) {
    const rows = this.playlistRows();
    if (index < 0 || index >= rows.length) return null;
    this.currentIdx = index;
    this.currentSongSegmentIdx = 0;
    const f = rows[this.currentIdx].file;
    if (getStatus(f) !== "ready") triggerPreGenerate(f);
    return f;
  }
}

/* ==================== 回调 ==================== */
let onPlaylistChange = null;
let onSongFinished = null;
function setStreamCallbacks({ playlistChange, songFinished }) {
  onPlaylistChange = playlistChange;
  onSongFinished = songFinished;
}

/* ==================== 管理器 ==================== */
function loadStreams() {
  const rows = store.listStreams();
  for (const r of rows) {
    const s = new LiveStream(r.id, r.name);
    s.currentIdx = r.current_pos || 0;
    s.mediaSequence = r.media_seq || 0;
    streams.set(r.id, s);
  }
  logger.info(`[LIVE] 载入 ${streams.size} 路流: ${[...streams.keys()].join(", ")}`);
}

function createStream(id, name) {
  if (streams.has(id)) throw new Error("流已存在");
  store.createStream(id, name);
  const s = new LiveStream(id, name);
  streams.set(id, s);
  s.start();
  return s;
}

function deleteStream(id) {
  if (id === "main") throw new Error("默认流不可删除");
  const s = streams.get(id);
  if (s) {
    s.stop();
    streams.delete(id);
  }
  store.deleteStream(id);
  // 删输出目录
  const dir = path.join(config.HLS_OUTPUT_DIR, id);
  if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true, force: true });
}

function getStream(id) {
  return streams.get(id);
}
function listStreams() {
  return [...streams.values()].map((s) => ({
    id: s.id,
    name: s.name,
    running: !!s.timer,
    m3u8: `/hls/${s.id}/index.m3u8`,
  }));
}

function startAll() {
  for (const s of streams.values()) s.start();
}
function stopAll() {
  for (const s of streams.values()) s.stop();
}

module.exports = {
  LiveStream,
  streams,
  loadStreams,
  createStream,
  deleteStream,
  getStream,
  listStreams,
  startAll,
  stopAll,
  // cache API
  getStatus,
  setStatus,
  getSegments,
  invalidateSegments,
  triggerPreGenerate,
  initCaches,
  enforceCacheSizeLimit,
  getCacheTotalSize,
  addCacheSize,
  setCacheChangeListener,
  setCacheSizeCheck,
  setStreamCallbacks,
};