const https = require('https');
const http = require('http');
const fs = require('fs');
const path = require('path');
const readline = require('readline');
const { execSync, execFileSync } = require('child_process');

// ========== 配置 ==========
const APP_CONFIG_FILE = path.join(__dirname, 'config.json');
const DEFAULT_APP_CONFIG = {
  api: {
    music: 'https://api.chksz.top/api/163_music',
    lyric: 'https://api.chksz.top/api/163_lyric',
    search: 'https://api.chksz.top/api/163_search',
    playlist: 'https://api.chksz.top/api/163_playlist',
    neteaseBaseUrl: 'https://music.163.com',
  },
  paths: {
    downloadDir: 'downloads',
    historyFile: 'download_history.json',
    runtimeConfigFile: 'downloader_config.json',
    trashDir: '.trash',
    tempZipDir: '.tmp_zip',
  },
  defaults: {
    quality: 'jymaster',
    retries: 3,
    historyLimit: 500,
  },
};

function loadAppConfig() {
  try {
    if (!fs.existsSync(APP_CONFIG_FILE)) return DEFAULT_APP_CONFIG;
    const config = JSON.parse(fs.readFileSync(APP_CONFIG_FILE, 'utf-8'));
    return {
      api: { ...DEFAULT_APP_CONFIG.api, ...(config.api || {}) },
      paths: { ...DEFAULT_APP_CONFIG.paths, ...(config.paths || {}) },
      defaults: { ...DEFAULT_APP_CONFIG.defaults, ...(config.defaults || {}) },
    };
  } catch (e) {
    console.warn(`⚠️  配置文件读取失败，将使用默认配置: ${e.message}`);
    return DEFAULT_APP_CONFIG;
  }
}

function resolveConfigPath(configPath, fallback) {
  const value = typeof configPath === 'string' && configPath.trim() ? configPath.trim() : fallback;
  return path.isAbsolute(value) ? value : path.join(__dirname, value);
}

function getConfigString(value, fallback) {
  return typeof value === 'string' && value.trim() ? value.trim() : fallback;
}

const APP_CONFIG = loadAppConfig();
const API = {
  music: getConfigString(APP_CONFIG.api.music, DEFAULT_APP_CONFIG.api.music),
  lyric: getConfigString(APP_CONFIG.api.lyric, DEFAULT_APP_CONFIG.api.lyric),
  search: getConfigString(APP_CONFIG.api.search, DEFAULT_APP_CONFIG.api.search),
  playlist: getConfigString(APP_CONFIG.api.playlist, DEFAULT_APP_CONFIG.api.playlist),
  neteaseBaseUrl: getConfigString(APP_CONFIG.api.neteaseBaseUrl, DEFAULT_APP_CONFIG.api.neteaseBaseUrl),
};
const NETEASE_BASE_URL = API.neteaseBaseUrl.replace(/\/$/, '');
const DOWNLOAD_DIR = resolveConfigPath(APP_CONFIG.paths.downloadDir, DEFAULT_APP_CONFIG.paths.downloadDir);
const HISTORY_FILE = resolveConfigPath(APP_CONFIG.paths.historyFile, DEFAULT_APP_CONFIG.paths.historyFile);
const CONFIG_FILE = resolveConfigPath(APP_CONFIG.paths.runtimeConfigFile, DEFAULT_APP_CONFIG.paths.runtimeConfigFile);
const TRASH_DIR = resolveConfigPath(APP_CONFIG.paths.trashDir, DEFAULT_APP_CONFIG.paths.trashDir);
const TEMP_ZIP_DIR = resolveConfigPath(APP_CONFIG.paths.tempZipDir, DEFAULT_APP_CONFIG.paths.tempZipDir);
const QUALITY_LEVELS = ['standard', 'exhigh', 'lossless', 'hires', 'jymaster', 'sky', 'jyeffect'];
const QUALITY_LABELS = {
  standard: '标准',
  exhigh:   '极高',
  lossless: '无损',
  hires:    'Hi-Res',
  jymaster: '超清母带',
  sky:      '空间音频',
  jyeffect: '高清臻品',
};
const DEFAULT_LEVEL = QUALITY_LEVELS.includes(APP_CONFIG.defaults.quality)
  ? APP_CONFIG.defaults.quality
  : DEFAULT_APP_CONFIG.defaults.quality;
const DEFAULT_RETRIES = Number.isInteger(APP_CONFIG.defaults.retries) && APP_CONFIG.defaults.retries > 0
  ? APP_CONFIG.defaults.retries
  : DEFAULT_APP_CONFIG.defaults.retries;
const HISTORY_LIMIT = Number.isInteger(APP_CONFIG.defaults.historyLimit) && APP_CONFIG.defaults.historyLimit > 0
  ? APP_CONFIG.defaults.historyLimit
  : DEFAULT_APP_CONFIG.defaults.historyLimit;

if (!fs.existsSync(DOWNLOAD_DIR)) fs.mkdirSync(DOWNLOAD_DIR, { recursive: true });

// ========== 网络工具 ==========

function fetchJSON(url) {
  return new Promise((resolve, reject) => {
    const proto = url.startsWith('https') ? https : http;
    proto.get(url, (res) => {
      let data = '';
      res.on('data', chunk => data += chunk);
      res.on('end', () => {
        try { resolve(JSON.parse(data)); }
        catch { reject(new Error(`JSON 解析失败: ${data.slice(0, 200)}`)); }
      });
    }).on('error', reject);
  });
}

function downloadFile(url, dest, showProgress = true) {
  return new Promise((resolve, reject) => {
    const proto = url.startsWith('https') ? https : http;
    proto.get(url, (res) => {
      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
        return downloadFile(res.headers.location, dest, showProgress).then(resolve).catch(reject);
      }
      if (res.statusCode !== 200) return reject(new Error(`HTTP ${res.statusCode}`));

      const total = parseInt(res.headers['content-length'], 10);
      let downloaded = 0;
      let lastTime = Date.now();
      let lastBytes = 0;
      const file = fs.createWriteStream(dest);

      res.on('data', (chunk) => {
        downloaded += chunk.length;
        if (showProgress) {
          const now = Date.now();
          const elapsed = (now - lastTime) / 1000;

          // 每 300ms 更新一次
          if (elapsed >= 0.3) {
            const speed = (downloaded - lastBytes) / elapsed;
            lastTime = now;
            lastBytes = downloaded;

            const speedStr = speed >= 1048576
              ? `${(speed / 1048576).toFixed(1)} MB/s`
              : `${(speed / 1024).toFixed(0)} KB/s`;

            if (total) {
              const pct = downloaded / total;
              const pctStr = (pct * 100).toFixed(1);
              const barWidth = 30;
              const filled = Math.round(pct * barWidth);
              const bar = '█'.repeat(filled) + '░'.repeat(barWidth - filled);
              const eta = speed > 0 ? Math.ceil((total - downloaded) / speed) : 0;
              const etaStr = eta > 60 ? `${Math.floor(eta / 60)}m${eta % 60}s` : `${eta}s`;
              process.stdout.write(`\r  ⬇️  [${bar}] ${pctStr}%  ${(downloaded / 1048576).toFixed(1)}/${(total / 1048576).toFixed(1)} MB  ${speedStr}  ETA ${etaStr}   `);
            } else {
              process.stdout.write(`\r  ⬇️  ${(downloaded / 1048576).toFixed(1)} MB  ${speedStr}   `);
            }
          }
        }
      });

      res.pipe(file);
      file.on('finish', () => { file.close(); if (showProgress) console.log(); resolve(); });
      file.on('error', (err) => { fs.unlink(dest, () => {}); reject(err); });
    }).on('error', reject);
  });
}

function downloadBuffer(url) {
  return new Promise((resolve, reject) => {
    https.get(url, (res) => {
      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
        return downloadBuffer(res.headers.location).then(resolve).catch(reject);
      }
      const chunks = [];
      res.on('data', chunk => chunks.push(chunk));
      res.on('end', () => resolve(Buffer.concat(chunks)));
    }).on('error', reject);
  });
}

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

function sanitizePathSegment(name, fallback) {
  const value = sanitize(String(name || '')).replace(/[. ]+$/g, '');
  return value && value !== '.' && value !== '..' ? value : fallback;
}

function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }

function getDirSize(dirPath) {
  let size = 0;
  try {
    const items = fs.readdirSync(dirPath);
    for (const item of items) {
      const p = path.join(dirPath, item);
      const stat = fs.statSync(p);
      if (stat.isDirectory()) size += getDirSize(p);
      else size += stat.size;
    }
  } catch {}
  return size;
}

// 全局暂停控制
let isPaused = false;
let pauseResolve = null;

function togglePause() {
  if (isPaused) {
    isPaused = false;
    if (pauseResolve) { pauseResolve(); pauseResolve = null; }
    console.log('\n  ▶️  已恢复下载');
  } else {
    isPaused = true;
    console.log('\n  ⏸  已暂停 (再按 p 恢复)');
  }
}

async function waitIfPaused() {
  if (!isPaused) return;
  await new Promise(resolve => { pauseResolve = resolve; });
}

// ========== 下载历史 ==========

function loadHistory() {
  try {
    if (fs.existsSync(HISTORY_FILE)) {
      return JSON.parse(fs.readFileSync(HISTORY_FILE, 'utf-8'));
    }
  } catch {}
  return [];
}

function saveHistory(history) {
  fs.mkdirSync(path.dirname(HISTORY_FILE), { recursive: true });
  fs.writeFileSync(HISTORY_FILE, JSON.stringify(history, null, 2), 'utf-8');
}

function addHistory(entry) {
  const history = loadHistory();
  history.unshift({
    ...entry,
    timestamp: new Date().toISOString(),
  });
  // 限制历史记录数量
  if (history.length > HISTORY_LIMIT) history.length = HISTORY_LIMIT;
  saveHistory(history);
}

function formatTime(isoStr) {
  const d = new Date(isoStr);
  const pad = (n) => String(n).padStart(2, '0');
  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
}

// ========== 配置管理 ==========

function loadConfig() {
  try {
    if (fs.existsSync(CONFIG_FILE)) {
      return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
    }
  } catch {}
  return {};
}

function saveConfig(config) {
  fs.mkdirSync(path.dirname(CONFIG_FILE), { recursive: true });
  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
}

function getConfig(key, defaultVal) {
  const config = loadConfig();
  return config[key] !== undefined ? config[key] : defaultVal;
}

function setConfig(key, val) {
  const config = loadConfig();
  config[key] = val;
  saveConfig(config);
}

// ========== 封面嵌入 ==========

function hasFFmpeg() {
  try { execSync('ffmpeg -version', { stdio: 'ignore' }); return true; } catch { return false; }
}
function hasNodeID3() {
  try { require.resolve('node-id3'); return true; } catch { return false; }
}

async function embedCover(audioPath, coverUrl, meta) {
  const ext = path.extname(audioPath).toLowerCase();
  const coverPath = audioPath + '.cover.jpg';

  try {
    const coverBuf = await downloadBuffer(coverUrl);
    fs.writeFileSync(coverPath, coverBuf);

    // 优先 node-id3 (仅 MP3)
    if (ext === '.mp3' && hasNodeID3()) {
      const NodeID3 = require('node-id3');
      const tags = {
        title: meta.name,
        artist: meta.artist,
        album: meta.album,
        image: coverPath,
      };
      if (meta.albumArtist) tags.performerInfo = meta.albumArtist;
      if (meta.year)        tags.year = String(meta.year);
      if (meta.date)        tags.date = String(meta.date);
      if (meta.trackNo)     tags.trackNumber = String(meta.trackNo);
      if (meta.disc)        tags.partOfSet = String(meta.disc);
      if (meta.genre)       tags.genre = meta.genre;
      if (meta.composer)    tags.composer = meta.composer;      // TCOM 作曲
      if (meta.lyricist)    tags.textWriter = meta.lyricist;    // TEXT 作词
      if (meta.publisher)   tags.publisher = meta.publisher;    // TPUB 发行公司
      // 编曲/制作人/混音无标准帧，写入自定义 TXXX
      const userTexts = [];
      if (meta.arranger) userTexts.push({ description: 'ARRANGER', value: meta.arranger });
      if (meta.producer) userTexts.push({ description: 'PRODUCER', value: meta.producer });
      if (meta.mixer)    userTexts.push({ description: 'MIXER', value: meta.mixer });
      if (userTexts.length) tags.userDefinedText = userTexts;
      if (meta.lyrics)      tags.unsynchronisedLyrics = { language: 'chi', text: meta.lyrics };
      const ok = NodeID3.write(tags, audioPath);
      if (ok === true) { console.log('  ✅ 封面+标签+歌词已嵌入 (node-id3)'); return; }
    }

    if (hasFFmpeg()) {
      const tmpPath = audioPath + '.tmp' + ext;

      // 用 execFileSync 直接传参数组，避免 shell 转义问题
      const args = ['-y', '-i', audioPath, '-i', coverPath,
        '-map', '0:a', '-map', '1:0', '-c', 'copy',
        // 关键：将第二路输入标记为专辑封面，否则播放器不识别（FLAC/MP3 通用）
        '-disposition:v:0', 'attached_pic',
      ];

      const addMeta = (k, v) => {
        if (v !== undefined && v !== null && v !== '') args.push('-metadata', `${k}=${v}`);
      };
      addMeta('title', meta.name);
      addMeta('artist', meta.artist);
      addMeta('album', meta.album);
      addMeta('album_artist', meta.albumArtist || meta.artist);
      addMeta('date', meta.date || meta.year);   // 优先完整日期，回退到年份
      addMeta('track', meta.trackNo);
      addMeta('disc', meta.disc);
      addMeta('genre', meta.genre);
      addMeta('composer', meta.composer);         // 作曲 (MP3→TCOM / FLAC→COMPOSER)
      addMeta('publisher', meta.publisher);       // 发行公司 (MP3→TPUB / FLAC→ORGANIZATION)
      // 以下键 MP3 会写入 TXXX，FLAC 直接作为 Vorbis 注释
      addMeta('lyricist', meta.lyricist);         // 作词
      addMeta('arranger', meta.arranger);         // 编曲
      addMeta('producer', meta.producer);         // 制作人
      addMeta('mixer', meta.mixer);               // 混音
      // 歌词过长时不写入标签（仍会另存 .lrc），避免命令行超长
      if (meta.lyrics && meta.lyrics.length <= 8000) addMeta('lyrics', meta.lyrics);
      // 封面流描述
      args.push('-metadata:s:v', 'title=Album cover', '-metadata:s:v', 'comment=Cover (front)');

      if (ext === '.mp3') args.push('-id3v2_version', '3');
      args.push(tmpPath);

      execFileSync('ffmpeg', args, { stdio: 'ignore' });
      fs.renameSync(tmpPath, audioPath);
      console.log('  ✅ 封面+标签+歌词已嵌入 (ffmpeg)');
    } else {
      console.log('  ⚠️  跳过封面: 需要 node-id3 (npm i node-id3) 或 ffmpeg');
    }
  } catch (e) {
    console.error(`  ⚠️  封面嵌入失败: ${e.message}`);
  } finally {
    if (fs.existsSync(coverPath)) fs.unlinkSync(coverPath);
  }
}

// ========== 歌词处理 ==========

async function fetchLyric(songId) {
  try {
    const res = await fetchJSON(`${API.lyric}?id=${songId}`);
    if (res.code !== 200) return null;
    return res.data; // { lrc, tlyric, romalrc, klyric }
  } catch {
    return null;
  }
}

function mergeLrc(lrc, tlyric) {
  if (!lrc) return '';
  if (!tlyric) return lrc;

  // 解析翻译歌词为 { timestamp: text } 映射
  const transMap = new Map();
  for (const line of tlyric.split('\n')) {
    const m = line.match(/^\[(\d+:\d+[\.:]\d+)\](.*)/);
    if (m && m[2].trim()) transMap.set(m[1], m[2].trim());
  }

  // 在原文歌词每行后面插入翻译
  const result = [];
  for (const line of lrc.split('\n')) {
    result.push(line);
    const m = line.match(/^\[(\d+:\d+[\.:]\d+)\]/);
    if (m) {
      const ts = m[1];
      if (transMap.has(ts)) {
        result.push(`[${ts}]${transMap.get(ts)}`);
      }
    }
  }
  return result.join('\n');
}

// 从歌词头部解析制作信息（网易云 song/detail 不返回作词/作曲，只能从 LRC 头提取）
// 典型行： "[00:00.000] 作词 : Cassie Wei" 或无时间戳 "作曲 ：xxx/yyy"
function parseCredits(lrcText) {
  const credits = {};
  if (!lrcText) return credits;
  const LABELS = {
    lyricist:  /^(作词|作詞|词|填词|Lyricist|Lyrics? by|Written by)$/i,
    composer:  /^(作曲|曲|Composer|Composed by|Music by)$/i,
    arranger:  /^(编曲|編曲|Arranger|Arranged by)$/i,
    producer:  /^(制作人|製作人|出品人|监制|Producer|Produced by)$/i,
    mixer:     /^(混音|Mix(ing)?|Mixed by)$/i,
  };
  for (const raw of lrcText.split('\n')) {
    // 去掉行首的 [mm:ss.xx] 时间戳（可能有多个）
    const line = raw.replace(/^(\s*\[[^\]]*\]\s*)+/, '').trim();
    const m = line.match(/^([^:：]{1,12})\s*[:：]\s*(.+)$/);
    if (!m) continue;
    const label = m[1].trim();
    const value = m[2].trim().replace(/\s*\/\s*/g, '/'); // 归一化多人分隔符
    if (!value) continue;
    for (const [key, re] of Object.entries(LABELS)) {
      if (re.test(label) && !credits[key]) { credits[key] = value; break; }
    }
  }
  return credits;
}

async function saveLyric(songId, fileName) {
  const data = await fetchLyric(songId);
  if (!data || !data.lrc) {
    console.log('  ⚠️  未获取到歌词');
    return;
  }

  // 保存纯原文 LRC
  const lrcPath = path.join(DOWNLOAD_DIR, fileName + '.lrc');
  fs.writeFileSync(lrcPath, data.lrc, 'utf-8');
  console.log(`  📄 歌词已保存: ${path.basename(lrcPath)}`);

  // 如果有翻译歌词，保存合并版
  if (data.tlyric && data.tlyric.trim()) {
    const merged = mergeLrc(data.lrc, data.tlyric);
    const mergedPath = path.join(DOWNLOAD_DIR, fileName + '.合并翻译.lrc');
    fs.writeFileSync(mergedPath, merged, 'utf-8');
    console.log(`  📄 翻译歌词已保存: ${path.basename(mergedPath)}`);
  }
}

// ========== 网易云详细元数据 ==========

function fetchNeteaseSongDetail(songId) {
  return new Promise((resolve, reject) => {
    const requestUrl = new URL(`/api/v1/song/detail?ids=[${songId}]`, `${NETEASE_BASE_URL}/`);
    const options = {
      method: 'GET',
      headers: {
        'Referer': NETEASE_BASE_URL,
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
        'Accept': 'application/json',
        'Cookie': 'os=pc',
      },
    };
    const proto = requestUrl.protocol === 'https:' ? https : http;
    const req = proto.request(requestUrl, options, (res) => {
      let data = '';
      res.on('data', c => data += c);
      res.on('end', () => {
        try {
          const j = JSON.parse(data);
          const s = j.songs?.[0];
          if (!s) return resolve(null);
          resolve({
            id: s.id,
            name: s.name,
            artists: s.ar?.map(a => ({ id: a.id, name: a.name })) || [],
            album: s.al ? { id: s.al.id, name: s.al.name, cover: s.al.picUrl || s.al.cover } : null,
            duration: s.dt || 0, // ms
            disc: s.cd || '',
            trackNo: s.no || 0,
            aliases: s.alia || [],
            transNames: s.tns || [],
            popularity: s.pop || 0,
            fee: s.fee,
            quality: {
              h: s.h ? { br: s.h.br, size: s.h.size, sr: s.h.sr } : null,
              m: s.m ? { br: s.m.br, size: s.m.size, sr: s.m.sr } : null,
              l: s.l ? { br: s.l.br, size: s.l.size, sr: s.l.sr } : null,
            },
          });
        } catch { resolve(null); }
      });
    });
    req.on('error', () => resolve(null));
    req.setTimeout(5000, () => { req.destroy(); resolve(null); });
    req.end();
  });
}

function fetchNeteaseAlbumDetail(albumId) {
  return new Promise((resolve, reject) => {
    const requestUrl = new URL(`/api/v1/album/${albumId}`, `${NETEASE_BASE_URL}/`);
    const options = {
      method: 'GET',
      headers: {
        'Referer': NETEASE_BASE_URL,
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
        'Accept': 'application/json',
        'Cookie': 'os=pc',
      },
    };
    const proto = requestUrl.protocol === 'https:' ? https : http;
    const req = proto.request(requestUrl, options, (res) => {
      let data = '';
      res.on('data', c => data += c);
      res.on('end', () => {
        try {
          const j = JSON.parse(data);
          const a = j.album || j;
          resolve({
            id: a.id,
            name: a.name,
            publishTime: a.publishTime || null, // ms timestamp
            company: a.company || '',
            description: a.description || '',
            tags: a.tags || [],
            type: a.type || '',
            size: a.size || 0,
            artist: a.artist ? { id: a.artist.id, name: a.artist.name, trans: a.artist.trans } : null,
            picUrl: a.picUrl || '',
            tracks: (j.songs || a.songs || []).map(s => ({
              id: s.id,
              name: s.name,
              ar: s.ar || s.artists || [],
              al: s.al || s.album || null,
              dt: s.dt || s.duration || 0,
              disc: s.cd || '',
              trackNo: s.no || 0,
            })),
          });
        } catch { resolve(null); }
      });
    });
    req.on('error', () => resolve(null));
    req.setTimeout(5000, () => { req.destroy(); resolve(null); });
    req.end();
  });
}

function getAlbumDownloadTarget(album, track, index, trackCount = album.tracks?.length || 0) {
  const trackArtists = track.ar?.map(a => a.name).filter(Boolean).join(' / ');
  const artistDir = sanitizePathSegment(album.artist?.name || trackArtists, '未知歌手');
  const albumDir = sanitizePathSegment(album.name, '未知专辑');
  const numberWidth = Math.max(2, String(trackCount).length);
  const trackNumber = String(index + 1).padStart(numberWidth, '0');
  return {
    outputDir: path.join(DOWNLOAD_DIR, artistDir, albumDir),
    outputBaseName: `${trackNumber}. ${track.name || '未知歌曲'}`,
  };
}

async function fetchFullMetadata(songId) {
  const [songDetail, chkszData] = await Promise.all([
    fetchNeteaseSongDetail(songId),
    fetchJSON(`${API.music}?id=${songId}&level=standard`).catch(() => null),
  ]);

  if (!songDetail) return null;

  let albumDetail = null;
  if (songDetail.album?.id) {
    albumDetail = await fetchNeteaseAlbumDetail(songDetail.album.id);
  }

  const durationSec = Math.round(songDetail.duration / 1000);
  const durationStr = `${Math.floor(durationSec / 60)}:${String(durationSec % 60).padStart(2, '0')}`;
  const publishYear = albumDetail?.publishTime
    ? new Date(albumDetail.publishTime).getFullYear()
    : null;
  const publishDate = albumDetail?.publishTime
    ? new Date(albumDetail.publishTime).toISOString().slice(0, 10)
    : null;

  return {
    // 基本信息
    id: songId,
    name: songDetail.name,
    artists: songDetail.artists,
    artistStr: songDetail.artists.map(a => a.name).join(' / '),
    album: songDetail.album,
    albumStr: songDetail.album?.name || '',

    // 详细信息
    duration: songDetail.duration,
    durationStr,
    disc: songDetail.disc,
    trackNo: songDetail.trackNo,
    aliases: songDetail.aliases,
    transNames: songDetail.transNames,
    popularity: songDetail.popularity,
    fee: songDetail.fee,

    // 专辑详情
    publishTime: albumDetail?.publishTime,
    publishYear,
    publishDate,
    company: albumDetail?.company || '',
    description: albumDetail?.description || '',
    tags: albumDetail?.tags || [],
    albumType: albumDetail?.type || '',
    albumSize: albumDetail?.size || 0,
    albumArtist: albumDetail?.artist,

    // 音质信息
    quality: songDetail.quality,

    // ChKSz 数据
    chksz: chkszData?.code === 200 ? chkszData.data : null,
  };
}

// ========== 音质选择 ==========

// 解析音质输入：支持数字序号(1-7)或音质名称，无效/空返回 null
function parseLevel(input) {
  const v = (input || '').trim().toLowerCase();
  if (!v) return null;
  if (/^\d+$/.test(v)) {
    const idx = parseInt(v, 10) - 1;
    return (idx >= 0 && idx < QUALITY_LEVELS.length) ? QUALITY_LEVELS[idx] : null;
  }
  return QUALITY_LEVELS.includes(v) ? v : null;
}

function printQualityMenu(currentLevel) {
  QUALITY_LEVELS.forEach((lv, i) => {
    const mark = lv === currentLevel ? '  ←当前' : '';
    console.log(`    ${i + 1}. ${lv.padEnd(10)} ${(QUALITY_LABELS[lv] || '').padEnd(8)}${mark}`);
  });
}

async function askLevel(ask, currentLevel) {
  const label = QUALITY_LABELS[currentLevel] ? ` (${QUALITY_LABELS[currentLevel]})` : '';
  console.log(`\n  当前音质: ${currentLevel}${label}`);
  console.log('  可选音质:');
  printQualityMenu(currentLevel);
  const input = await ask('  选择音质 (输入序号或名称, 回车使用当前): ');
  const parsed = parseLevel(input);
  if (parsed) return parsed;
  if (input.trim()) console.log('  ⚠️  无效选择，使用当前设置');
  return currentLevel;
}

// ========== 搜索 ==========

async function searchSongs(keyword, limit = 10) {
  const res = await fetchJSON(`${API.search}?keyword=${encodeURIComponent(keyword)}&limit=${limit}`);
  if (res.code !== 200) {
    console.log('❌ 搜索无结果');
    return [];
  }
  // 兼容两种返回格式：data 直接是数组，或 data.songs 是数组
  const songs = Array.isArray(res.data) ? res.data : (res.data?.songs || []);
  if (!songs.length) {
    console.log('❌ 搜索无结果');
    return [];
  }
  return songs;
}

async function interactiveSearch(rl, ask) {
  const keyword = await ask('🔍 搜索关键词: ');
  if (!keyword.trim()) return null;

  const results = await searchSongs(keyword.trim(), 10);
  if (!results.length) return null;

  console.log('\n  #  歌曲名                  歌手                专辑');
  console.log('  ' + '─'.repeat(70));
  results.forEach((s, i) => {
    const num = String(i + 1).padStart(2);
    const name = s.name.slice(0, 20).padEnd(22);
    const artist = s.artists.slice(0, 16).padEnd(18);
    console.log(`  ${num} ${name} ${artist} ${s.album}`);
  });

  const pick = await ask('\n选择序号 (多个用逗号分隔, 0=取消): ');
  if (!pick.trim() || pick.trim() === '0') return null;

  return pick.split(/[,，\s]+/)
    .map(n => parseInt(n, 10))
    .filter(n => n >= 1 && n <= results.length)
    .map(n => results[n - 1]);
}

// ========== 歌单 ==========

async function fetchPlaylist(playlistId) {
  const res = await fetchJSON(`${API.playlist}?id=${playlistId}`);
  if (!res.data?.tracks?.length) {
    console.log('❌ 歌单获取失败或为空');
    return null;
  }
  return res.data; // { name, trackCount, tracks: [{ id, name, ar, al }] }
}

// ========== 核心: 下载歌曲 ==========

async function downloadSong(songId, level, {
  downloadLyric = true,
  embedCoverArt = true,
  maxRetries = DEFAULT_RETRIES,
  outputDir = DOWNLOAD_DIR,
  outputBaseName = null,
} = {}) {
  let lastError = null;

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await _downloadSong(songId, level, { downloadLyric, embedCoverArt, outputDir, outputBaseName });
    } catch (e) {
      lastError = e;
      if (attempt < maxRetries) {
        const waitSec = attempt * 3;
        console.log(`  ⚠️  第 ${attempt} 次失败: ${e.message}，${waitSec}秒后重试...`);
        await sleep(waitSec * 1000);
      }
    }
  }

  console.error(`❌ 歌曲 ${songId} 下载失败 (已重试 ${maxRetries} 次): ${lastError?.message}`);
  return false;
}

async function _downloadSong(songId, level, {
  downloadLyric = true,
  embedCoverArt = true,
  outputDir = DOWNLOAD_DIR,
  outputBaseName = null,
} = {}) {
  const url = `${API.music}?id=${songId}&level=${level}`;
  console.log(`\n🎵 解析歌曲 ID: ${songId} ...`);

  const result = await fetchJSON(url);
  if (result.code !== 200 || !result.data?.url) {
    throw new Error(result.msg || 'API 返回错误');
  }

  const { name, artist, album, url: audioUrl, br, size, level: actualLevel, picUrl } = result.data;
  const ext = audioUrl.match(/\.(mp3|flac|m4a|wav|aac)(\?|$)/i)?.[1] || 'mp3';
  const baseName = sanitize(outputBaseName || `${artist} - ${name}`);
  const fileName = `${baseName}.${ext}`;
  fs.mkdirSync(outputDir, { recursive: true });
  const dest = path.join(outputDir, fileName);

  console.log(`  🎶 ${name} - ${artist}`);
  console.log(`  💿 ${album} | ${actualLevel} (${br}kbps) | ${(size / 1024 / 1024).toFixed(2)} MB`);

  // 检查是否已存在（精确匹配文件名）
  if (fs.existsSync(dest)) {
    const existStat = fs.statSync(dest);
    // 检查文件大小是否接近（允许 1% 误差）
    const sizeDiff = Math.abs(existStat.size - size) / size;
    if (sizeDiff < 0.01) {
      console.log(`  ⏭️  已存在，跳过: ${fileName}`);
      // 检查是否缺少歌词/封面，自动补全
      const lrcPath = path.join(outputDir, baseName + '.lrc');
      if (downloadLyric && !fs.existsSync(lrcPath)) {
        console.log(`  🔧 检测到缺少歌词，自动补全...`);
        const lyricData = await fetchLyric(songId);
        if (lyricData?.lrc) {
          fs.writeFileSync(lrcPath, lyricData.lrc, 'utf-8');
          console.log(`  📄 歌词已补全`);
          if (lyricData.tlyric && lyricData.tlyric.trim()) {
            const merged = mergeLrc(lyricData.lrc, lyricData.tlyric);
            fs.writeFileSync(path.join(outputDir, baseName + '.合并翻译.lrc'), merged, 'utf-8');
          }
        }
      }
    } else {
      // 文件大小差异大，可能是不同版本，询问是否重新下载
      console.log(`  ⚠️  已存在同名文件但大小不同 (现有 ${(existStat.size / 1048576).toFixed(2)} MB, 预期 ${(size / 1048576).toFixed(2)} MB)`);
      console.log(`  ⬇️  覆盖下载...`);
      await downloadFile(audioUrl, dest);
      console.log(`  ✅ 下载完成: ${fileName}`);
    }
  } else {
    console.log(`  ⬇️  下载中...`);
    await downloadFile(audioUrl, dest);
    console.log(`  ✅ 下载完成: ${fileName}`);
  }

  // 下载歌词
  let lyricData = null;
  if (downloadLyric) {
    lyricData = await fetchLyric(songId);
    if (lyricData?.lrc) {
      const lrcPath = path.join(outputDir, baseName + '.lrc');
      fs.writeFileSync(lrcPath, lyricData.lrc, 'utf-8');
      console.log(`  📄 歌词已保存: ${path.basename(lrcPath)}`);
      if (lyricData.tlyric && lyricData.tlyric.trim()) {
        const merged = mergeLrc(lyricData.lrc, lyricData.tlyric);
        const mergedPath = path.join(outputDir, baseName + '.合并翻译.lrc');
        fs.writeFileSync(mergedPath, merged, 'utf-8');
        console.log(`  📄 翻译歌词已保存: ${path.basename(mergedPath)}`);
      }
    } else {
      console.log('  ⚠️  未获取到歌词');
    }
  }

  // 嵌入封面 + 歌词
  if (embedCoverArt && picUrl) {
    const lrcText = lyricData?.lrc || null;
    const tagMeta = { name, artist, album, lyrics: lrcText };
    // 从歌词头解析作词/作曲/编曲/制作人等（网易云元数据接口不提供这些字段）
    Object.assign(tagMeta, parseCredits(lrcText));
    // 拉取更丰富的元数据（曲目号/碟号/发行年份/发行公司/流派/专辑歌手）用于写入标签
    try {
      const detail = await fetchNeteaseSongDetail(songId);
      if (detail) {
        if (detail.trackNo) tagMeta.trackNo = detail.trackNo;
        if (detail.disc)    tagMeta.disc = detail.disc;
        const albumArtist = detail.artists?.map(a => a.name).join(' / ');
        if (albumArtist) tagMeta.albumArtist = albumArtist;
        if (detail.album?.id) {
          const albumDetail = await fetchNeteaseAlbumDetail(detail.album.id);
          if (albumDetail?.publishTime) {
            const d = new Date(albumDetail.publishTime);
            tagMeta.year = d.getFullYear();
            tagMeta.date = d.toISOString().slice(0, 10); // 完整发行日期 YYYY-MM-DD
          }
          if (albumDetail?.tags?.length) tagMeta.genre = albumDetail.tags.join(', ');
          if (albumDetail?.company)      tagMeta.publisher = albumDetail.company; // 发行公司
          // 曲目号补全为 "当前/总数" 形式
          if (tagMeta.trackNo && albumDetail?.size) tagMeta.trackNo = `${tagMeta.trackNo}/${albumDetail.size}`;
        }
      }
    } catch {}
    await embedCover(dest, picUrl, tagMeta);
  }

  // 记录下载历史
  addHistory({
    id: songId,
    name,
    artist,
    album,
    level: actualLevel,
    bitrate: br,
    size,
    file: path.relative(DOWNLOAD_DIR, dest),
  });

  return true;
}

// ========== 主程序 ==========

function createRL() {
  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
  const ask = (q) => new Promise(r => rl.question(q, r));
  return { rl, ask };
}

function printBanner() {
  console.log('');
  console.log('╔══════════════════════════════════════════╗');
  console.log('║   🎵 网易云音乐下载器 v2.0              ║');
  console.log('║   基于 ChKSz API · 免费 · 高音质        ║');
  console.log('╚══════════════════════════════════════════╝');
  console.log(`  封面嵌入: node-id3(${hasNodeID3() ? '✓' : '✗'}) ffmpeg(${hasFFmpeg() ? '✓' : '✗'})`);
  console.log(`  下载目录: ${DOWNLOAD_DIR}`);
  console.log('');
}

function printMenu() {
  console.log('┌────────────────────────────┐');
  console.log('│  1. 搜索歌曲并下载         │');
  console.log('│  2. 输入歌曲 ID 下载       │');
  console.log('│  3. 输入歌单 ID 下载全部   │');
  console.log('│  4. 查看歌单歌曲列表       │');
  console.log('│  5. 查看歌曲歌词           │');
  console.log('│  6. 按歌手批量下载         │');
  console.log('│  7. 试听歌曲               │');
  console.log('│  8. 查看歌曲详情           │');
  console.log('│  9. 下载历史               │');
  console.log('│  0. 设置音质等级           │');
  console.log('│  s. 按歌名搜索             │');
  console.log('│  a. 下载完整专辑           │');
  console.log('│  b. 批量ID下载             │');
  console.log('│  f. 从文件批量下载         │');
  console.log('│  n. 从文件名识别并补全标签 │');
  console.log('│  e. 导出下载历史           │');
  console.log('│  m. 保存歌单为 M3U         │');
  console.log('│  g. 自动识别并补全标签     │');
  console.log('│  z. 歌单下载并打包 ZIP     │');
  console.log('│  c. 清理缓存和临时文件     │');
  console.log('│  t. 下载统计               │');
  console.log('│  l. 已下载歌曲列表         │');
  console.log('│  p. 暂停/恢复下载          │');
  console.log('│  r. 重置所有设置           │');
  console.log('│  h. 帮助                   │');
  console.log('│  q. 退出                   │');
  console.log('└────────────────────────────┘');
}

async function main() {
  const args = process.argv.slice(2);

  // 解析命令行参数
  let level = getConfig('level', DEFAULT_LEVEL);
  const ids = [];
  let playlistId = null;
  let albumId = null;
  let batchLyric = true;
  let batchCover = true;

  let maxRetries = DEFAULT_RETRIES;
  for (const arg of args) {
    if (arg.startsWith('--level='))     level = parseLevel(arg.split('=')[1]) || level;
    else if (arg.startsWith('--playlist=')) playlistId = arg.split('=')[1];
    else if (arg.startsWith('--album=')) albumId = arg.split('=')[1];
    else if (arg.startsWith('--retries='))  maxRetries = parseInt(arg.split('=')[1], 10) || DEFAULT_RETRIES;
    else if (arg === '--no-lyric')      batchLyric = false;
    else if (arg === '--no-cover')      batchCover = false;
    else if (/^\d+$/.test(arg))         ids.push(arg);
  }

  // 命令行批量模式
  if (ids.length || playlistId || albumId) {
    printBanner();
    console.log('📋 命令行模式\n');

    if (albumId) {
      const album = await fetchNeteaseAlbumDetail(albumId);
      if (!album?.tracks?.length) {
        console.log('❌ 专辑获取失败或没有歌曲');
      } else {
        console.log(`💿 专辑: ${album.name} - ${album.artist?.name || '未知歌手'} (${album.tracks.length} 首)\n`);
        for (let i = 0; i < album.tracks.length; i++) {
          const track = album.tracks[i];
          const target = getAlbumDownloadTarget(album, track, i);
          await waitIfPaused();
          const artists = track.ar?.map(a => a.name).join('/') || album.artist?.name || '未知';
          console.log(`[${i + 1}/${album.tracks.length}] ${track.name} - ${artists}`);
          try {
            await downloadSong(track.id, level, {
              downloadLyric: batchLyric,
              embedCoverArt: batchCover,
              maxRetries,
              ...target,
            });
          }
          catch (e) { console.error(`  ❌ 出错: ${e.message}`); }
          if (i < album.tracks.length - 1) await sleep(500);
        }
      }
    }

    if (playlistId) {
      const pl = await fetchPlaylist(playlistId);
      if (pl) {
        console.log(`📜 歌单: ${pl.name} (${pl.trackCount} 首)\n`);
        for (let i = 0; i < pl.tracks.length; i++) {
          const t = pl.tracks[i];
          await waitIfPaused();
          console.log(`[${i + 1}/${pl.tracks.length}] ${t.name} - ${t.ar?.map(a => a.name).join('/')}`);
          try { await downloadSong(t.id, level, { downloadLyric: batchLyric, embedCoverArt: batchCover, maxRetries }); }
          catch (e) { console.error(`  ❌ 出错: ${e.message}`); }
          if (i < pl.tracks.length - 1) await sleep(500);
        }
      }
    }

    for (const id of ids) {
      await waitIfPaused();
      try { await downloadSong(id, level, { downloadLyric: batchLyric, embedCoverArt: batchCover, maxRetries }); }
      catch (e) { console.error(`❌ ID ${id} 出错: ${e.message}`); }
    }
    return;
  }

  // 交互模式
  printBanner();
  const { rl, ask } = createRL();

  // 设置快捷键监听
  if (process.stdin.isTTY) {
    readline.emitKeypressEvents(process.stdin);
    process.stdin.setRawMode(true);
    process.stdin.on('keypress', (str, key) => {
      if (key && key.name === 'p' && !key.ctrl && !key.meta) {
        togglePause();
      }
      if (key && key.ctrl && key.name === 'c') {
        process.exit(0);
      }
    });
  }
  // 启用 keypress 事件用于暂停快捷键
  readline.emitKeypressEvents(process.stdin);
  if (process.stdin.isTTY) process.stdin.setRawMode(true);
  process.stdin.on('keypress', (str, key) => {
    if (key && key.name === 'p' && !isPaused) {
      // 只在非输入状态下触发暂停
    }
    if (key && key.ctrl && key.name === 'c') {
      process.exit(0);
    }
  });

  while (true) {
    printMenu();
    const choice = await ask('\n请选择功能: ');

    switch (choice.trim()) {
      case '1': {
        // 搜索并下载
        const songs = await interactiveSearch(rl, ask);
        if (songs?.length) {
          level = await askLevel(ask, level);
          for (const s of songs) {
            await waitIfPaused();
            try { await downloadSong(s.id, level); }
            catch (e) { console.error(`❌ ${s.name} 出错: ${e.message}`); }
            await sleep(500);
          }
        }
        break;
      }

      case '2': {
        // 按 ID 下载
        const input = await ask('请输入歌曲ID (多个用逗号分隔): ');
        const songIds = input.split(/[,，\s]+/).filter(s => /^\d+$/.test(s.trim()));
        if (songIds.length) {
          level = await askLevel(ask, level);
          for (const id of songIds) {
            await waitIfPaused();
            try { await downloadSong(id, level); }
            catch (e) { console.error(`❌ ID ${id} 出错: ${e.message}`); }
            await sleep(500);
          }
        }
        break;
      }

      case '3': {
        // 歌单下载
        const plInput = await ask('请输入歌单ID: ');
        const plId = plInput.trim();
        if (!/^\d+$/.test(plId)) { console.log('⚠️  无效歌单ID'); break; }

        const pl = await fetchPlaylist(plId);
        if (!pl) break;

        console.log(`\n📜 歌单: ${pl.name} (${pl.trackCount} 首)`);
        level = await askLevel(ask, level);
        const confirm = await ask(`确认下载全部 ${pl.trackCount} 首? (y/n): `);
        if (confirm.trim().toLowerCase() !== 'y') break;

        for (let i = 0; i < pl.tracks.length; i++) {
          const t = pl.tracks[i];
          await waitIfPaused();
          console.log(`\n[${i + 1}/${pl.tracks.length}] ${t.name} - ${t.ar?.map(a => a.name).join('/')}`);
          try { await downloadSong(t.id, level); }
          catch (e) { console.error(`  ❌ 出错: ${e.message}`); }
          if (i < pl.tracks.length - 1) await sleep(500);
        }
        break;
      }

      case '4': {
        // 查看歌单歌曲列表
        const plInput = await ask('请输入歌单ID: ');
        const plId = plInput.trim();
        if (!/^\d+$/.test(plId)) { console.log('⚠️  无效歌单ID'); break; }

        const pl = await fetchPlaylist(plId);
        if (!pl) break;

        console.log(`\n📜 ${pl.name} (${pl.trackCount} 首)`);
        console.log(`  创建者: ${pl.creator?.nickname || '未知'}`);
        if (pl.description) console.log(`  描述: ${pl.description.slice(0, 100)}`);
        console.log('  ' + '─'.repeat(60));
        console.log('  #    歌曲名                  歌手                专辑');
        console.log('  ' + '─'.repeat(60));
        pl.tracks.forEach((t, i) => {
          const num = String(i + 1).padStart(3);
          const name = (t.name || '').slice(0, 22).padEnd(24);
          const artist = (t.ar?.map(a => a.name).join('/') || '').slice(0, 18).padEnd(20);
          const album = (t.al?.name || '').slice(0, 18);
          console.log(`  ${num}  ${name} ${artist} ${album}`);
        });
        console.log('  ' + '─'.repeat(60));
        console.log(`  共 ${pl.trackCount} 首`);

        console.log('\n  下载选项:');
        console.log('    a = 下载全部');
        console.log('    输入序号 = 下载指定歌曲 (如: 1,3,5 或 5-10)');
        console.log('    回车 = 跳过');
        const doDownload = await ask('  请选择: ');
        const dlInput = doDownload.trim().toLowerCase();

        let tracksToDownload = [];
        if (dlInput === 'a') {
          tracksToDownload = pl.tracks;
        } else if (dlInput) {
          // 解析序号: 支持 1,3,5 和 5-10 混合
          const indices = new Set();
          for (const part of dlInput.split(/[,，\s]+/)) {
            const rangeMatch = part.match(/^(\d+)-(\d+)$/);
            if (rangeMatch) {
              const start = parseInt(rangeMatch[1], 10);
              const end = parseInt(rangeMatch[2], 10);
              for (let n = start; n <= end; n++) indices.add(n);
            } else if (/^\d+$/.test(part)) {
              indices.add(parseInt(part, 10));
            }
          }
          tracksToDownload = [...indices]
            .filter(n => n >= 1 && n <= pl.tracks.length)
            .sort((a, b) => a - b)
            .map(n => pl.tracks[n - 1]);
        }

        if (tracksToDownload.length) {
          level = await askLevel(ask, level);
          console.log(`\n📥 开始下载 ${tracksToDownload.length} 首歌曲...`);
          for (let i = 0; i < tracksToDownload.length; i++) {
            const t = tracksToDownload[i];
            console.log(`\n[${i + 1}/${tracksToDownload.length}] ${t.name} - ${t.ar?.map(a => a.name).join('/')}`);
            try { await downloadSong(t.id, level); }
            catch (e) { console.error(`  ❌ 出错: ${e.message}`); }
            if (i < tracksToDownload.length - 1) await sleep(500);
          }
        }
        break;
      }

      case '5': {
        // 查看歌曲歌词
        const idInput = await ask('请输入歌曲ID: ');
        const songId = idInput.trim();
        if (!/^\d+$/.test(songId)) { console.log('⚠️  无效歌曲ID'); break; }

        console.log(`\n🔍 获取歌词 (ID: ${songId}) ...`);
        const data = await fetchLyric(songId);
        if (!data?.lrc) {
          console.log('❌ 未获取到歌词');
          break;
        }

        // 解析歌词用于显示
        const parseLrc = (lrcStr) => {
          return lrcStr.split('\n')
            .map(line => {
              const m = line.match(/^\[(\d+):(\d+)[.:](\d+)\](.*)/);
              if (!m) return null;
              const time = `${m[1]}:${m[2]}`;
              const text = m[4].trim();
              if (!text) return null;
              return { time, text };
            })
            .filter(Boolean);
        };

        const lrcLines = parseLrc(data.lrc);
        const transLines = data.tlyric ? parseLrc(data.tlyric) : [];
        const transMap = new Map(transLines.map(l => [l.time, l.text]));

        console.log('\n  📜 歌词:\n');
        for (const line of lrcLines) {
          console.log(`  [${line.time}] ${line.text}`);
          if (transMap.has(line.time)) {
            console.log(`           ↳ ${transMap.get(line.time)}`);
          }
        }

        const saveOpt = await ask('\n是否保存为 .lrc 文件? (y/n): ');
        if (saveOpt.trim().toLowerCase() === 'y') {
          const defaultName = `song_${songId}`;
          const nameInput = await ask(`文件名 (默认 ${defaultName}): `);
          const baseName = sanitize(nameInput.trim() || defaultName);
          const lrcPath = path.join(DOWNLOAD_DIR, baseName + '.lrc');
          fs.writeFileSync(lrcPath, data.lrc, 'utf-8');
          console.log(`  ✅ 歌词已保存: ${lrcPath}`);

          if (data.tlyric && data.tlyric.trim()) {
            const merged = mergeLrc(data.lrc, data.tlyric);
            const mergedPath = path.join(DOWNLOAD_DIR, baseName + '.合并翻译.lrc');
            fs.writeFileSync(mergedPath, merged, 'utf-8');
            console.log(`  ✅ 翻译歌词已保存: ${mergedPath}`);
          }
        }
        break;
      }

      case '6': {
        // 按歌手批量下载
        const artistInput = await ask('请输入歌手名: ');
        const artistName = artistInput.trim();
        if (!artistName) { console.log('⚠️  请输入歌手名'); break; }

        const limitInput = await ask('搜索数量 (默认 50): ');
        const searchLimit = parseInt(limitInput, 10) || 50;

        console.log(`\n🔍 搜索 "${artistName}" 的歌曲 (最多 ${searchLimit} 首) ...`);
        const results = await searchSongs(artistName, searchLimit);
        if (!results.length) break;

        // 过滤出歌手名匹配的歌曲
        const artistLower = artistName.toLowerCase();
        const matched = results.filter(s => s.artists.toLowerCase().includes(artistLower));
        const pool = matched.length >= 3 ? matched : results; // 匹配太少就用全部

        if (matched.length >= 3 && matched.length < results.length) {
          console.log(`  找到 ${results.length} 首结果，其中 ${matched.length} 首匹配歌手 "${artistName}"`);
        }

        console.log(`\n  #  歌曲名                  歌手                专辑`);
        console.log('  ' + '─'.repeat(70));
        pool.slice(0, 30).forEach((s, i) => {
          const num = String(i + 1).padStart(2);
          const name = s.name.slice(0, 20).padEnd(22);
          const artist = s.artists.slice(0, 16).padEnd(18);
          console.log(`  ${num} ${name} ${artist} ${s.album}`);
        });
        if (pool.length > 30) console.log(`  ... 共 ${pool.length} 首，仅显示前 30 首`);

        console.log('\n  下载选项:');
        console.log('    a = 下载全部');
        console.log('    输入序号 = 下载指定歌曲 (如: 1,3,5 或 1-10)');
        console.log('    回车 = 跳过');
        const pick = await ask('  请选择: ');
        const pickInput = pick.trim().toLowerCase();

        let toDownload = [];
        if (pickInput === 'a') {
          toDownload = pool;
        } else if (pickInput) {
          const indices = new Set();
          for (const part of pickInput.split(/[,，\s]+/)) {
            const rangeMatch = part.match(/^(\d+)-(\d+)$/);
            if (rangeMatch) {
              const start = parseInt(rangeMatch[1], 10);
              const end = parseInt(rangeMatch[2], 10);
              for (let n = start; n <= end; n++) indices.add(n);
            } else if (/^\d+$/.test(part)) {
              indices.add(parseInt(part, 10));
            }
          }
          toDownload = [...indices]
            .filter(n => n >= 1 && n <= pool.length)
            .sort((a, b) => a - b)
            .map(n => pool[n - 1]);
        }

        if (toDownload.length) {
          level = await askLevel(ask, level);
          console.log(`\n📥 开始下载 ${toDownload.length} 首歌曲...`);
          for (let i = 0; i < toDownload.length; i++) {
            const s = toDownload[i];
            console.log(`\n[${i + 1}/${toDownload.length}] ${s.name} - ${s.artists}`);
            try { await downloadSong(s.id, level); }
            catch (e) { console.error(`  ❌ 出错: ${e.message}`); }
            if (i < toDownload.length - 1) await sleep(500);
          }
        }
        break;
      }

      case '7': {
        // 试听歌曲
        const idInput = await ask('请输入歌曲ID: ');
        const songId = idInput.trim();
        if (!/^\d+$/.test(songId)) { console.log('⚠️  无效歌曲ID'); break; }

        console.log(`\n🔍 获取试听链接 (ID: ${songId}) ...`);
        try {
          const result = await fetchJSON(`${API.music}?id=${songId}&level=standard`);
          if (result.code !== 200 || !result.data?.url) {
            console.log(`❌ 获取失败: ${result.msg || '未知错误'}`);
            break;
          }
          const { name, artist, album, url: audioUrl } = result.data;
          console.log(`  🎶 ${name} - ${artist} (${album})`);

          // 检测可用播放器
          const players = [
            { cmd: 'mpv', args: (u) => ['--no-video', u] },
            { cmd: 'ffplay', args: (u) => ['-nodisp', '-autoexit', u] },
            { cmd: 'play', args: (u) => [u] }, // sox
            { cmd: 'cvlc', args: (u) => ['--play-and-exit', u] },
            { cmd: 'aplay', args: (u) => [u] },
          ];

          let player = null;
          for (const p of players) {
            try {
              execSync(`which ${p.cmd}`, { stdio: 'ignore' });
              player = p;
              break;
            } catch {}
          }

          if (!player) {
            console.log('  ⚠️  未检测到音频播放器 (mpv/ffplay/play/cvlc/aplay)');
            console.log(`  📋 试听链接: ${audioUrl}`);
            console.log('  请手动在浏览器或播放器中打开');
            break;
          }

          console.log(`  ▶️  使用 ${player.cmd} 播放中... (Ctrl+C 停止)`);
          try {
            execSync(`${player.cmd} ${player.args(audioUrl).map(a => `"${a}"`).join(' ')}`, {
              stdio: 'inherit',
              timeout: 300000, // 5分钟超时
            });
          } catch (e) {
            if (e.status !== null) {
              // 用户中断或正常结束
            } else {
              console.error(`  ❌ 播放出错: ${e.message}`);
            }
          }
          console.log('  ⏹  播放结束');
        } catch (e) {
          console.error(`  ❌ 出错: ${e.message}`);
        }
        break;
      }

      case '8': {
        // 查看歌曲详情（完整元数据）
        const idInput = await ask('请输入歌曲ID: ');
        const songId = idInput.trim();
        if (!/^\d+$/.test(songId)) { console.log('⚠️  无效歌曲ID'); break; }

        console.log(`\n🔍 获取歌曲详情 (ID: ${songId}) ...`);
        try {
          const meta = await fetchFullMetadata(songId);
          if (!meta) {
            console.log('❌ 获取失败');
            break;
          }

          const pad = 42;
          console.log('');
          console.log('  ╔══════════════════════════════════════════════════╗');
          console.log(`  ║ 🎵 ${meta.name}`);
          if (meta.aliases.length) {
            console.log(`  ║    别名: ${meta.aliases.join(', ')}`);
          }
          if (meta.transNames.length) {
            console.log(`  ║    译名: ${meta.transNames.join(', ')}`);
          }
          console.log('  ╠══════════════════════════════════════════════════╣');
          console.log(`  ║ 歌手:     ${meta.artistStr}`);
          console.log(`  ║ 专辑:     ${meta.albumStr}`);
          console.log(`  ║ ID:       ${meta.id}`);
          if (meta.trackNo) console.log(`  ║ 曲目号:   ${meta.trackNo}${meta.disc ? ` (碟片 ${meta.disc})` : ''}`);
          console.log('  ╠══════════════════════════════════════════════════╣');
          console.log(`  ║ 时长:     ${meta.durationStr}`);
          if (meta.publishDate) {
            console.log(`  ║ 发行日期: ${meta.publishDate}`);
          } else if (meta.publishYear) {
            console.log(`  ║ 发行年份: ${meta.publishYear}`);
          }
          if (meta.company) console.log(`  ║ 唱片公司: ${meta.company}`);
          if (meta.albumType) console.log(`  ║ 专辑类型: ${meta.albumType}`);
          if (meta.albumSize) console.log(`  ║ 专辑曲目: ${meta.albumSize} 首`);
          if (meta.tags.length) console.log(`  ║ 标签:     ${meta.tags.join(', ')}`);
          console.log(`  ║ 热度:     ${'★'.repeat(Math.round(meta.popularity / 20))}${'☆'.repeat(5 - Math.round(meta.popularity / 20))} (${meta.popularity}/100)`);
          console.log('  ╠══════════════════════════════════════════════════╣');

          // 音质信息
          if (meta.quality) {
            console.log('  ║ 音质信息:');
            const q = meta.quality;
            if (q.l) console.log(`  ║   标准   ${q.l.br}kbps  ${(q.l.size / 1048576).toFixed(1)} MB  ${q.l.sr}Hz`);
            if (q.m) console.log(`  ║   较高   ${q.m.br}kbps  ${(q.m.size / 1048576).toFixed(1)} MB  ${q.m.sr}Hz`);
            if (q.h) console.log(`  ║   极高   ${q.h.br}kbps  ${(q.h.size / 1048576).toFixed(1)} MB  ${q.h.sr}Hz`);
          }

          // ChKSz 最高音质
          if (meta.chksz) {
            console.log('  ╠══════════════════════════════════════════════════╣');
            console.log(`  ║ ChKSz 最高可用: ${meta.chksz.level} (${meta.chksz.br}kbps) ${(meta.chksz.size / 1048576).toFixed(1)} MB`);
          }

          // 专辑描述
          if (meta.description) {
            console.log('  ╠══════════════════════════════════════════════════╣');
            console.log('  ║ 专辑简介:');
            const descLines = meta.description.split(/\n/).slice(0, 3);
            for (const line of descLines) {
              const trimmed = line.trim();
              if (trimmed) {
                // 自动换行
                for (let i = 0; i < trimmed.length; i += 44) {
                  console.log(`  ║   ${trimmed.slice(i, i + 44)}`);
                }
              }
            }
            if (meta.description.split(/\n/).length > 3) {
              console.log('  ║   ...');
            }
          }

          console.log('  ╚══════════════════════════════════════════════════╝');
        } catch (e) {
          console.error(`  ❌ 出错: ${e.message}`);
        }
        break;
      }

      case '9': {
        // 下载历史
        const history = loadHistory();
        if (!history.length) {
          console.log('\n  📭 暂无下载历史');
          break;
        }

        const showCount = Math.min(history.length, 30);
        console.log(`\n  📜 下载历史 (最近 ${showCount} 条，共 ${history.length} 条)`);
        console.log('  ' + '─'.repeat(70));
        console.log('  #    时间              歌曲名                  歌手              音质');
        console.log('  ' + '─'.repeat(70));
        history.slice(0, showCount).forEach((h, i) => {
          const num = String(i + 1).padStart(3);
          const time = formatTime(h.timestamp);
          const name = (h.name || '').slice(0, 20).padEnd(22);
          const artist = (h.artist || '').slice(0, 14).padEnd(16);
          const lv = h.level || '?';
          console.log(`  ${num}  ${time}  ${name} ${artist} ${lv}`);
        });
        console.log('  ' + '─'.repeat(70));

        if (history.length > showCount) {
          console.log(`  ... 还有 ${history.length - showCount} 条更早的记录`);
        }

        const action = await ask('\n  操作: [d=删除指定] [c=清空全部] [回车=返回]: ');
        if (action.trim().toLowerCase() === 'c') {
          const confirm = await ask('  ⚠️  确认清空全部下载历史? (输入 yes 确认): ');
          if (confirm.trim() === 'yes') {
            saveHistory([]);
            console.log('  ✅ 下载历史已全部清空');
          } else {
            console.log('  取消操作');
          }
        } else if (action.trim().toLowerCase() === 'd') {
          const delInput = await ask('  输入要删除的序号 (如: 1,3,5): ');
          const delIndices = delInput.split(/[,，\s]+/)
            .map(n => parseInt(n, 10))
            .filter(n => n >= 1 && n <= showCount)
            .sort((a, b) => b - a); // 从后往前删
          for (const idx of delIndices) {
            history.splice(idx - 1, 1);
          }
          saveHistory(history);
          console.log(`  ✅ 已删除 ${delIndices.length} 条记录`);
        }
        break;
      }

      case '0': {
        // 设置音质
        const label = QUALITY_LABELS[level] ? ` (${QUALITY_LABELS[level]})` : '';
        console.log(`\n当前音质: ${level}${label}`);
        console.log('可选音质:');
        printQualityMenu(level);
        const newLevel = await ask('选择音质等级 (输入序号或名称): ');
        const parsed = parseLevel(newLevel);
        if (parsed) {
          level = parsed;
          setConfig('level', level);
          console.log(`✅ 音质已设为: ${level}${QUALITY_LABELS[level] ? ` (${QUALITY_LABELS[level]})` : ''} (已保存)`);
        } else {
          console.log('⚠️  无效等级');
        }
        break;
      }

      case 's':
      case 'S': {
        // 按歌名搜索
        const songName = await ask('请输入歌名: ');
        if (!songName.trim()) { console.log('⚠️  请输入歌名'); break; }

        const limitInput = await ask('搜索数量 (默认 20): ');
        const searchLimit = parseInt(limitInput, 10) || 20;

        console.log(`\n🔍 搜索 "${songName.trim()}" ...`);
        const results = await searchSongs(songName.trim(), searchLimit);
        if (!results.length) break;

        console.log(`\n  #  歌曲名                  歌手                专辑`);
        console.log('  ' + '─'.repeat(70));
        results.forEach((s, i) => {
          const num = String(i + 1).padStart(2);
          const name = s.name.slice(0, 20).padEnd(22);
          const artist = s.artists.slice(0, 16).padEnd(18);
          const album = s.album.slice(0, 20);
          console.log(`  ${num} ${name} ${artist} ${album}`);
        });
        console.log('  ' + '─'.repeat(70));
        console.log(`  共 ${results.length} 首结果`);

        console.log('\n  操作选项:');
        console.log('    输入序号 = 下载指定歌曲 (如: 1,3,5 或 1-5)');
        console.log('    a = 下载全部');
        console.log('    v+序号 = 试听 (如: v3)');
        console.log('    d+序号 = 查看详情 (如: d3)');
        console.log('    回车 = 返回');
        const action = await ask('  请选择: ');
        const actionInput = action.trim().toLowerCase();

        if (!actionInput) break;

        // 试听
        const listenMatch = actionInput.match(/^v(\d+)$/);
        if (listenMatch) {
          const idx = parseInt(listenMatch[1], 10);
          if (idx >= 1 && idx <= results.length) {
            const s = results[idx - 1];
            console.log(`\n  ▶️  试听: ${s.name} - ${s.artists}`);
            try {
              const r = await fetchJSON(`${API.music}?id=${s.id}&level=standard`);
              if (r.code === 200 && r.data?.url) {
                const players = [
                  { cmd: 'mpv', args: (u) => ['--no-video', u] },
                  { cmd: 'ffplay', args: (u) => ['-nodisp', '-autoexit', u] },
                  { cmd: 'play', args: (u) => [u] },
                  { cmd: 'cvlc', args: (u) => ['--play-and-exit', u] },
                ];
                let player = null;
                for (const p of players) {
                  try { execSync(`which ${p.cmd}`, { stdio: 'ignore' }); player = p; break; } catch {}
                }
                if (player) {
                  console.log(`  ▶️  使用 ${player.cmd} 播放中... (Ctrl+C 停止)`);
                  try { execSync(`${player.cmd} ${player.args(r.data.url).map(a => `"${a}"`).join(' ')}`, { stdio: 'inherit', timeout: 300000 }); } catch {}
                  console.log('  ⏹  播放结束');
                } else {
                  console.log(`  📋 链接: ${r.data.url}`);
                }
              }
            } catch (e) { console.error(`  ❌ ${e.message}`); }
          } else {
            console.log('  ⚠️  无效序号');
          }
          break;
        }

        // 详情
        const detailMatch = actionInput.match(/^d(\d+)$/);
        if (detailMatch) {
          const idx = parseInt(detailMatch[1], 10);
          if (idx >= 1 && idx <= results.length) {
            const s = results[idx - 1];
            try {
              const r = await fetchJSON(`${API.music}?id=${s.id}&level=jymaster`);
              if (r.code === 200 && r.data) {
                const d = r.data;
                console.log('\n  ┌─────────────────────────────────────────┐');
                console.log(`  │ 🎵 ${d.name}`);
                console.log('  ├─────────────────────────────────────────┤');
                console.log(`  │ 歌手: ${d.artist}`);
                console.log(`  │ 专辑: ${d.album}`);
                console.log(`  │ ID:   ${d.id}`);
                console.log(`  │ 音质: ${d.level} (${d.br}kbps)  大小: ${(d.size / 1048576).toFixed(2)} MB`);
                console.log('  └─────────────────────────────────────────┘');
              }
            } catch (e) { console.error(`  ❌ ${e.message}`); }
          } else {
            console.log('  ⚠️  无效序号');
          }
          break;
        }

        // 下载
        let toDownload = [];
        if (actionInput === 'a') {
          toDownload = results;
        } else {
          const indices = new Set();
          for (const part of actionInput.split(/[,，\s]+/)) {
            const rangeMatch = part.match(/^(\d+)-(\d+)$/);
            if (rangeMatch) {
              const start = parseInt(rangeMatch[1], 10);
              const end = parseInt(rangeMatch[2], 10);
              for (let n = start; n <= end; n++) indices.add(n);
            } else if (/^\d+$/.test(part)) {
              indices.add(parseInt(part, 10));
            }
          }
          toDownload = [...indices]
            .filter(n => n >= 1 && n <= results.length)
            .sort((a, b) => a - b)
            .map(n => results[n - 1]);
        }

        if (toDownload.length) {
          level = await askLevel(ask, level);
          console.log(`\n📥 开始下载 ${toDownload.length} 首歌曲...`);
          for (let i = 0; i < toDownload.length; i++) {
            const s = toDownload[i];
            console.log(`\n[${i + 1}/${toDownload.length}] ${s.name} - ${s.artists}`);
            try { await downloadSong(s.id, level); }
            catch (e) { console.error(`  ❌ 出错: ${e.message}`); }
            if (i < toDownload.length - 1) await sleep(500);
          }
        }
        break;
      }

      case 'l':
      case 'L': {
        // 已下载歌曲列表
        if (!fs.existsSync(DOWNLOAD_DIR)) {
          console.log('\n  📭 下载目录不存在');
          break;
        }

        const allFiles = fs.readdirSync(DOWNLOAD_DIR);
        const audioExts = ['.mp3', '.flac', '.m4a', '.wav', '.aac', '.ogg', '.wma'];
        const audioFiles = allFiles.filter(f => audioExts.includes(path.extname(f).toLowerCase()));

        if (!audioFiles.length) {
          console.log('\n  📭 暂无已下载的歌曲');
          break;
        }

        // 按修改时间排序（最新在前）
        const filesWithTime = audioFiles.map(f => {
          const fp = path.join(DOWNLOAD_DIR, f);
          const stat = fs.statSync(fp);
          return { name: f, size: stat.size, mtime: stat.mtime };
        }).sort((a, b) => b.mtime - a.mtime);

        console.log(`\n  📁 已下载歌曲 (${filesWithTime.length} 首)`);
        console.log(`  目录: ${DOWNLOAD_DIR}`);
        console.log('  ' + '─'.repeat(75));
        console.log('  #    文件名                                  大小        修改时间');
        console.log('  ' + '─'.repeat(75));

        const showCount = Math.min(filesWithTime.length, 50);
        filesWithTime.slice(0, showCount).forEach((f, i) => {
          const num = String(i + 1).padStart(3);
          const name = f.name.length > 38 ? f.name.slice(0, 35) + '...' : f.name;
          const sizeMB = (f.size / 1048576).toFixed(1);
          const time = `${f.mtime.getMonth() + 1}/${f.mtime.getDate()} ${String(f.mtime.getHours()).padStart(2, '0')}:${String(f.mtime.getMinutes()).padStart(2, '0')}`;
          console.log(`  ${num}  ${name.padEnd(40)} ${(sizeMB + ' MB').padStart(10)}  ${time}`);
        });

        if (filesWithTime.length > showCount) {
          console.log(`  ... 还有 ${filesWithTime.length - showCount} 首未显示`);
        }

        const totalSize = filesWithTime.reduce((s, f) => s + f.size, 0);
        console.log('  ' + '─'.repeat(75));
        console.log(`  共 ${filesWithTime.length} 首，总大小 ${(totalSize / 1073741824).toFixed(2)} GB`);

        const action = await ask('\n  操作: [p+序号=播放] [d+序号=删除] [da=删除全部] [回车=返回]: ');
        const actLower = action.trim().toLowerCase();

        // 播放
        const playMatch = actLower.match(/^p(\d+)$/);
        if (playMatch) {
          const idx = parseInt(playMatch[1], 10);
          if (idx >= 1 && idx <= filesWithTime.length) {
            const filePath = path.join(DOWNLOAD_DIR, filesWithTime[idx - 1].name);
            const players = [
              { cmd: 'mpv', args: (u) => ['--no-video', u] },
              { cmd: 'ffplay', args: (u) => ['-nodisp', '-autoexit', u] },
              { cmd: 'play', args: (u) => [u] },
              { cmd: 'cvlc', args: (u) => ['--play-and-exit', u] },
            ];
            let player = null;
            for (const p of players) {
              try { execSync(`which ${p.cmd}`, { stdio: 'ignore' }); player = p; break; } catch {}
            }
            if (player) {
              console.log(`  ▶️  播放: ${filesWithTime[idx - 1].name}`);
              try { execSync(`${player.cmd} ${player.args(filePath).map(a => `"${a}"`).join(' ')}`, { stdio: 'inherit', timeout: 300000 }); } catch {}
              console.log('  ⏹  播放结束');
            } else {
              console.log('  ⚠️  未检测到音频播放器');
            }
          } else {
            console.log('  ⚠️  无效序号');
          }
        }

        // 删除指定
        const delMatch = actLower.match(/^d(\d+)$/);
        if (delMatch) {
          const idx = parseInt(delMatch[1], 10);
          if (idx >= 1 && idx <= filesWithTime.length) {
            const target = filesWithTime[idx - 1];
            const confirm = await ask(`  确认删除 "${target.name}"? (y/n): `);
            if (confirm.trim().toLowerCase() === 'y') {
              const filePath = path.join(DOWNLOAD_DIR, target.name);
              // 移到回收站目录
              if (!fs.existsSync(TRASH_DIR)) fs.mkdirSync(TRASH_DIR, { recursive: true });
              const trashPath = path.join(TRASH_DIR, `${Date.now()}_${target.name}`);
              try {
                fs.renameSync(filePath, trashPath);
                console.log(`  ✅ 已移到回收站: ${target.name}`);
                // 同时移动关联的 .lrc 文件
                const baseName = path.parse(target.name).name;
                for (const f of allFiles) {
                  if (f.startsWith(baseName) && f.endsWith('.lrc')) {
                    const lrcSrc = path.join(DOWNLOAD_DIR, f);
                    const lrcDst = path.join(TRASH_DIR, `${Date.now()}_${f}`);
                    try { fs.renameSync(lrcSrc, lrcDst); } catch {}
                  }
                }
              } catch (e) {
                console.error(`  ❌ 删除失败: ${e.message}`);
              }
            }
          } else {
            console.log('  ⚠️  无效序号');
          }
        }

        // 删除全部
        if (actLower === 'da') {
          const confirm = await ask(`  ⚠️  确认删除全部 ${filesWithTime.length} 首歌曲? 此操作不可恢复! (输入 yes 确认): `);
          if (confirm.trim() === 'yes') {
            if (!fs.existsSync(TRASH_DIR)) fs.mkdirSync(TRASH_DIR, { recursive: true });
            let deleted = 0;
            for (const f of filesWithTime) {
              try {
                const src = path.join(DOWNLOAD_DIR, f.name);
                const dst = path.join(TRASH_DIR, `${Date.now()}_${f.name}`);
                fs.renameSync(src, dst);
                deleted++;
              } catch {}
            }
            // 清理关联文件
            for (const f of allFiles) {
              if (!audioExts.includes(path.extname(f).toLowerCase())) {
                try {
                  const src = path.join(DOWNLOAD_DIR, f);
                  const dst = path.join(TRASH_DIR, `${Date.now()}_${f}`);
                  fs.renameSync(src, dst);
                } catch {}
              }
            }
            console.log(`  ✅ 已删除 ${deleted} 首歌曲 (已移到 .trash 目录)`);
          } else {
            console.log('  取消删除');
          }
        }
        break;
      }

      case 'a':
      case 'A': {
        // 按专辑下载
        const albumInput = await ask('请输入专辑 ID（推荐）或专辑名: ');
        const albumQuery = albumInput.trim();
        if (!albumQuery) { console.log('⚠️  请输入专辑 ID 或名称'); break; }

        if (/^\d+$/.test(albumQuery)) {
          console.log(`\n🔍 获取专辑 ${albumQuery} ...`);
          const album = await fetchNeteaseAlbumDetail(albumQuery);
          if (!album?.tracks?.length) {
            console.log('❌ 专辑获取失败或没有歌曲');
            break;
          }

          console.log(`\n💿 ${album.name} - ${album.artist?.name || '未知歌手'}`);
          console.log(`  共 ${album.tracks.length} 首歌曲`);
          album.tracks.forEach((track, i) => {
            const artists = track.ar?.map(a => a.name).join('/') || album.artist?.name || '未知';
            console.log(`  ${String(i + 1).padStart(2)}. ${track.name} - ${artists}`);
          });

          level = await askLevel(ask, level);
          const confirm = await ask(`确认下载整张专辑? (y/n): `);
          if (confirm.trim().toLowerCase() !== 'y') break;

          for (let i = 0; i < album.tracks.length; i++) {
            const track = album.tracks[i];
            const artists = track.ar?.map(a => a.name).join('/') || album.artist?.name || '未知';
            const target = getAlbumDownloadTarget(album, track, i);
            await waitIfPaused();
            console.log(`\n[${i + 1}/${album.tracks.length}] ${track.name} - ${artists}`);
            try { await downloadSong(track.id, level, target); }
            catch (e) { console.error(`  ❌ 出错: ${e.message}`); }
            if (i < album.tracks.length - 1) await sleep(500);
          }
          break;
        }

        const albumName = albumQuery;

        const limitInput = await ask('搜索数量 (默认 50): ');
        const searchLimit = parseInt(limitInput, 10) || 50;

        console.log(`\n🔍 搜索专辑 "${albumName}" ...`);
        const results = await searchSongs(albumName, searchLimit);
        if (!results.length) break;

        // 按专辑名过滤
        const albumLower = albumName.toLowerCase();
        const matched = results.filter(s => (s.album || '').toLowerCase().includes(albumLower));
        const pool = matched.length >= 2 ? matched : results;

        if (matched.length >= 2 && matched.length < results.length) {
          console.log(`  找到 ${results.length} 首结果，其中 ${matched.length} 首匹配专辑 "${albumName}"`);
        }

        // 按专辑分组
        const albumGroups = {};
        for (const s of pool) {
          const key = s.album || '未知专辑';
          if (!albumGroups[key]) albumGroups[key] = [];
          albumGroups[key].push(s);
        }

        console.log('\n  匹配的专辑:');
        const albumKeys = Object.keys(albumGroups);
        albumKeys.forEach((a, i) => {
          const num = String(i + 1).padStart(2);
          const songs = albumGroups[a];
          const artist = songs[0]?.artists || '未知';
          console.log(`  ${num} ${a.slice(0, 30).padEnd(32)} ${artist} (${songs.length}首)`);
        });

        const albumPick = await ask('\n选择专辑序号 (多个用逗号分隔, a=全部, 0=取消): ');
        const albumPickInput = albumPick.trim().toLowerCase();
        if (!albumPickInput || albumPickInput === '0') break;

        let albumsToDownload = [];
        if (albumPickInput === 'a') {
          albumsToDownload = albumKeys;
        } else {
          const indices = albumPickInput.split(/[,，\s]+/)
            .map(n => parseInt(n, 10))
            .filter(n => n >= 1 && n <= albumKeys.length);
          albumsToDownload = [...new Set(indices)].sort((a, b) => a - b).map(n => albumKeys[n - 1]);
        }

        if (!albumsToDownload.length) break;

        const allSongs = [];
        for (const aName of albumsToDownload) {
          const albumSongs = albumGroups[aName];
          for (let trackIndex = 0; trackIndex < albumSongs.length; trackIndex++) {
            const song = albumSongs[trackIndex];
            if (!allSongs.find(x => x.song.id === song.id)) {
              allSongs.push({
                song,
                albumName: aName,
                trackIndex,
                trackCount: albumSongs.length,
              });
            }
          }
        }

        console.log(`\n💿 共 ${albumsToDownload.length} 张专辑，${allSongs.length} 首歌曲`);
        level = await askLevel(ask, level);
        const confirm = await ask(`确认下载? (y/n): `);
        if (confirm.trim().toLowerCase() !== 'y') break;

        for (let i = 0; i < allSongs.length; i++) {
          const item = allSongs[i];
          const s = item.song;
          const target = getAlbumDownloadTarget({
            name: item.albumName,
            artist: { name: s.artists || '未知歌手' },
          }, s, item.trackIndex, item.trackCount);
          await waitIfPaused();
          console.log(`\n[${i + 1}/${allSongs.length}] ${s.name} - ${s.artists}`);
          try { await downloadSong(s.id, level, target); }
          catch (e) { console.error(`  ❌ 出错: ${e.message}`); }
          if (i < allSongs.length - 1) await sleep(500);
        }
        break;
      }

      case 'b':
      case 'B': {
        // 批量ID下载
        console.log('\n  📋 批量输入歌曲ID');
        console.log('  支持格式:');
        console.log('    - 逗号分隔: 123,456,789');
        console.log('    - 空格分隔: 123 456 789');
        console.log('    - 每行一个 (输入空行结束)');

        const idLines = [];
        console.log('');
        while (true) {
          const line = await ask('  输入ID (空行结束): ');
          if (!line.trim()) break;
          idLines.push(line.trim());
        }

        if (!idLines.length) { console.log('  ⚠️  未输入任何ID'); break; }

        // 解析所有ID
        const allIds = [];
        for (const line of idLines) {
          const parts = line.split(/[,，\s]+/).filter(s => /^\d+$/.test(s));
          allIds.push(...parts);
        }

        const uniqueIds = [...new Set(allIds)];
        if (!uniqueIds.length) { console.log('  ⚠️  未找到有效ID'); break; }

        console.log(`\n  📊 解析结果: ${uniqueIds.length} 个有效ID`);
        level = await askLevel(ask, level);
        const confirm = await ask(`确认下载 ${uniqueIds.length} 首歌曲? (y/n): `);
        if (confirm.trim().toLowerCase() !== 'y') break;

        let success = 0;
        let fail = 0;
        const failedIds = [];

        for (let i = 0; i < uniqueIds.length; i++) {
          const id = uniqueIds[i];
          console.log(`\n  [${i + 1}/${uniqueIds.length}] ID: ${id}`);
          try {
            const ok = await downloadSong(id, level);
            if (ok) success++;
            else { fail++; failedIds.push(id); }
          } catch (e) {
            console.error(`  ❌ 出错: ${e.message}`);
            fail++;
            failedIds.push(id);
          }
          if (i < uniqueIds.length - 1) await sleep(500);
        }

        console.log(`\n  📊 下载完成:`);
        console.log(`    ✅ 成功: ${success} 首`);
        console.log(`    ❌ 失败: ${fail} 首`);
        if (failedIds.length) {
          console.log(`    失败ID: ${failedIds.join(', ')}`);
          const retry = await ask('\n  是否重试失败的歌曲? (y/n): ');
          if (retry.trim().toLowerCase() === 'y') {
            console.log('\n  🔄 重试中...');
            let retrySuccess = 0;
            for (let i = 0; i < failedIds.length; i++) {
              const id = failedIds[i];
              console.log(`  [${i + 1}/${failedIds.length}] ID: ${id}`);
              try {
                const ok = await downloadSong(id, level);
                if (ok) retrySuccess++;
              } catch {}
              if (i < failedIds.length - 1) await sleep(1000);
            }
            console.log(`  ✅ 重试完成: 成功 ${retrySuccess} 首`);
          }
        }
        break;
      }

      case 'f':
      case 'F': {
        // 从文件批量下载
        const filePath = await ask('请输入文件路径 (每行一个歌曲ID或"歌手 - 歌名"): ');
        const fPath = filePath.trim();
        if (!fPath) { console.log('⚠️  请输入文件路径'); break; }
        if (!fs.existsSync(fPath)) { console.log('❌ 文件不存在'); break; }

        const lines = fs.readFileSync(fPath, 'utf-8')
          .split('\n')
          .map(l => l.trim())
          .filter(l => l && !l.startsWith('#'));

        if (!lines.length) { console.log('⚠️  文件为空'); break; }

        // 区分 ID 和 "歌手 - 歌名"
        const idList = [];
        const nameList = [];
        for (const line of lines) {
          if (/^\d+$/.test(line)) {
            idList.push(line);
          } else if (line.includes('-')) {
            nameList.push(line);
          }
        }

        console.log(`\n📋 解析结果: ${idList.length} 个ID, ${nameList.length} 个歌名`);

        // 歌名搜索匹配
        const resolvedIds = [];
        if (nameList.length) {
          console.log('\n🔍 搜索歌名匹配...');
          for (const nameLine of nameList) {
            const parts = nameLine.split(/\s*[-—]\s*/);
            const keyword = parts.length >= 2 ? `${parts[0]} ${parts[1]}` : nameLine;
            try {
              const res = await fetchJSON(`${API.search}?keyword=${encodeURIComponent(keyword)}&limit=3`);
              if (res.code === 200 && res.data?.length) {
                const best = res.data[0];
                resolvedIds.push(best.id);
                console.log(`  ✅ "${nameLine}" → ${best.name} - ${best.artists} (ID: ${best.id})`);
              } else {
                console.log(`  ⚠️  "${nameLine}" 未找到匹配`);
              }
            } catch (e) {
              console.log(`  ❌ "${nameLine}" 搜索失败: ${e.message}`);
            }
            await sleep(300);
          }
        }

        const allIds = [...idList, ...resolvedIds];
        if (!allIds.length) { console.log('❌ 无有效歌曲ID'); break; }

        console.log(`\n📥 共 ${allIds.length} 首歌曲待下载`);
        level = await askLevel(ask, level);
        const confirm = await ask('确认下载? (y/n): ');
        if (confirm.trim().toLowerCase() !== 'y') break;

        let success = 0;
        let fail = 0;
        for (let i = 0; i < allIds.length; i++) {
          const id = allIds[i];
          console.log(`\n[${i + 1}/${allIds.length}] ID: ${id}`);
          try {
            const ok = await downloadSong(id, level);
            if (ok) success++; else fail++;
          } catch (e) {
            console.error(`  ❌ 出错: ${e.message}`);
            fail++;
          }
          if (i < allIds.length - 1) await sleep(500);
        }

        console.log(`\n📊 下载完成: 成功 ${success} 首, 失败 ${fail} 首`);
        break;
      }

      case 'n':
      case 'N': {
        // 从文件名识别并补全标签
        if (!fs.existsSync(DOWNLOAD_DIR)) {
          console.log('\n  📭 下载目录不存在');
          break;
        }

        const allFiles = fs.readdirSync(DOWNLOAD_DIR);
        const audioExts = ['.mp3', '.flac', '.m4a', '.wav', '.aac'];
        const audioFiles = allFiles.filter(f => audioExts.includes(path.extname(f).toLowerCase()));

        if (!audioFiles.length) {
          console.log('\n  📭 暂无音频文件');
          break;
        }

        console.log(`\n  📁 扫描到 ${audioFiles.length} 个音频文件，分析文件名...\n`);

        const candidates = [];
        for (const f of audioFiles) {
          const baseName = path.parse(f).name;
          // 常见格式: "歌手 - 歌名" 或 "歌手-歌名"
          const match = baseName.match(/^(.+?)\s*[-—]\s*(.+)$/);
          if (match) {
            candidates.push({ file: f, artist: match[1].trim(), name: match[2].trim() });
          }
        }

        if (!candidates.length) {
          console.log('  ⚠️  未识别到 "歌手 - 歌名" 格式的文件');
          console.log('  支持的格式: "周杰伦 - 晴天.mp3" 或 "周杰伦-晴天.flac"');
          break;
        }

        console.log(`  识别到 ${candidates.length} 首歌曲:`);
        console.log('  ' + '─'.repeat(60));
        console.log('  #    歌手                  歌曲名                文件');
        console.log('  ' + '─'.repeat(60));
        candidates.forEach((c, i) => {
          const num = String(i + 1).padStart(3);
          const artist = c.artist.slice(0, 18).padEnd(20);
          const name = c.name.slice(0, 18).padEnd(20);
          const file = c.file.length > 30 ? c.file.slice(0, 27) + '...' : c.file;
          console.log(`  ${num}  ${artist} ${name} ${file}`);
        });
        console.log('  ' + '─'.repeat(60));

        console.log('\n  操作选项:');
        console.log('    a = 全部自动匹配并补全标签');
        console.log('    输入序号 = 选择指定文件 (如: 1,3,5)');
        console.log('    回车 = 跳过');
        const pick = await ask('  请选择: ');
        const pickInput = pick.trim().toLowerCase();

        let targets = [];
        if (pickInput === 'a') {
          targets = candidates;
        } else if (pickInput) {
          const indices = new Set();
          for (const part of pickInput.split(/[,，\s]+/)) {
            if (/^\d+$/.test(part)) indices.add(parseInt(part, 10));
          }
          targets = [...indices]
            .filter(n => n >= 1 && n <= candidates.length)
            .sort((a, b) => a - b)
            .map(n => candidates[n - 1]);
        }

        if (!targets.length) break;

        console.log(`\n🏷️  开始匹配 ${targets.length} 首歌曲...\n`);
        let successCount = 0;

        for (let i = 0; i < targets.length; i++) {
          const c = targets[i];
          console.log(`[${i + 1}/${targets.length}] ${c.artist} - ${c.name}`);

          try {
            // 搜索匹配
            const keyword = `${c.artist} ${c.name}`;
            const results = await fetchJSON(`${API.search}?keyword=${encodeURIComponent(keyword)}&limit=5`);
            if (results.code !== 200 || !results.data?.length) {
              console.log('  ⚠️  未找到匹配');
              continue;
            }

            // 找最佳匹配
            const best = results.data.find(s => {
              const sName = (s.name || '').toLowerCase();
              const sArtist = (s.artists || '').toLowerCase();
              return sName.includes(c.name.toLowerCase()) && sArtist.includes(c.artist.toLowerCase());
            }) || results.data[0];

            console.log(`  ✅ 匹配: ${best.name} - ${best.artists} (ID: ${best.id})`);

            // 获取完整歌曲信息并嵌入标签
            const filePath = path.join(DOWNLOAD_DIR, c.file);
            const songInfo = await fetchJSON(`${API.music}?id=${best.id}&level=standard`);
            if (songInfo.code === 200 && songInfo.data) {
              const d = songInfo.data;
              if (d.picUrl) {
                await embedCover(filePath, d.picUrl, { name: d.name, artist: d.artist, album: d.album });
              }

              // 获取并保存歌词
              const lyricData = await fetchLyric(best.id);
              if (lyricData?.lrc) {
                const baseName = path.parse(c.file).name;
                const lrcPath = path.join(DOWNLOAD_DIR, baseName + '.lrc');
                fs.writeFileSync(lrcPath, lyricData.lrc, 'utf-8');
                console.log(`  📄 歌词已保存`);
              }

              // 重命名文件
              const ext = path.extname(c.file);
              const newName = sanitize(`${d.artist} - ${d.name}${ext}`);
              if (newName !== c.file) {
                const newPath = path.join(DOWNLOAD_DIR, newName);
                if (!fs.existsSync(newPath)) {
                  fs.renameSync(filePath, newPath);
                  console.log(`  📝 重命名: ${newName}`);
                }
              }

              // 记录历史
              addHistory({ id: best.id, name: d.name, artist: d.artist, album: d.album, level: 'standard', bitrate: d.br, size: d.size, file: newName });
              successCount++;
            }
          } catch (e) {
            console.error(`  ❌ 出错: ${e.message}`);
          }

          if (i < targets.length - 1) await sleep(500);
        }

        console.log(`\n✅ 完成! 成功补全 ${successCount}/${targets.length} 首`);
        break;
      }

      case 'e':
      case 'E': {
        // 导出下载历史
        const history = loadHistory();
        if (!history.length) {
          console.log('\n  📭 暂无下载历史可导出');
          break;
        }

        console.log('\n  导出格式:');
        console.log('    1. CSV (Excel 兼容)');
        console.log('    2. JSON');
        console.log('    3. TXT (纯文本列表)');
        const fmt = await ask('  选择格式 (1/2/3): ');

        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
        let exportPath;

        switch (fmt.trim()) {
          case '1': {
            // CSV
            exportPath = path.join(__dirname, `download_history_${timestamp}.csv`);
            const header = '歌曲ID,歌曲名,歌手,专辑,音质,码率(kbps),文件大小(bytes),文件名,下载时间\n';
            const rows = history.map(h => {
              return [
                h.id,
                `"${(h.name || '').replace(/"/g, '""')}"`,
                `"${(h.artist || '').replace(/"/g, '""')}"`,
                `"${(h.album || '').replace(/"/g, '""')}"`,
                h.level || '',
                h.bitrate || '',
                h.size || '',
                `"${(h.file || '').replace(/"/g, '""')}"`,
                h.timestamp || '',
              ].join(',');
            }).join('\n');
            fs.writeFileSync(exportPath, header + rows + '\n', 'utf-8');
            break;
          }

          case '2': {
            // JSON
            exportPath = path.join(__dirname, `download_history_${timestamp}.json`);
            fs.writeFileSync(exportPath, JSON.stringify(history, null, 2), 'utf-8');
            break;
          }

          case '3': {
            // TXT
            exportPath = path.join(__dirname, `download_history_${timestamp}.txt`);
            const lines = history.map((h, i) => {
              const time = h.timestamp ? formatTime(h.timestamp) : '未知';
              return `${i + 1}. ${h.artist || '未知'} - ${h.name || '未知'} (${h.album || '未知专辑'}) [${h.level || '?'}] ${time}`;
            });
            fs.writeFileSync(exportPath, lines.join('\n') + '\n', 'utf-8');
            break;
          }

          default:
            console.log('  ⚠️  无效选项');
            break;
        }

        if (exportPath && fs.existsSync(exportPath)) {
          const stat = fs.statSync(exportPath);
          console.log(`\n  ✅ 导出成功!`);
          console.log(`  📄 文件: ${exportPath}`);
          console.log(`  📊 共 ${history.length} 条记录, ${(stat.size / 1024).toFixed(1)} KB`);
        }
        break;
      }

      case 'm':
      case 'M': {
        // 保存歌单为 M3U
        const plInput = await ask('请输入歌单ID: ');
        const plId = plInput.trim();
        if (!/^\d+$/.test(plId)) { console.log('⚠️  无效歌单ID'); break; }

        console.log(`\n🔍 获取歌单信息 ...`);
        const pl = await fetchPlaylist(plId);
        if (!pl) break;

        console.log(`📜 歌单: ${pl.name} (${pl.trackCount} 首)`);

        // 生成 M3U 内容
        const m3uLines = ['#EXTM3U', ''];
        for (const t of pl.tracks) {
          const artist = t.ar?.map(a => a.name).join('/') || '未知';
          const title = t.name || '未知';
          const duration = Math.round((t.dt || 0) / 1000) || -1;
          m3uLines.push(`#EXTINF:${duration},${artist} - ${title}`);
          // 检查本地是否已下载
          const localFile = path.join(DOWNLOAD_DIR, sanitize(`${artist} - ${title}`));
          const possibleExts = ['.mp3', '.flac', '.m4a', '.wav', '.aac'];
          let found = false;
          for (const ext of possibleExts) {
            const fp = localFile + ext;
            if (fs.existsSync(fp)) {
              m3uLines.push(fp);
              found = true;
              break;
            }
          }
          if (!found) {
            // 用 API 链接作为备选
            m3uLines.push(`#EXTVLCOPT:network-caching=1000`);
            m3uLines.push(`${API.music}?id=${t.id}&type=down`);
          }
          m3uLines.push('');
        }

        const m3uContent = m3uLines.join('\n');
        const defaultName = sanitize(pl.name || `playlist_${plId}`);
        const nameInput = await ask(`保存文件名 (默认 ${defaultName}): `);
        const fileName = sanitize(nameInput.trim() || defaultName) + '.m3u';
        const savePath = path.join(__dirname, fileName);

        fs.writeFileSync(savePath, m3uContent, 'utf-8');
        console.log(`\n  ✅ M3U 播放列表已保存!`);
        console.log(`  📄 文件: ${savePath}`);
        console.log(`  📊 共 ${pl.trackCount} 首歌曲`);

        // 统计本地已有数量
        const localCount = m3uLines.filter(l => l.startsWith(DOWNLOAD_DIR)).length;
        if (localCount > 0) {
          console.log(`  💾 本地已有: ${localCount} 首可直接播放`);
        }
        break;
      }

      case 'g':
      case 'G': {
        // 自动识别并补全标签
        if (!fs.existsSync(DOWNLOAD_DIR)) {
          console.log('\n  📭 下载目录不存在');
          break;
        }

        const allFiles = fs.readdirSync(DOWNLOAD_DIR);
        const audioExts = ['.mp3', '.flac', '.m4a', '.wav', '.aac'];
        const audioFiles = allFiles.filter(f => audioExts.includes(path.extname(f).toLowerCase()));

        if (!audioFiles.length) {
          console.log('\n  📭 暂无音频文件');
          break;
        }

        // 筛选需要补全的文件（没有封面或没有歌词）
        console.log(`\n  🔍 扫描 ${audioFiles.length} 个音频文件，检查标签完整性...\n`);

        const needTag = [];
        for (const f of audioFiles) {
          const filePath = path.join(DOWNLOAD_DIR, f);
          const baseName = path.parse(f).name;
          const hasLrc = allFiles.some(lf => lf.startsWith(baseName) && lf.endsWith('.lrc'));

          // 简单判断：文件名包含 " - " 且没有对应 .lrc 文件
          const isNameFormat = /^.+\s*[-—]\s*.+$/.test(baseName);
          if (isNameFormat && !hasLrc) {
            needTag.push(f);
          }
        }

        if (!needTag.length) {
          console.log('  ✅ 所有文件标签已完整，无需补全');
          break;
        }

        console.log(`  发现 ${needTag.length} 个文件需要补全标签:`);
        needTag.forEach((f, i) => {
          console.log(`    ${i + 1}. ${f}`);
        });

        const confirm = await ask(`\n  自动补全这 ${needTag.length} 个文件? (y/n): `);
        if (confirm.trim().toLowerCase() !== 'y') break;

        let success = 0;
        let fail = 0;

        for (let i = 0; i < needTag.length; i++) {
          const f = needTag[i];
          const baseName = path.parse(f).name;
          console.log(`\n  [${i + 1}/${needTag.length}] ${f}`);

          // 解析文件名
          const match = baseName.match(/^(.+?)\s*[-—]\s*(.+)$/);
          if (!match) {
            console.log('    ⚠️  无法解析文件名，跳过');
            fail++;
            continue;
          }

          const artist = match[1].trim();
          const name = match[2].trim();

          try {
            // 搜索匹配
            const keyword = `${artist} ${name}`;
            const results = await fetchJSON(`${API.search}?keyword=${encodeURIComponent(keyword)}&limit=5`);
            if (results.code !== 200 || !results.data?.length) {
              console.log('    ⚠️  搜索无结果，跳过');
              fail++;
              continue;
            }

            // 找最佳匹配
            const best = results.data.find(s => {
              const sName = (s.name || '').toLowerCase();
              const sArtist = (s.artists || '').toLowerCase();
              return sName.includes(name.toLowerCase()) && sArtist.includes(artist.toLowerCase());
            }) || results.data[0];

            console.log(`    ✅ 匹配: ${best.name} - ${best.artists}`);

            // 获取完整信息
            const songInfo = await fetchJSON(`${API.music}?id=${best.id}&level=standard`);
            if (songInfo.code === 200 && songInfo.data) {
              const d = songInfo.data;
              const filePath = path.join(DOWNLOAD_DIR, f);

              // 嵌入封面和标签
              if (d.picUrl) {
                await embedCover(filePath, d.picUrl, { name: d.name, artist: d.artist, album: d.album });
              }

              // 获取并保存歌词
              const lyricData = await fetchLyric(best.id);
              if (lyricData?.lrc) {
                const lrcPath = path.join(DOWNLOAD_DIR, baseName + '.lrc');
                fs.writeFileSync(lrcPath, lyricData.lrc, 'utf-8');
                console.log('    📄 歌词已保存');
              }

              // 记录历史
              addHistory({ id: best.id, name: d.name, artist: d.artist, album: d.album, level: 'standard', bitrate: d.br, size: d.size, file: f });
              success++;
            }
          } catch (e) {
            console.error(`    ❌ 出错: ${e.message}`);
            fail++;
          }

          if (i < needTag.length - 1) await sleep(500);
        }

        console.log(`\n  📊 自动补全完成: 成功 ${success} 首, 失败 ${fail} 首`);
        break;
      }

      case 'z':
      case 'Z': {
        // 歌单下载并打包 ZIP
        const plInput = await ask('请输入歌单ID: ');
        const plId = plInput.trim();
        if (!/^\d+$/.test(plId)) { console.log('⚠️  无效歌单ID'); break; }

        const pl = await fetchPlaylist(plId);
        if (!pl) break;

        console.log(`\n📜 歌单: ${pl.name} (${pl.trackCount} 首)`);
        level = await askLevel(ask, level);
        const confirm = await ask(`确认下载并打包 ${pl.trackCount} 首歌曲? (y/n): `);
        if (confirm.trim().toLowerCase() !== 'y') break;

        // 创建临时目录
        const zipName = sanitize(pl.name || `playlist_${plId}`);
        const tempDir = path.join(TEMP_ZIP_DIR, zipName);
        if (fs.existsSync(tempDir)) fs.rmSync(tempDir, { recursive: true });
        fs.mkdirSync(tempDir, { recursive: true });

        console.log(`\n📥 开始下载到临时目录...\n`);
        let downloaded = 0;
        let failed = 0;

        for (let i = 0; i < pl.tracks.length; i++) {
          const t = pl.tracks[i];
          const artist = t.ar?.map(a => a.name).join('/') || '未知';
          const title = t.name || '未知';
          console.log(`[${i + 1}/${pl.tracks.length}] ${title} - ${artist}`);

          try {
            const result = await fetchJSON(`${API.music}?id=${t.id}&level=${level}`);
            if (result.code !== 200 || !result.data?.url) {
              console.log('  ❌ 解析失败');
              failed++;
              continue;
            }

            const { url: audioUrl, name: sName, artist: sArtist } = result.data;
            const ext = audioUrl.match(/\.([a-z0-9]+)(\?|$)/i)?.[1] || 'mp3';
            const fileName = sanitize(`${sArtist} - ${sName}.${ext}`);
            const dest = path.join(tempDir, fileName);

            console.log(`  ⬇️  下载中...`);
            await downloadFile(audioUrl, dest, false);
            console.log(`  ✅ ${fileName}`);
            downloaded++;
          } catch (e) {
            console.error(`  ❌ 出错: ${e.message}`);
            failed++;
          }

          if (i < pl.tracks.length - 1) await sleep(300);
        }

        if (downloaded === 0) {
          console.log('\n❌ 没有歌曲下载成功，取消打包');
          fs.rmSync(tempDir, { recursive: true });
          break;
        }

        // 打包 ZIP
        const zipPath = path.join(__dirname, `${zipName}.zip`);
        console.log(`\n📦 正在打包 ${downloaded} 首歌曲...`);

        try {
          // 尝试使用系统 zip 命令
          execSync(`cd "${path.dirname(tempDir)}" && zip -r "${zipPath}" "${zipName}"`, { stdio: 'ignore' });
          console.log(`\n  ✅ ZIP 打包完成!`);
          console.log(`  📦 文件: ${zipPath}`);
          const zipStat = fs.statSync(zipPath);
          console.log(`  📊 大小: ${(zipStat.size / 1048576).toFixed(2)} MB`);
          console.log(`  📋 包含: ${downloaded} 首歌曲 (失败 ${failed} 首)`);
        } catch (e) {
          // zip 不可用，尝试 tar.gz
          console.log('  ⚠️  zip 命令不可用，尝试 tar.gz...');
          const tarPath = path.join(__dirname, `${zipName}.tar.gz`);
          try {
            execSync(`tar -czf "${tarPath}" -C "${path.dirname(tempDir)}" "${zipName}"`, { stdio: 'ignore' });
            console.log(`\n  ✅ tar.gz 打包完成!`);
            console.log(`  📦 文件: ${tarPath}`);
            const tarStat = fs.statSync(tarPath);
            console.log(`  📊 大小: ${(tarStat.size / 1048576).toFixed(2)} MB`);
          } catch (e2) {
            console.error(`  ❌ 打包失败: ${e2.message}`);
            console.log(`  📁 歌曲已下载到: ${tempDir}`);
            console.log('  请手动打包');
          }
        }

        // 清理临时目录
        try { fs.rmSync(tempDir, { recursive: true }); } catch {}
        break;
      }

      case 'c':
      case 'C': {
        // 清理缓存和临时文件
        console.log('\n  🧹 清理缓存和临时文件');

        let cleanedSize = 0;
        let cleanedCount = 0;

        // 清理临时 zip 目录
        if (fs.existsSync(TEMP_ZIP_DIR)) {
          const tmpSize = getDirSize(TEMP_ZIP_DIR);
          fs.rmSync(TEMP_ZIP_DIR, { recursive: true });
          cleanedSize += tmpSize;
          cleanedCount++;
          console.log(`  ✅ 已清理临时打包目录 (${(tmpSize / 1024).toFixed(1)} KB)`);
        }

        // 清理回收站
        if (fs.existsSync(TRASH_DIR)) {
          const trashFiles = fs.readdirSync(TRASH_DIR);
          if (trashFiles.length) {
            console.log(`\n  📁 回收站中有 ${trashFiles.length} 个文件`);
            const trashConfirm = await ask('  是否清空回收站? (y/n): ');
            if (trashConfirm.trim().toLowerCase() === 'y') {
              const trashSize = getDirSize(TRASH_DIR);
              fs.rmSync(TRASH_DIR, { recursive: true });
              cleanedSize += trashSize;
              cleanedCount++;
              console.log(`  ✅ 回收站已清空 (${(trashSize / 1048576).toFixed(2)} MB)`);
            } else {
              console.log('  ⏭️  跳过回收站');
            }
          } else {
            console.log('  📁 回收站为空');
          }
        }

        // 清理孤立的 .cover.jpg 临时文件
        if (fs.existsSync(DOWNLOAD_DIR)) {
          const allFiles = fs.readdirSync(DOWNLOAD_DIR);
          const coverTemps = allFiles.filter(f => f.endsWith('.cover.jpg'));
          if (coverTemps.length) {
            let coverSize = 0;
            for (const f of coverTemps) {
              const fp = path.join(DOWNLOAD_DIR, f);
              coverSize += fs.statSync(fp).size;
              fs.unlinkSync(fp);
            }
            cleanedSize += coverSize;
            cleanedCount++;
            console.log(`  ✅ 已清理 ${coverTemps.length} 个临时封面文件 (${(coverSize / 1024).toFixed(1)} KB)`);
          }
        }

        // 清理 .tmp 文件
        if (fs.existsSync(DOWNLOAD_DIR)) {
          const allFiles = fs.readdirSync(DOWNLOAD_DIR);
          const tmpFiles = allFiles.filter(f => f.includes('.tmp.'));
          if (tmpFiles.length) {
            let tmpSize = 0;
            for (const f of tmpFiles) {
              const fp = path.join(DOWNLOAD_DIR, f);
              tmpSize += fs.statSync(fp).size;
              fs.unlinkSync(fp);
            }
            cleanedSize += tmpSize;
            cleanedCount++;
            console.log(`  ✅ 已清理 ${tmpFiles.length} 个临时文件 (${(tmpSize / 1024).toFixed(1)} KB)`);
          }
        }

        if (cleanedCount === 0) {
          console.log('  ✨ 没有需要清理的文件');
        } else {
          console.log(`\n  📊 共释放 ${(cleanedSize / 1048576).toFixed(2)} MB 空间`);
        }
        break;
      }

      case 'w':
      case 'W': {
        // 重命名歌曲文件
        if (!fs.existsSync(DOWNLOAD_DIR)) {
          console.log('\n  📭 下载目录不存在');
          break;
        }

        const allFiles = fs.readdirSync(DOWNLOAD_DIR);
        const audioExts = ['.mp3', '.flac', '.m4a', '.wav', '.aac'];
        const audioFiles = allFiles.filter(f => audioExts.includes(path.extname(f).toLowerCase()));

        if (!audioFiles.length) {
          console.log('\n  📭 暂无音频文件');
          break;
        }

        console.log(`\n  📁 已下载的音频文件 (${audioFiles.length} 首):`);
        console.log('  ' + '─'.repeat(60));
        audioFiles.forEach((f, i) => {
          console.log(`  ${String(i + 1).padStart(3)}  ${f}`);
        });
        console.log('  ' + '─'.repeat(60));

        const pick = await ask('\n  输入要重命名的序号 (如: 1,3,5): ');
        if (!pick.trim()) break;

        const indices = pick.split(/[,，\s]+/)
          .map(n => parseInt(n, 10))
          .filter(n => n >= 1 && n <= audioFiles.length);

        if (!indices.length) { console.log('  ⚠️  无效序号'); break; }

        for (const idx of indices) {
          const oldName = audioFiles[idx - 1];
          const ext = path.extname(oldName);
          const oldBase = path.parse(oldName).name;

          console.log(`\n  📝 重命名: ${oldName}`);
          console.log('  格式: 歌手 - 歌名');

          // 智能解析现有文件名
          const match = oldBase.match(/^(.+?)\s*[-—]\s*(.+)$/);
          const defaultArtist = match ? match[1].trim() : '';
          const defaultName = match ? match[2].trim() : oldBase;

          const newArtist = await ask(`  歌手 [${defaultArtist || '未知'}]: `);
          const newName = await ask(`  歌名 [${defaultName}]: `);

          const artist = sanitize(newArtist.trim() || defaultArtist || '未知');
          const songName = sanitize(newName.trim() || defaultName);
          const newBase = `${artist} - ${songName}`;

          if (newBase === oldBase) {
            console.log('  ⏭️  名称未变，跳过');
            continue;
          }

          const newFileName = newBase + ext;
          const oldPath = path.join(DOWNLOAD_DIR, oldName);
          const newPath = path.join(DOWNLOAD_DIR, newFileName);

          if (fs.existsSync(newPath)) {
            console.log(`  ⚠️  目标文件已存在: ${newFileName}，跳过`);
            continue;
          }

          try {
            fs.renameSync(oldPath, newPath);
            console.log(`  ✅ 已重命名: ${newFileName}`);

            // 同时重命名关联的 .lrc 文件
            const oldLrc = path.join(DOWNLOAD_DIR, oldBase + '.lrc');
            const newLrc = path.join(DOWNLOAD_DIR, newBase + '.lrc');
            if (fs.existsSync(oldLrc)) {
              fs.renameSync(oldLrc, newLrc);
              console.log(`  ✅ 歌词文件也已重命名`);
            }
            const oldMergedLrc = path.join(DOWNLOAD_DIR, oldBase + '.合并翻译.lrc');
            const newMergedLrc = path.join(DOWNLOAD_DIR, newBase + '.合并翻译.lrc');
            if (fs.existsSync(oldMergedLrc)) {
              fs.renameSync(oldMergedLrc, newMergedLrc);
              console.log(`  ✅ 翻译歌词文件也已重命名`);
            }
          } catch (e) {
            console.error(`  ❌ 重命名失败: ${e.message}`);
          }
        }
        break;
      }

      case 't':
      case 'T': {
        // 下载统计
        const history = loadHistory();
        if (!history.length) {
          console.log('\n  📭 暂无下载记录');
          break;
        }

        const totalSize = history.reduce((sum, h) => sum + (h.size || 0), 0);
        const uniqueArtists = new Set(history.map(h => h.artist).filter(Boolean));
        const uniqueAlbums = new Set(history.map(h => h.album).filter(Boolean));
        const uniqueSongs = new Set(history.map(h => h.id));

        // 音质分布
        const levelCount = {};
        for (const h of history) {
          const lv = h.level || '未知';
          levelCount[lv] = (levelCount[lv] || 0) + 1;
        }

        // 歌手 Top 10
        const artistCount = {};
        for (const h of history) {
          if (h.artist) artistCount[h.artist] = (artistCount[h.artist] || 0) + 1;
        }
        const topArtists = Object.entries(artistCount)
          .sort((a, b) => b[1] - a[1])
          .slice(0, 10);

        // 最近 7 天下载量
        const now = Date.now();
        const dayMs = 86400000;
        const last7days = [];
        for (let i = 6; i >= 0; i--) {
          const dayStart = new Date(now - i * dayMs);
          const dayStr = `${dayStart.getMonth() + 1}/${dayStart.getDate()}`;
          const count = history.filter(h => {
            const t = new Date(h.timestamp).getTime();
            return t >= dayStart.setHours(0,0,0,0) && t < dayStart.setHours(0,0,0,0) + dayMs;
          }).length;
          last7days.push({ day: dayStr, count });
        }

        console.log('\n  ╔═══════════════════════════════════════╗');
        console.log('  ║          📊 下载统计                   ║');
        console.log('  ╠═══════════════════════════════════════╣');
        console.log(`  ║  总下载次数:  ${String(history.length).padStart(6)} 次`);
        console.log(`  ║  去重歌曲数:  ${String(uniqueSongs.size).padStart(6)} 首`);
        console.log(`  ║  涉及歌手:    ${String(uniqueArtists.size).padStart(6)} 位`);
        console.log(`  ║  涉及专辑:    ${String(uniqueAlbums.size).padStart(6)} 张`);
        console.log(`  ║  总文件大小:  ${(totalSize / 1073741824).toFixed(2).padStart(6)} GB`);
        console.log('  ╠═══════════════════════════════════════╣');

        console.log('  ║  音质分布:');
        for (const [lv, cnt] of Object.entries(levelCount).sort((a, b) => b[1] - a[1])) {
          const bar = '█'.repeat(Math.min(Math.round(cnt / history.length * 20), 20));
          const pct = ((cnt / history.length) * 100).toFixed(0);
          console.log(`  ║    ${lv.padEnd(12)} ${bar} ${cnt}首 (${pct}%)`);
        }

        if (topArtists.length) {
          console.log('  ╠═══════════════════════════════════════╣');
          console.log('  ║  下载最多的歌手:');
          for (const [artist, cnt] of topArtists) {
            console.log(`  ║    ${artist.slice(0, 16).padEnd(18)} ${cnt} 首`);
          }
        }

        console.log('  ╠═══════════════════════════════════════╣');
        console.log('  ║  近 7 天下载量:');
        const maxDayCnt = Math.max(...last7days.map(d => d.count), 1);
        for (const d of last7days) {
          const bar = '▓'.repeat(Math.round(d.count / maxDayCnt * 15));
          console.log(`  ║    ${d.day.padEnd(6)} ${bar || '·'} ${d.count}`);
        }
        console.log('  ╚═══════════════════════════════════════╝');
        break;
      }

      case 'p':
      case 'P': {
        // 暂停/恢复
        togglePause();
        break;
      }

      case 'r':
      case 'R': {
        // 重置所有设置
        console.log('\n  ⚠️  将重置以下内容:');
        console.log(`    - 音质等级恢复默认 (${DEFAULT_LEVEL})`);
        console.log('    - 清空下载历史');
        console.log('    - 删除运行时配置文件');
        const confirm = await ask('\n  确认重置? (输入 yes 确认): ');
        if (confirm.trim() === 'yes') {
          // 重置配置
          if (fs.existsSync(CONFIG_FILE)) {
            fs.unlinkSync(CONFIG_FILE);
          }
          level = DEFAULT_LEVEL;
          // 清空历史
          const keepHistory = await ask('  是否保留下载历史? (y/n): ');
          if (keepHistory.trim().toLowerCase() !== 'y') {
            saveHistory([]);
            console.log('  ✅ 下载历史已清空');
          }
          console.log(`  ✅ 音质已恢复默认: ${DEFAULT_LEVEL}`);
          console.log('  ✅ 配置已重置');
        } else {
          console.log('  取消重置');
        }
        break;
      }

      case 'p':
      case 'P': {
        // 暂停/恢复
        togglePause();
        break;
      }

      case 'h':
      case 'H': {
        // 帮助
        console.log(`
  ╔══════════════════════════════════════════════════════════╗`);
        console.log(`  ║                    📖 使用帮助                           ║`);
        console.log(`  ╠══════════════════════════════════════════════════════════╣`);
        console.log(`  ║                                                          ║`);
        console.log(`  ║  【搜索与下载】                                           ║`);
        console.log(`  ║  1  搜索歌曲并下载 - 输入关键词搜索，选择后下载           ║`);
        console.log(`  ║  2  输入歌曲 ID 下载 - 直接输入网易云歌曲ID               ║`);
        console.log(`  ║  3  输入歌单 ID 下载全部 - 输入歌单ID批量下载             ║`);
        console.log(`  ║  s  按歌名搜索 - 按歌名精确搜索，支持试听/详情/下载      ║`);
        console.log(`  ║  6  按歌手批量下载 - 搜索歌手并选择下载其歌曲             ║`);
        console.log(`  ║  a  下载完整专辑 - 输入专辑ID下载全部曲目，也支持名称搜索 ║`);
        console.log(`  ║                                                          ║`);
        console.log(`  ║  【查看与管理】                                           ║`);
        console.log(`  ║  4  查看歌单歌曲列表 - 浏览歌单内容，可选择性下载         ║`);
        console.log(`  ║  5  查看歌曲歌词 - 输入ID查看歌词，可保存为.lrc文件       ║`);
        console.log(`  ║  7  试听歌曲 - 输入ID在线试听 (需本地播放器)              ║`);
        console.log(`  ║  8  查看歌曲详情 - 显示音质、大小等详细信息               ║`);
        console.log(`  ║  l  已下载歌曲列表 - 查看本地已下载的所有歌曲             ║`);
        console.log(`  ║                                                          ║`);
        console.log(`  ║  【数据统计】                                             ║`);
        console.log(`  ║  9  下载历史 - 查看/删除下载记录                          ║`);
        console.log(`  ║  t  下载统计 - 音质分布、歌手排行、近7天趋势             ║`);
        console.log(`  ║                                                          ║`);
        console.log(`  ║  【设置】                                                 ║`);
        console.log(`  ║  0  设置音质等级 - 切换下载音质                           ║`);
        console.log(`  ║                                                          ║`);
        console.log(`  ║  【命令行模式】                                           ║`);
        console.log(`  ║  node 163_music_downloader.js <id1> <id2> ...             ║`);
        console.log(`  ║  node 163_music_downloader.js --playlist=<id>             ║`);
        console.log(`  ║  node 163_music_downloader.js --album=<id>                ║`);
        console.log(`  ║  可选参数: --level=lossless --retries=5                   ║`);
        console.log(`  ║           --no-lyric --no-cover                           ║`);
        console.log(`  ║                                                          ║`);
        console.log(`  ║  【音质等级说明】                                         ║`);
        console.log(`  ║  standard  - 标准    exhigh   - 极高                     ║`);
        console.log(`  ║  lossless  - 无损    hires    - Hi-Res                   ║`);
        console.log(`  ║  jymaster  - 超清母带 (默认)  sky - 空间音频              ║`);
        console.log(`  ║  jyeffect  - 高清臻品                                     ║`);
        console.log(`  ║                                                          ║`);
        console.log(`  ╚══════════════════════════════════════════════════════════╝`);
        break;
      }

      case 'q':
      case 'Q':
      case 'exit':
      case 'quit':
        rl.close();
        console.log('\n👋 再见！');
        process.exit(0);

      default:
        console.log('⚠️  无效选项');
    }
  }
}

main().catch(console.error);