const fs = require("fs");
const path = require("path");
const crypto = require("crypto");
const http = require("http");
const https = require("https");
const { spawn } = require("child_process");
const chokidar = require("chokidar");
const express = require("express");

// ==================== 路径常量 ====================
const AUDIO_DIR = path.join(__dirname, "audio");
const HLS_CACHE_DIR = path.join(__dirname, "hls_cache");
const HLS_OUTPUT_DIR = path.join(__dirname, "hls");
const PLAYLIST_FILE = path.join(__dirname, "playlist.json");
const HEAT_FILE = path.join(__dirname, "heat.json");
const METADATA_FILE = path.join(__dirname, "metadata.json");
const PUBLIC_DIR = path.join(__dirname, "public");

for (const dir of [AUDIO_DIR, HLS_CACHE_DIR, HLS_OUTPUT_DIR, PUBLIC_DIR]) {
  fs.mkdirSync(dir, { recursive: true });
}

// ==================== 配置 ====================
// 环境变量解析助手：非法或缺失时回退默认值
function envInt(name, fallback) {
  const v = parseInt(process.env[name], 10);
  return Number.isFinite(v) && v > 0 ? v : fallback;
}

const MAX_CACHE_SIZE = envInt("MAX_CACHE_MB", 1000) * 1024 * 1024;
const HLS_TIME = envInt("HLS_TIME", 5);
const SLIDE_WINDOW_SIZE = envInt("SLIDE_WINDOW", 15);
const LIVE_TICK_INTERVAL = HLS_TIME * 1000; // 与切片时长对齐，避免累积漂移
const HTTP_PORT = envInt("PORT", 3000);
const MAX_FFMPEG_CONCURRENT = envInt("FFMPEG_CONCURRENCY", 3);
const MAX_RETRIES = envInt("MAX_RETRIES", 3);
const FFMPEG_TIMEOUT = envInt("FFMPEG_TIMEOUT_MS", 5 * 60 * 1000);
const AUTH_TOKEN = process.env.AUTH_TOKEN || "";

// [FIX] DISCONTINUITY 默认关闭
// 设为 true：严格合规，但部分播放器会在标签处插入静音
// 设为 false：让播放器自然处理 PTS 跳变，兼容性更好
const USE_DISCONTINUITY = process.env.USE_DISCONTINUITY === "true";

// ==================== 全局状态 ====================
let audioFiles = [];
let playlist = [];
let heatMap = new Map();
let metadataMap = new Map();
let cacheStatus = new Map(); // 'ready' | 'pending' | 'error'
let server = null;
let cacheTotalSize = 0; // 增量追踪

let liveSegments = []; // { duration, path, songId }
let mediaSequence = 0;
let currentPlaylistIdx = 0;
let currentSongSegmentIdx = 0;
let songSegmentsCache = new Map();
let liveTimer = null;

let retryCount = new Map();
let heatSaveTimer = null;
let scanDebounceTimer = null;
const sseClients = new Set();

// ==================== FFmpeg 并发队列 ====================
class TaskQueue {
  constructor(max) {
    this.max = max;
    this.running = 0;
    this.queue = [];
  }
  push(fn) {
    this.queue.push(fn);
    this._drain();
  }
  _drain() {
    while (this.running < this.max && this.queue.length > 0) {
      this.running++;
      const task = this.queue.shift();
      task()
        .catch((e) => console.error("[QUEUE]", e.message))
        .finally(() => {
          this.running--;
          this._drain();
        });
    }
  }
}
const ffmpegQueue = new TaskQueue(MAX_FFMPEG_CONCURRENT);

// ==================== 工具函数 ====================
function fileHash(fp) {
  return crypto.createHash("md5").update(fp).digest("hex").slice(0, 16);
}
function getCacheDir(fp) {
  return path.join(HLS_CACHE_DIR, fileHash(fp));
}
function naturalCompare(a, b) {
  return a.localeCompare(b, undefined, { numeric: true, sensitivity: "base" });
}
function getDirSize(dirPath) {
  let size = 0;
  if (!fs.existsSync(dirPath)) return size;
  for (const entry of fs.readdirSync(dirPath)) {
    const full = path.join(dirPath, entry);
    try {
      const st = fs.statSync(full);
      size += st.isDirectory() ? getDirSize(full) : st.size;
    } catch (_) {}
  }
  return size;
}
function clampPlaylistIndex() {
  if (playlist.length === 0) {
    currentPlaylistIdx = 0;
    currentSongSegmentIdx = 0;
    return;
  }
  if (currentPlaylistIdx < 0) currentPlaylistIdx = 0;
  if (currentPlaylistIdx >= playlist.length) {
    currentPlaylistIdx = 0;
    currentSongSegmentIdx = 0;
  }
}

// [FIX] 原子写入：先写临时文件再 rename，播放器不会读到半截 M3U8
function atomicWriteSync(filePath, data) {
  const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
  fs.writeFileSync(tmp, data, "utf8");
  fs.renameSync(tmp, filePath);
}

// ==================== 网易云音源导入 ====================
const NETEASE_UA =
  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36";
const NETEASE_REFERER = "http://music.163.com/";

function neteaseRequest(url, redirects = 0) {
  return new Promise((resolve, reject) => {
    const lib = url.startsWith("https:") ? https : http;
    const req = lib.get(
      url,
      { headers: { "User-Agent": NETEASE_UA, Referer: NETEASE_REFERER } },
      (res) => {
        const code = res.statusCode;
        if ([301, 302, 303, 307, 308].includes(code) && res.headers.location) {
          res.resume();
          const loc = res.headers.location;
          if (loc.includes("/404"))
            return reject(new Error("该歌曲无版权或需 VIP，无法下载"));
          if (redirects >= 5) return reject(new Error("重定向次数过多"));
          const next = new URL(loc, url).toString();
          return resolve(neteaseRequest(next, redirects + 1));
        }
        if (code !== 200) {
          res.resume();
          return reject(new Error(`网易云 HTTP ${code}`));
        }
        resolve(res);
      },
    );
    req.on("error", reject);
    req.setTimeout(15000, () => req.destroy(new Error("网易云请求超时")));
  });
}

function readResponseBody(res) {
  return new Promise((resolve, reject) => {
    let body = "";
    res.setEncoding("utf8");
    res.on("data", (d) => (body += d));
    res.on("end", () => resolve(body));
    res.on("error", reject);
  });
}

function sanitizeFileName(name) {
  return name.replace(/[\\/:*?"<>|]/g, "_").trim();
}

async function fetchNetEaseDetail(id) {
  const url = `http://music.163.com/api/song/detail/?id=${id}&ids=[${id}]`;
  const res = await neteaseRequest(url);
  const body = await readResponseBody(res);
  const json = JSON.parse(body.replace(/^/, ""));
  const song = json.songs && json.songs[0];
  if (!song) throw new Error("未找到歌曲（可能是无版权/灰色歌曲）");
  return {
    name: song.name,
    artist: (song.artists && song.artists[0] && song.artists[0].name) || "",
    albumImage: (song.album && song.album.blurPicUrl) || "",
  };
}

function downloadNetEase(id, filename) {
  return new Promise((resolve, reject) => {
    const url = `http://music.163.com/song/media/outer/url?id=${id}.mp3`;
    neteaseRequest(url)
      .then((res) => {
        const filePath = path.join(AUDIO_DIR, filename + ".mp3");
        const ws = fs.createWriteStream(filePath);
        ws.on("finish", () => {
          const ctype = res.headers["content-type"] || "";
          if (!ctype.startsWith("audio")) {
            fs.unlinkSync(filePath);
            return reject(
              new Error(`返回非音频内容 (${ctype})，歌曲可能无版权`),
            );
          }
          resolve(filePath);
        });
        ws.on("error", reject);
        res.on("error", reject);
        res.pipe(ws);
      })
      .catch(reject);
  });
}

// 网易云音源：歌名搜索（返回精简列表，过滤 fee=1）
async function searchNetEase(keyword, offset = 0, limit = 20) {
  const url =
    "http://music.163.com/api/search/get/web?csrf_token=hlpretag=&hlposttag=" +
    "&s=" +
    encodeURIComponent(keyword) +
    "&type=1&offset=" +
    offset +
    "&total=true&limit=" +
    limit;
  const res = await neteaseRequest(url);
  const body = await readResponseBody(res);
  const json = JSON.parse(body.replace(/^/, ""));
  const songs = (json.result && json.result.songs) || [];
  const list = songs
    .filter((s) => Number(s.fee) !== 1)
    .map((s) => {
      const item = {
        id: s.id,
        name: s.name,
        artists: (s.artists || []).map((a) => a.name).filter(Boolean),
        duration: s.duration,
      };
      const alias = s.alias || [];
      if (alias.length) item.alias = alias;
      return item;
    });
  return { total: list.length, list };
}

// ==================== SSE 推送 ====================
function broadcastSSE(event, data) {
  const msg = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
  for (const c of sseClients) {
    try {
      c.write(msg);
    } catch (_) {
      sseClients.delete(c);
    }
  }
}
function getPlaylistSnapshot() {
  return playlist.map((file, idx) => ({
    name: path.basename(file),
    path: file,
    heat: heatMap.get(file) || 0,
    cacheStatus: cacheStatus.get(file) || "unknown",
    isCurrent: idx === currentPlaylistIdx,
  }));
}

// ==================== 热度管理（防抖落盘）====================
function loadHeatMap() {
  try {
    heatMap = new Map(
      Object.entries(JSON.parse(fs.readFileSync(HEAT_FILE, "utf8"))),
    );
  } catch (_) {
    heatMap = new Map();
  }
}
function saveHeatMap() {
  try {
    fs.writeFileSync(
      HEAT_FILE,
      JSON.stringify(Object.fromEntries(heatMap), null, 2),
    );
  } catch (_) {}
}
function scheduleHeatSave() {
  if (heatSaveTimer) clearTimeout(heatSaveTimer);
  heatSaveTimer = setTimeout(saveHeatMap, 5000);
}
function incrementHeat(fp) {
  heatMap.set(fp, (heatMap.get(fp) || 0) + 1);
  scheduleHeatSave();
}

// ==================== 播放列表 ====================
function loadPlaylist() {
  try {
    playlist = JSON.parse(fs.readFileSync(PLAYLIST_FILE, "utf8")).filter((p) =>
      fs.existsSync(p),
    );
  } catch (_) {
    playlist = [];
  }
}
function savePlaylist() {
  try {
    fs.writeFileSync(PLAYLIST_FILE, JSON.stringify(playlist, null, 2));
  } catch (_) {}
}

// ==================== 切片元数据解析 ====================
function loadSongSegments(fp) {
  if (songSegmentsCache.has(fp)) return songSegmentsCache.get(fp);
  const m3u8 = path.join(getCacheDir(fp), "index.m3u8");
  if (!fs.existsSync(m3u8)) return null;
  try {
    const lines = fs
      .readFileSync(m3u8, "utf8")
      .split("\n")
      .map((l) => l.trim())
      .filter(Boolean);
    const segments = [];
    let dur = HLS_TIME;
    for (const line of lines) {
      if (line.startsWith("#EXTINF:")) {
        dur = parseFloat(line.split(":")[1].replace(",", ""));
      } else if (!line.startsWith("#") && line.endsWith(".ts")) {
        segments.push({ duration: dur, fileName: path.basename(line) });
      }
    }
    if (segments.length === 0) return null;
    songSegmentsCache.set(fp, segments);
    return segments;
  } catch (e) {
    console.error("[SEG]", path.basename(fp), e.message);
    return null;
  }
}

// ==================== 音频探测 ====================
function probeAudio(fp) {
  return new Promise((resolve, reject) => {
    const proc = spawn("ffprobe", [
      "-v",
      "error",
      "-select_streams",
      "a:0",
      "-show_entries",
      "stream=codec_name,sample_rate,channels:format=duration",
      "-of",
      "json",
      fp,
    ]);
    let out = "",
      err = "";
    proc.stdout.on("data", (d) => (out += d));
    proc.stderr.on("data", (d) => (err += d));
    proc.on("close", (code) => {
      if (code !== 0) return reject(new Error(err));
      try {
        const data = JSON.parse(out);
        const s = data.streams?.[0];
        if (!s) return reject(new Error("无音频流"));
        const dur =
          data.format && data.format.duration
            ? parseFloat(data.format.duration)
            : null;
        resolve({
          codec: s.codec_name,
          sampleRate: parseInt(s.sample_rate, 10),
          channels: s.channels,
          duration: dur,
        });
      } catch (e) {
        reject(e);
      }
    });
    proc.on("error", reject);
  });
}

// ==================== 音频元数据管理 ====================
function loadMetadata() {
  try {
    metadataMap = new Map(
      Object.entries(JSON.parse(fs.readFileSync(METADATA_FILE, "utf8"))),
    );
  } catch (_) {
    metadataMap = new Map();
  }
}
function saveMetadata() {
  try {
    fs.writeFileSync(
      METADATA_FILE,
      JSON.stringify(Object.fromEntries(metadataMap), null, 2),
    );
  } catch (_) {}
}
// 从「作者 - 歌名.mp3」文件名解析出作者与歌名
function parseFileName(fileName) {
  const stem = fileName.replace(/\.[^.]+$/, "");
  const idx = stem.indexOf(" - ");
  if (idx > 0)
    return {
      artist: stem.slice(0, idx).trim(),
      name: stem.slice(idx + 3).trim(),
    };
  return { artist: "", name: stem.trim() };
}
// 补齐某音频的元数据（歌名/作者/封面/时长）；已有则跳过，仅补缺失的时长
async function ensureMetadata(filePath) {
  if (metadataMap.has(filePath)) {
    const m = metadataMap.get(filePath);
    if (m.duration == null) {
      try {
        m.duration = (await probeAudio(filePath)).duration;
        saveMetadata();
      } catch (_) {}
    }
    return m;
  }
  const parsed = parseFileName(path.basename(filePath));
  const meta = {
    name: parsed.name,
    artist: parsed.artist,
    albumImage: "",
    duration: null,
  };
  try {
    meta.duration = (await probeAudio(filePath)).duration;
  } catch (_) {}
  metadataMap.set(filePath, meta);
  saveMetadata();
  return meta;
}

// ==================== [FIX] 启动缓存扫描 ====================
// 在 preGenerateAll 之前调用，识别已有缓存，避免重复生成
function scanExistingCaches() {
  const hashMap = new Map();
  for (const file of audioFiles) hashMap.set(fileHash(file), file);

  let validCount = 0;
  for (const entry of fs.readdirSync(HLS_CACHE_DIR)) {
    const dir = path.join(HLS_CACHE_DIR, entry);
    try {
      if (!fs.statSync(dir).isDirectory()) continue;
    } catch (_) {
      continue;
    }

    const originalFile = hashMap.get(entry);
    if (!originalFile) continue; // 孤立缓存，后续由 enforceCacheSizeLimit 清理

    // 检查 index.m3u8 是否存在且可解析
    const segments = loadSongSegments(originalFile);
    if (segments && segments.length > 0) {
      // 检查所有 .ts 文件是否完整存在且非空
      const allValid = segments.every((seg) => {
        const segPath = path.join(dir, seg.fileName);
        try {
          return fs.existsSync(segPath) && fs.statSync(segPath).size > 0;
        } catch (_) {
          return false;
        }
      });

      if (allValid) {
        cacheStatus.set(originalFile, "ready");
        cacheTotalSize += getDirSize(dir);
        validCount++;
      } else {
        console.log(
          `[CACHE] 不完整，将重新生成: ${path.basename(originalFile)}`,
        );
        const oldSize = getDirSize(dir);
        fs.rmSync(dir, { recursive: true, force: true });
        cacheTotalSize = Math.max(0, cacheTotalSize - oldSize);
        songSegmentsCache.delete(originalFile);
      }
    } else {
      // index.m3u8 不存在或无法解析
      const oldSize = getDirSize(dir);
      fs.rmSync(dir, { recursive: true, force: true });
      cacheTotalSize = Math.max(0, cacheTotalSize - oldSize);
    }
  }
  console.log(
    `[CACHE] 启动扫描: ${validCount}/${audioFiles.length} 个缓存有效，` +
      `总大小 ${(cacheTotalSize / 1024 / 1024).toFixed(1)}MB`,
  );
}

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

  // 保护当前 + 接下来 2 首
  const protectedFiles = new Set();
  for (let i = 0; i < Math.min(3, playlist.length); i++) {
    const idx = (currentPlaylistIdx + i) % playlist.length;
    if (playlist[idx]) protectedFiles.add(playlist[idx]);
  }

  // 保护直播滑动窗口中的歌曲（即使已从播放列表移除）
  const liveHashes = new Set(liveSegments.map((s) => s.songId));

  const items = [];
  for (const entry of fs.readdirSync(HLS_CACHE_DIR)) {
    const dir = path.join(HLS_CACHE_DIR, entry);
    try {
      if (!fs.statSync(dir).isDirectory()) continue;
    } catch (_) {
      continue;
    }
    let origFile = null;
    for (const a of audioFiles) {
      if (fileHash(a) === entry) {
        origFile = a;
        break;
      }
    }
    const size = getDirSize(dir);
    items.push({
      dir,
      size,
      origFile,
      inLiveWindow: liveHashes.has(entry),
      isProtected: origFile ? protectedFiles.has(origFile) : false,
      inPlaylist: origFile ? playlist.includes(origFile) : false,
      heat: origFile ? heatMap.get(origFile) || 0 : 0,
    });
  }

  // 清理优先级：不受保护 → 不在播放列表 → 不在直播窗口 → 热度低
  items.sort((a, b) => {
    if (a.inLiveWindow !== b.inLiveWindow) return a.inLiveWindow ? 1 : -1;
    if (a.isProtected !== b.isProtected) return a.isProtected ? 1 : -1;
    if (a.inPlaylist !== b.inPlaylist) return a.inPlaylist ? 1 : -1;
    return a.heat - b.heat;
  });

  for (const item of items) {
    if (cacheTotalSize <= MAX_CACHE_SIZE) break;
    console.log(
      `[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) {
      cacheStatus.set(item.origFile, "pending");
      songSegmentsCache.delete(item.origFile);
      if (!item.isProtected) triggerPreGenerate(item.origFile);
    }
  }
}

// ==================== HLS 预生成 ====================
function triggerPreGenerate(filePath) {
  const status = cacheStatus.get(filePath);
  if (status === "pending" || status === "ready") return;

  const retries = retryCount.get(filePath) || 0;
  if (retries >= MAX_RETRIES) {
    console.warn(
      `[PRESEG] 跳过（已重试 ${MAX_RETRIES} 次）: ${path.basename(filePath)}`,
    );
    return;
  }
  retryCount.set(filePath, retries + 1);
  cacheStatus.set(filePath, "pending");

  const cacheDir = getCacheDir(filePath);
  // [FIX] 仅清理残留缓存（正常路径不会走到这里，因为 scanExistingCaches 已处理）
  if (fs.existsSync(cacheDir)) {
    cacheTotalSize = Math.max(0, cacheTotalSize - getDirSize(cacheDir));
    fs.rmSync(cacheDir, { recursive: true, force: true });
  }
  fs.mkdirSync(cacheDir, { recursive: true });

  ffmpegQueue.push(async () => {
    // 探测源格式：AAC 44.1kHz 立体声 → copy 模式避免二次压缩损耗
    let audioArgs;
    try {
      const probe = await probeAudio(filePath);
      if (
        probe.codec === "aac" &&
        probe.sampleRate === 44100 &&
        probe.channels <= 2
      ) {
        audioArgs = ["-c:a", "copy"];
        console.log(`[PRESEG] copy: ${path.basename(filePath)}`);
      } else {
        audioArgs = [
          "-c:a",
          "aac",
          "-b:a",
          "192k",
          "-ar",
          "44100",
          "-ac",
          "2",
          "-profile:a",
          "aac_low",
        ];
        console.log(
          `[PRESEG] 转码: ${path.basename(filePath)} (${probe.codec} ${probe.sampleRate}Hz)`,
        );
      }
    } catch (_) {
      audioArgs = [
        "-c:a",
        "aac",
        "-b:a",
        "192k",
        "-ar",
        "44100",
        "-ac",
        "2",
        "-profile:a",
        "aac_low",
      ];
    }

    return new Promise((resolve, reject) => {
      const outputM3u8 = path.join(cacheDir, "index.m3u8");
      const args = [
        "-y",
        "-fflags",
        "+genpts+discardcorrupt",
        "-i",
        filePath,
        ...audioArgs,
        "-vn",
        "-avoid_negative_ts",
        "make_zero",
        "-hls_time",
        String(HLS_TIME),
        "-hls_list_size",
        "0",
        "-hls_segment_type",
        "mpegts",
        "-hls_flags",
        "independent_segments",
        "-max_muxing_queue_size",
        "2048",
        "-f",
        "hls",
        outputM3u8,
      ];

      const proc = spawn("ffmpeg", args);
      let stderrBuf = "";
      proc.stderr.on("data", (d) => {
        stderrBuf += d.toString();
        if (stderrBuf.length > 4096) stderrBuf = stderrBuf.slice(-4096);
      });

      // [FIX] 超时保护：防止 FFmpeg 挂死阻塞队列
      const timer = setTimeout(() => {
        proc.kill("SIGKILL");
        console.error(`[PRESEG] 超时终止: ${path.basename(filePath)}`);
      }, FFMPEG_TIMEOUT);

      proc.on("close", (code) => {
        clearTimeout(timer);
        if (code === 0) {
          console.log(`[PRESEG] 完成: ${path.basename(filePath)}`);
          cacheStatus.set(filePath, "ready");
          songSegmentsCache.delete(filePath);
          retryCount.delete(filePath);
          cacheTotalSize += getDirSize(cacheDir);
          enforceCacheSizeLimit();
          broadcastSSE("cache-status", {
            file: path.basename(filePath),
            status: "ready",
          });
          resolve();
        } else {
          cacheStatus.set(filePath, "error");
          if (fs.existsSync(cacheDir))
            fs.rmSync(cacheDir, { recursive: true, force: true });
          console.error(
            `[PRESEG] 失败 code=${code}: ${path.basename(filePath)}`,
          );
          reject(new Error(`FFmpeg exit ${code}`));
        }
      });

      proc.on("error", (err) => {
        clearTimeout(timer);
        cacheStatus.set(filePath, "error");
        reject(err);
      });
    });
  });
}

function preGenerateAll() {
  for (const file of audioFiles) {
    const status = cacheStatus.get(file);
    if (!status || status === "error") triggerPreGenerate(file);
  }
}

// ==================== 直播流核心 ====================
function generateLivePlaylist() {
  if (liveSegments.length === 0) {
    atomicWriteSync(
      path.join(HLS_OUTPUT_DIR, "index.m3u8"),
      `#EXTM3U\n#EXT-X-VERSION:3\n` +
        `#EXT-X-TARGETDURATION:${HLS_TIME + 1}\n` +
        `#EXT-X-INDEPENDENT-SEGMENTS\n` +
        `#EXT-X-MEDIA-SEQUENCE:0\n`,
    );
    return;
  }

  // TARGETDURATION = 所有切片最大时长向上取整 + 1（安全余量）
  const maxDur = liveSegments.reduce(
    (m, s) => Math.max(m, s.duration),
    HLS_TIME,
  );
  const targetDur = Math.max(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:${mediaSequence}\n`;

  for (let i = 0; i < liveSegments.length; i++) {
    // 可选：仅在启用时插入不连续性标记
    if (
      USE_DISCONTINUITY &&
      i > 0 &&
      liveSegments[i].songId !== liveSegments[i - 1].songId
    ) {
      content += "#EXT-X-DISCONTINUITY\n";
    }
    content += `#EXTINF:${liveSegments[i].duration.toFixed(3)},\n${liveSegments[i].path}\n`;
  }

  // [FIX] 原子写入
  atomicWriteSync(path.join(HLS_OUTPUT_DIR, "index.m3u8"), content);
}

function advanceLiveStream() {
  if (audioFiles.length === 0) return;

  if (playlist.length === 0) {
    playlist.push(audioFiles[Math.floor(Math.random() * audioFiles.length)]);
    savePlaylist();
    currentPlaylistIdx = 0;
    currentSongSegmentIdx = 0;
    broadcastSSE("playlist-update", getPlaylistSnapshot());
  }

  let safety = playlist.length + 2;
  while (safety-- > 0) {
    clampPlaylistIndex();

    const currentSong = playlist[currentPlaylistIdx];
    const status = cacheStatus.get(currentSong);

    // 未就绪 → 跳下一首
    if (status !== "ready") {
      if (status !== "pending") triggerPreGenerate(currentSong);
      currentPlaylistIdx = (currentPlaylistIdx + 1) % playlist.length;
      currentSongSegmentIdx = 0;
      continue;
    }

    const segments = loadSongSegments(currentSong);
    if (!segments || segments.length === 0) {
      currentPlaylistIdx = (currentPlaylistIdx + 1) % playlist.length;
      currentSongSegmentIdx = 0;
      continue;
    }

    // ===== 歌曲播放完毕 → 从列表中移除 =====
    if (currentSongSegmentIdx >= segments.length) {
      const finishedName = path.basename(currentSong);
      // splice 只移除当前位置的一个实例，同歌其他实例保留
      playlist.splice(currentPlaylistIdx, 1);
      songSegmentsCache.delete(currentSong);
      currentSongSegmentIdx = 0;

      // 列表空了 → 自动补一首
      if (playlist.length === 0 && audioFiles.length > 0) {
        playlist.push(
          audioFiles[Math.floor(Math.random() * audioFiles.length)],
        );
        currentPlaylistIdx = 0;
      }

      savePlaylist();
      clampPlaylistIndex();
      broadcastSSE("song-finished", { name: finishedName });
      broadcastSSE("playlist-update", getPlaylistSnapshot());

      // 确保下一首缓存就绪
      if (
        playlist.length > 0 &&
        cacheStatus.get(playlist[currentPlaylistIdx]) !== "ready"
      ) {
        triggerPreGenerate(playlist[currentPlaylistIdx]);
      }

      continue; // 立即尝试追加下一首的切片，不留间隙
    }

    // ===== 正常追加切片 =====
    const seg = segments[currentSongSegmentIdx];
    const songId = fileHash(currentSong);
    liveSegments.push({
      duration: seg.duration,
      path: path.posix.join("/hls_cache", songId, seg.fileName),
      songId,
    });

    while (liveSegments.length > SLIDE_WINDOW_SIZE) {
      liveSegments.shift();
      mediaSequence++;
    }

    currentSongSegmentIdx++;
    generateLivePlaylist();
    return; // 成功追加一个切片，等下一个 tick
  }

  console.warn("[LIVE] 所有歌曲均不可用");
}

function startLiveStream() {
  if (liveTimer) clearInterval(liveTimer);

  // 预填充窗口（以实际长度为终止条件）
  let attempts = 0;
  const target = Math.floor(SLIDE_WINDOW_SIZE / 2);
  while (liveSegments.length < target && attempts < SLIDE_WINDOW_SIZE * 2) {
    const prev = liveSegments.length;
    advanceLiveStream();
    attempts++;
    if (liveSegments.length === prev && liveSegments.length === 0) break;
  }

  liveTimer = setInterval(advanceLiveStream, LIVE_TICK_INTERVAL);
  console.log(
    `[LIVE] 已启动 | 切片 ${HLS_TIME}s | 窗口 ${SLIDE_WINDOW_SIZE} 段 ≈${SLIDE_WINDOW_SIZE * HLS_TIME}s | 预填充 ${liveSegments.length} 段`,
  );
}

// ==================== 资源扫描 ====================
function scanAudioFiles() {
  const exts = [".mp3", ".m4a", ".flac", ".wav"];
  audioFiles = fs
    .readdirSync(AUDIO_DIR)
    .filter((n) => exts.includes(path.extname(n).toLowerCase()))
    .map((n) => path.join(AUDIO_DIR, n))
    .sort(naturalCompare);
  console.log(`[INFO] 资源: ${audioFiles.length} 个文件`);
}

function sanitizePlaylist() {
  const valid = new Set(audioFiles);
  for (const p of playlist) {
    if (!valid.has(p)) songSegmentsCache.delete(p);
  }
  playlist = playlist.filter((p) => valid.has(p));
  clampPlaylistIndex();
  savePlaylist();
}

// ==================== [FIX] 初始化顺序 ====================
// 1. 加载持久化数据
// 2. 扫描文件列表
// 3. 验证已有缓存（关键！在 preGenerateAll 之前）
// 4. 只生成缺失的缓存
loadHeatMap();
loadMetadata();
loadPlaylist();
scanAudioFiles();
audioFiles.forEach((f) => ensureMetadata(f)); // 异步补全元数据（封面/时长等）
scanExistingCaches(); // ← 识别已有缓存，设为 ready
preGenerateAll(); // ← 只处理 status 为空或 error 的文件
enforceCacheSizeLimit();
sanitizePlaylist();
startLiveStream();

// ==================== 文件监听（防抖）====================
const watcher = chokidar.watch(AUDIO_DIR, {
  ignoreInitial: true,
  awaitWriteFinish: { stabilityThreshold: 500 },
});
function scheduleScan() {
  if (scanDebounceTimer) clearTimeout(scanDebounceTimer);
  scanDebounceTimer = setTimeout(() => {
    scanAudioFiles();
    audioFiles.forEach((f) => ensureMetadata(f));
    preGenerateAll();
    enforceCacheSizeLimit();
    sanitizePlaylist();
  }, 500);
}
watcher.on("add", scheduleScan);
watcher.on("unlink", scheduleScan);

// ==================== 认证 ====================
function authMiddleware(req, res, next) {
  if (!AUTH_TOKEN) return next();
  if (req.headers.authorization === `Bearer ${AUTH_TOKEN}`) return next();
  return res.status(401).json({ error: "未授权" });
}

// ==================== HTTP API ====================
const app = express();
app.use((req, res, next) => {
  res.header("Access-Control-Allow-Origin", "*");
  res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
  res.header("Access-Control-Allow-Headers", "Content-Type, Authorization");
  if (req.method === "OPTIONS") return res.sendStatus(200);
  next();
});
app.use(express.json());
app.use(express.static(PUBLIC_DIR));

// [FIX] M3U8 禁止浏览器缓存，确保每次都获取最新版本
app.use(
  "/hls",
  express.static(HLS_OUTPUT_DIR, {
    setHeaders: (res, filePath) => {
      if (filePath.endsWith(".m3u8")) {
        res.set("Content-Type", "application/vnd.apple.mpegurl; charset=utf-8");
        res.set("Cache-Control", "no-cache, no-store, must-revalidate");
      }
    },
  }),
);
app.use("/hls_cache", express.static(HLS_CACHE_DIR));

app.get("/api/events", (req, res) => {
  res.writeHead(200, {
    "Content-Type": "text/event-stream",
    "Cache-Control": "no-cache",
    Connection: "keep-alive",
  });
  res.write(":ok\n\n");
  sseClients.add(res);
  req.on("close", () => sseClients.delete(res));
});

app.use("/api", authMiddleware);

function isValidFileName(f) {
  return (
    typeof f === "string" &&
    f.length > 0 &&
    f.length < 500 &&
    !f.includes("..") &&
    !f.includes("/") &&
    !f.includes("\\") &&
    !f.includes("\0")
  );
}

app.get("/api/resources", (req, res) => {
  res.json(
    audioFiles.map((f) => {
      const m = metadataMap.get(f) || {
        name: path.basename(f),
        artist: "",
        albumImage: "",
        duration: null,
      };
      let fileSize = 0;
      try {
        fileSize = fs.statSync(f).size;
      } catch (_) {}
      return {
        file: path.basename(f),
        path: f,
        title: m.name,
        artist: m.artist || "",
        albumImage: m.albumImage || "",
        duration: m.duration || null,
        fileSize,
        heat: heatMap.get(f) || 0,
        cacheStatus: cacheStatus.get(f) || "unknown",
        cacheSize: (() => {
          const d = getCacheDir(f);
          return fs.existsSync(d) ? getDirSize(d) : 0;
        })(),
      };
    }),
  );
});

// 网易云音源：歌名搜索
app.get("/api/music/search", async (req, res) => {
  const { keyword } = req.query;
  if (!keyword || !String(keyword).trim())
    return res.status(400).json({ error: "缺少搜索关键词" });
  try {
    res.json(await searchNetEase(String(keyword).trim()));
  } catch (e) {
    res.status(400).json({ error: e.message });
  }
});

// 网易云音源：查询歌曲详情（歌名/作者/专辑图）
app.post("/api/music/detail", async (req, res) => {
  const { id } = req.body;
  if (!id || !/^\d+$/.test(String(id)))
    return res.status(400).json({ error: "无效 id" });
  try {
    res.json(await fetchNetEaseDetail(String(id)));
  } catch (e) {
    res.status(400).json({ error: e.message });
  }
});

// 网易云音源：下载入库（保存到 audio/，watcher 自动切片）
app.post("/api/music/download", async (req, res) => {
  const { id, name, artist, albumImage } = req.body;
  if (!id || !/^\d+$/.test(String(id)))
    return res.status(400).json({ error: "无效 id" });
  try {
    // 缺省时重新查详情，统一拿到歌名/作者/封面
    let meta = { name, artist: artist || "", albumImage: albumImage || "" };
    if (!meta.name) {
      const info = await fetchNetEaseDetail(String(id));
      meta = {
        name: info.name,
        artist: info.artist || "",
        albumImage: info.albumImage || "",
      };
    }
    const filename = sanitizeFileName(
      meta.artist ? `${meta.artist} - ${meta.name}` : meta.name,
    );
    if (!filename) return res.status(400).json({ error: "缺少歌名" });

    // 防重复：同名文件已存在则不覆盖（覆盖触发 change 而非 add，不会重新切片）
    if (fs.existsSync(path.join(AUDIO_DIR, filename + ".mp3")))
      return res.status(409).json({ error: `已存在: ${filename}.mp3` });

    const filePath = await downloadNetEase(String(id), filename);
    metadataMap.set(filePath, { ...meta, duration: null }); // 时长稍后由 ensureMetadata 补齐
    saveMetadata();
    res.json({ success: true, file: path.basename(filePath) });
  } catch (e) {
    res.status(400).json({ error: e.message });
  }
});

app.get("/api/playlist", (req, res) => res.json(getPlaylistSnapshot()));

app.post("/api/playlist/add", (req, res) => {
  const { file } = req.body;
  if (!isValidFileName(file))
    return res.status(400).json({ error: "无效文件名" });
  const tp = path.join(AUDIO_DIR, file);
  if (!audioFiles.includes(tp))
    return res.status(404).json({ error: "资源不存在" });
  playlist.push(tp);
  incrementHeat(tp);
  savePlaylist();
  if (cacheStatus.get(tp) !== "ready") triggerPreGenerate(tp);
  broadcastSSE("playlist-update", getPlaylistSnapshot());
  res.json({ success: true, playlist: playlist.map((p) => path.basename(p)) });
});

app.post("/api/playlist/remove", (req, res) => {
  const { index } = req.body;
  if (
    typeof index !== "number" ||
    !Number.isInteger(index) ||
    index < 0 ||
    index >= playlist.length
  )
    return res.status(400).json({ error: "无效索引" });
  if (index < currentPlaylistIdx) currentPlaylistIdx--;
  else if (index === currentPlaylistIdx) currentSongSegmentIdx = 0;
  playlist.splice(index, 1);
  if (playlist.length === 0 && audioFiles.length > 0) {
    playlist.push(audioFiles[Math.floor(Math.random() * audioFiles.length)]);
    currentPlaylistIdx = 0;
    currentSongSegmentIdx = 0;
  }
  clampPlaylistIndex();
  savePlaylist();
  broadcastSSE("playlist-update", getPlaylistSnapshot());
  res.json({ success: true, playlist: playlist.map((p) => path.basename(p)) });
});

app.post("/api/playlist/reorder", (req, res) => {
  const { newOrder } = req.body;
  if (!Array.isArray(newOrder))
    return res.status(400).json({ error: "无效数据" });
  const valid = new Set(audioFiles);
  const cur = playlist[currentPlaylistIdx];
  playlist = newOrder.filter((p) => typeof p === "string" && valid.has(p));
  const ni = playlist.indexOf(cur);
  currentPlaylistIdx = ni !== -1 ? ni : 0;
  if (ni === -1) currentSongSegmentIdx = 0;
  if (playlist.length === 0 && audioFiles.length > 0) {
    playlist.push(audioFiles[Math.floor(Math.random() * audioFiles.length)]);
    currentPlaylistIdx = 0;
    currentSongSegmentIdx = 0;
  }
  savePlaylist();
  broadcastSSE("playlist-update", getPlaylistSnapshot());
  res.json({ success: true, playlist: playlist.map((p) => path.basename(p)) });
});

app.post("/api/playlist/clear", (req, res) => {
  for (const f of playlist) songSegmentsCache.delete(f);
  playlist = [];
  if (audioFiles.length > 0)
    playlist.push(audioFiles[Math.floor(Math.random() * audioFiles.length)]);
  currentPlaylistIdx = 0;
  currentSongSegmentIdx = 0;
  savePlaylist();
  broadcastSSE("playlist-update", getPlaylistSnapshot());
  res.json({ success: true, playlist: playlist.map((p) => path.basename(p)) });
});

app.post("/api/playlist/next", (req, res) => {
  if (playlist.length === 0)
    return res.status(400).json({ error: "播放列表为空" });
  currentPlaylistIdx = (currentPlaylistIdx + 1) % playlist.length;
  currentSongSegmentIdx = 0;
  if (cacheStatus.get(playlist[currentPlaylistIdx]) !== "ready")
    triggerPreGenerate(playlist[currentPlaylistIdx]);
  broadcastSSE("now-playing", {
    index: currentPlaylistIdx,
    name: path.basename(playlist[currentPlaylistIdx]),
  });
  broadcastSSE("playlist-update", getPlaylistSnapshot());
  res.json({
    success: true,
    current: path.basename(playlist[currentPlaylistIdx]),
  });
});

app.post("/api/playlist/prev", (req, res) => {
  if (playlist.length === 0)
    return res.status(400).json({ error: "播放列表为空" });
  currentPlaylistIdx =
    (currentPlaylistIdx - 1 + playlist.length) % playlist.length;
  currentSongSegmentIdx = 0;
  if (cacheStatus.get(playlist[currentPlaylistIdx]) !== "ready")
    triggerPreGenerate(playlist[currentPlaylistIdx]);
  broadcastSSE("now-playing", {
    index: currentPlaylistIdx,
    name: path.basename(playlist[currentPlaylistIdx]),
  });
  broadcastSSE("playlist-update", getPlaylistSnapshot());
  res.json({
    success: true,
    current: path.basename(playlist[currentPlaylistIdx]),
  });
});

app.post("/api/playlist/jump", (req, res) => {
  const { index } = req.body;
  if (
    typeof index !== "number" ||
    !Number.isInteger(index) ||
    index < 0 ||
    index >= playlist.length
  )
    return res.status(400).json({ error: "无效索引" });
  currentPlaylistIdx = index;
  currentSongSegmentIdx = 0;
  if (cacheStatus.get(playlist[currentPlaylistIdx]) !== "ready")
    triggerPreGenerate(playlist[currentPlaylistIdx]);
  broadcastSSE("now-playing", {
    index: currentPlaylistIdx,
    name: path.basename(playlist[currentPlaylistIdx]),
  });
  broadcastSSE("playlist-update", getPlaylistSnapshot());
  res.json({
    success: true,
    current: path.basename(playlist[currentPlaylistIdx]),
  });
});

app.get("/api/cache/size", (req, res) => {
  res.json({
    total: cacheTotalSize,
    limit: MAX_CACHE_SIZE,
    usedPercent: ((cacheTotalSize / MAX_CACHE_SIZE) * 100).toFixed(2),
  });
});

app.post("/api/cache/cleanup", (req, res) => {
  enforceCacheSizeLimit();
  res.json({ success: true, total: cacheTotalSize, limit: MAX_CACHE_SIZE });
});

// ==================== 启动 ====================
server = app.listen(HTTP_PORT, () => {
  console.log(`[HTTP] 面板: http://127.0.0.1:${HTTP_PORT}`);
  console.log(`[HTTP] 直播: http://127.0.0.1:${HTTP_PORT}/hls/index.m3u8`);
  if (AUTH_TOKEN) console.log("[HTTP] 认证已启用");
});

process.on("uncaughtException", (err) => {
  console.error("[FATAL]", err.message, err.stack);
});
process.on("unhandledRejection", (r) => console.error("[WARN]", r));

process.on("SIGINT", () => {
  console.log("\n[EXIT] 正在关闭...");
  if (liveTimer) clearInterval(liveTimer);
  if (heatSaveTimer) clearTimeout(heatSaveTimer);
  if (scanDebounceTimer) clearTimeout(scanDebounceTimer);
  for (const c of sseClients)
    try {
      c.end();
    } catch (_) {}
  saveHeatMap();
  watcher.close().then(() => server.close(() => process.exit(0)));
});