// 引入Node.js內(nèi)置的文件系統(tǒng)與路徑處理模塊
const fs = require('fs');
const path = require('path');

/**
 * 自動(dòng)備份文件函數(shù)
 * @param {string} sourceFolder - 源文件目錄路徑（需替換為實(shí)際路徑）
 * @param {string} backupFolder - 備份目錄路徑（需替換為實(shí)際路徑）
 */
function backupFiles(sourceFolder, backupFolder) {
  // 讀取源目錄下的所有文件/文件夾
  fs.readdir(sourceFolder, (err, files) => {
    // 若讀取目錄時(shí)出錯(cuò)（如路徑不存在），直接拋出錯(cuò)誤
    if (err) throw new Error(`讀取源目錄失?。?{err.message}`);
    
    // 遍歷每個(gè)文件，執(zhí)行復(fù)制操作
    files.forEach((file) => {
      // 拼接完整的源文件路徑與備份路徑
      const sourcePath = path.join(sourceFolder, file);
      const backupPath = path.join(backupFolder, file);
      
      // 復(fù)制文件（覆蓋已存在的備份文件）
      fs.copyFile(sourcePath, backupPath, (err) => {
        if (err) {
          console.error(`備份文件 ${file} 失?。?{err.message}`);
        } else {
          console.log(`? 成功備份：${file}`);
        }
      });
    });
  });
}

// 配置源目錄與備份目錄（請(qǐng)根據(jù)你的實(shí)際需求修改這兩個(gè)路徑）
const sourceDir = '/Users/your-name/Documents/重要工作文檔'; // 示例：Mac下的工作文檔目錄
const backupDir = '/Volumes/移動(dòng)硬盤(pán)/工作文檔備份'; // 示例：移動(dòng)硬盤(pán)的備份目錄

// 執(zhí)行備份操作
backupFiles(sourceDir, backupDir);

// 引入郵件發(fā)送庫(kù)nodemailer（需提前安裝：npm install nodemailer）
const nodemailer = require('nodemailer');
// 引入dotenv庫(kù)（可選，用于加載環(huán)境變量，避免硬編碼敏感信息）
require('dotenv').config();

/**
 * 預(yù)定電子郵件發(fā)送函數(shù)
 * @param {string} toEmail - 收件人郵箱地址（如："user@example.com"）
 * @param {string} subject - 郵件主題
 * @param {string} body - 郵件正文（支持純文本或HTML格式）
 * @param {number} sendTime - 發(fā)送時(shí)間的時(shí)間戳（毫秒級(jí)，如：Date.now() + 60000 表示1分鐘后發(fā)送）
 */
function sendScheduledEmail(toEmail, subject, body, sendTime) {
  // 計(jì)算當(dāng)前時(shí)間到發(fā)送時(shí)間的延遲（毫秒）
  const delay = sendTime - Date.now();
  
  // 若延遲為負(fù)（即發(fā)送時(shí)間已過(guò)），提示錯(cuò)誤并終止
  if (delay < 0) {
    console.error('? 錯(cuò)誤：預(yù)定的發(fā)送時(shí)間已過(guò)期，請(qǐng)?jiān)O(shè)置未來(lái)的時(shí)間');
    return;
  }

  // 延遲指定時(shí)間后執(zhí)行郵件發(fā)送
  setTimeout(() => {
    // 配置郵件發(fā)送器（以Gmail為例，其他郵箱需調(diào)整service或host）
    const transporter = nodemailer.createTransport({
      service: 'gmail', // 郵箱服務(wù)提供商（如："qq"、"163"，或手動(dòng)指定host: "smtp.163.com"）
      auth: {
        user: process.env.EMAIL_USER, // 發(fā)件人郵箱（從環(huán)境變量讀取，避免硬編碼）
        pass: process.env.EMAIL_PASS, // 郵箱授權(quán)碼（非登錄密碼，需在郵箱設(shè)置中開(kāi)啟SMTP并獲?。?
      },
    });

    // 配置郵件內(nèi)容
    const mailOptions = {
      from: `"你的名稱(chēng)" <${process.env.EMAIL_USER}>`, // 發(fā)件人信息（格式："名稱(chēng) <郵箱>"）
      to: toEmail, // 收件人郵箱（多個(gè)收件人用逗號(hào)分隔："a@example.com,b@example.com"）
      subject: subject, // 郵件主題
      text: body, // 純文本正文（若需HTML正文，可添加html: "<h1>HTML內(nèi)容</h1>"）
    };

    // 發(fā)送郵件
    transporter.sendMail(mailOptions, (error, info) => {
      if (error) {
        console.error(`? 郵件發(fā)送失?。?{error.message}`);
      } else {
        console.log(`? 郵件已成功發(fā)送！響應(yīng)信息：${info.response}`);
      }
    });
  }, delay);
}

// ------------------- 使用示例 -------------------
// 1. 設(shè)置發(fā)送時(shí)間：10秒后發(fā)送（Date.now()獲取當(dāng)前時(shí)間戳，加10000毫秒=10秒）
const scheduledTime = Date.now() + 10000;

// 2. 調(diào)用函數(shù)發(fā)送郵件（替換為你的實(shí)際需求）
sendScheduledEmail(
  'recipient@example.com', // 收件人郵箱
  '項(xiàng)目進(jìn)度提醒', // 郵件主題
  '您好！提醒您本周項(xiàng)目進(jìn)度需在周五前提交，感謝配合！', // 郵件正文
  scheduledTime // 預(yù)定發(fā)送時(shí)間
);

EMAIL_USER=your-email@gmail.com # 你的發(fā)件人郵箱
EMAIL_PASS=your-app-password    # 郵箱授權(quán)碼（非登錄密碼，Gmail需開(kāi)啟2FA后生成應(yīng)用專(zhuān)用密碼）

const fs = require('fs');
const path = require('path');

/**
 * 監(jiān)控目錄變化函數(shù)
 * @param {string} pathToWatch - 待監(jiān)控的目錄路徑（需替換為實(shí)際路徑）
 */
function monitorFolder(pathToWatch) {
  // 驗(yàn)證目錄是否存在
  if (!fs.existsSync(pathToWatch)) {
    throw new Error(`待監(jiān)控的目錄不存在：${pathToWatch}`);
  }

  console.log(`?? 已開(kāi)始監(jiān)控目錄：${pathToWatch}`);
  console.log('----------------------------------------');

  // 監(jiān)聽(tīng)目錄變化（支持rename和change兩種事件）
  fs.watch(pathToWatch, (eventType, filename) => {
    // eventType：事件類(lèi)型（rename=文件新增/刪除/重命名；change=文件內(nèi)容修改）
    // filename：發(fā)生變化的文件名（部分系統(tǒng)可能返回undefined，需處理）
    if (!filename) {
      console.log(`??  檢測(cè)到目錄變化，但未獲取到文件名`);
      return;
    }

    // 拼接完整的文件路徑
    const filePath = path.join(pathToWatch, filename);
    // 獲取當(dāng)前時(shí)間（用于日志記錄）
    const currentTime = new Date().toLocaleString();

    // 根據(jù)事件類(lèi)型輸出不同的日志
    switch (eventType) {
      case 'rename':
        // 檢查文件是否存在（存在=新增/重命名，不存在=刪除）
        const fileExists = fs.existsSync(filePath);
        console.log(`[${currentTime}] ?? ${fileExists ? '新增/重命名文件' : '刪除文件'}：${filename}`);
        break;
      case 'change':
        console.log(`[${currentTime}] ?? 修改文件內(nèi)容：${filename}`);
        break;
      default:
        console.log(`[${currentTime}] ??  未知事件類(lèi)型：${eventType}，涉及文件：${filename}`);
    }
  });
}

// 配置待監(jiān)控的目錄（替換為你的實(shí)際目錄，如共享文檔或項(xiàng)目代碼目錄）
const targetFolder = '/Users/your-name/Shared/團(tuán)隊(duì)共享文件';
// 啟動(dòng)監(jiān)控
monitorFolder(targetFolder);

const fs = require('fs');
const path = require('path');
// 引入PDF生成庫(kù)pdfkit（需安裝：npm install pdfkit）
const PDFDocument = require('pdfkit');

/**
 * 批量將圖像轉(zhuǎn)換為PDF文件
 * @param {string} imageFolder - 存放圖像的目錄路徑（需替換為實(shí)際路徑）
 * @param {string} outputPDF - 生成的PDF文件路徑（如："output.pdf"）
 */
function imagesToPDF(imageFolder, outputPDF) {
  // 驗(yàn)證圖像目錄是否存在
  if (!fs.existsSync(imageFolder)) {
    throw new Error(`圖像目錄不存在：${imageFolder}`);
  }

  // 創(chuàng)建PDF文檔實(shí)例
  const doc = new PDFDocument({
    size: 'A4', // PDF頁(yè)面尺寸（可選：'A3'/'Letter'/'Legal'等）
    margin: 20 // 頁(yè)面邊距（避免圖片緊貼邊緣）
  });

  // 創(chuàng)建寫(xiě)入流，用于將PDF內(nèi)容寫(xiě)入文件
  const writeStream = fs.createWriteStream(outputPDF);
  doc.pipe(writeStream); // 將PDF文檔與寫(xiě)入流關(guān)聯(lián)

  // 讀取圖像目錄下的所有文件，并篩選出圖片文件
  fs.readdir(imageFolder, (err, files) => {
    if (err) throw new Error(`讀取圖像目錄失?。?{err.message}`);

    // 篩選JPG/JPEG/PNG格式的文件（不區(qū)分大小寫(xiě)）
    const imageFiles = files.filter(file => 
      /\.(jpg|jpeg|png)$/i.test(path.extname(file))
    );

    if (imageFiles.length === 0) {
      console.warn('??  圖像目錄中未找到任何JPG/PNG文件');
      doc.end(); // 關(guān)閉PDF文檔
      return;
    }

    console.log(`?? 找到 ${imageFiles.length} 張圖片，開(kāi)始生成PDF...`);

    // 遍歷每張圖片，插入到PDF中
    imageFiles.forEach((file, index) => {
      const imagePath = path.join(imageFolder, file);

      // 除第一張圖片外，其余圖片均新增一頁(yè)（避免多圖擠在同一頁(yè)）
      if (index !== 0) {
        doc.addPage(); // 新增PDF頁(yè)面
      }

      // 將圖片插入當(dāng)前頁(yè)面（配置自適應(yīng)尺寸與居中顯示）
      doc.image(imagePath, {
        fit: [550, 750], // 圖片最大尺寸（適配A4頁(yè)面，避免超出邊界）
        align: 'center', // 水平居中
        valign: 'center' // 垂直居中
      });

      // 在圖片下方添加文件名（可選，便于識(shí)別圖片來(lái)源）
      doc.moveDown(2) // 向下移動(dòng)2行距離
         .fontSize(10)
         .text(`圖片來(lái)源：${file}`, { align: 'center' });
    });

    // 結(jié)束PDF文檔生成
    doc.end();
  });

  // 監(jiān)聽(tīng)寫(xiě)入流完成事件（提示PDF生成成功）
  writeStream.on('finish', () => {
    console.log(`? PDF生成完成！文件路徑：${path.resolve(outputPDF)}`);
  });

  // 監(jiān)聽(tīng)寫(xiě)入流錯(cuò)誤事件（捕獲生成過(guò)程中的異常）
  writeStream.on('error', (err) => {
    console.error(`? PDF生成失?。?{err.message}`);
  });
}

// ------------------- 使用示例 -------------------
const imageDir = '/Users/your-name/Desktop/掃描件'; // 存放掃描圖片的目錄
const outputPath = '/Users/your-name/Desktop/掃描件合集.pdf'; // 生成的PDF路徑
imagesToPDF(imageDir, outputPath);

// 引入桌面通知庫(kù)（需安裝：npm install node-notifier）
const notifier = require('node-notifier');
const path = require('path');

/**
 * 桌面通知提醒函數(shù)
 * @param {string} title - 通知標(biāo)題（如："會(huì)議提醒"）
 * @param {string} message - 通知內(nèi)容（如："下午3點(diǎn)項(xiàng)目會(huì)議"）
 * @param {number} notificationTime - 通知觸發(fā)時(shí)間（毫秒級(jí)時(shí)間戳）
 * @param {string} [soundPath] - 提示音路徑（可選，支持mp3/wav格式）
 */
function desktopNotifier(title, message, notificationTime, soundPath) {
  // 計(jì)算延遲時(shí)間（當(dāng)前時(shí)間到通知時(shí)間的差值）
  const delay = notificationTime - Date.now();

  // 處理延遲為負(fù)的情況（通知時(shí)間已過(guò)）
  if (delay < 0) {
    console.error('? 錯(cuò)誤：通知時(shí)間已過(guò)期，請(qǐng)?jiān)O(shè)置未來(lái)的時(shí)間');
    return;
  }

  console.log(`? 已預(yù)約通知：【${title}】，將在 ${new Date(notificationTime).toLocaleString()} 提醒`);

  // 延遲指定時(shí)間后觸發(fā)通知
  setTimeout(() => {
    // 配置通知選項(xiàng)
    const notificationOptions = {
      title: title, // 通知標(biāo)題
      message: message, // 通知內(nèi)容（支持換行，用\n分隔）
      icon: path.join(__dirname, 'reminder-icon.png'), // 通知圖標(biāo)（可選，替換為你的圖標(biāo)路徑）
      sound: soundPath ? soundPath : true, // 提示音（true表示使用系統(tǒng)默認(rèn)提示音）
      wait: true, // 點(diǎn)擊通知后才關(guān)閉（避免被忽略）
    };

    // 發(fā)送桌面通知
    notifier.notify(notificationOptions, (err, response) => {
      if (err) {
        console.error(`? 通知發(fā)送失敗：${err.message}`);
      } else {
        console.log(`? 通知已發(fā)送！用戶(hù)響應(yīng)：${response}`);
      }
    });

    // 監(jiān)聽(tīng)通知的點(diǎn)擊事件（可選，如點(diǎn)擊后打開(kāi)相關(guān)文件/鏈接）
    notifier.on('click', () => {
      console.log(`?? 用戶(hù)點(diǎn)擊了【${title}】通知`);
      // 示例：點(diǎn)擊通知后打開(kāi)瀏覽器訪問(wèn)指定鏈接（需引入open庫(kù)：npm install open）
      // const open = require('open');
      // open('https://docs.google.com/document/d/xxx'); // 如打開(kāi)會(huì)議文檔
    });
  }, delay);
}

// ------------------- 使用示例 -------------------
// 1. 設(shè)置通知時(shí)間：15秒后觸發(fā)（Date.now() + 15000毫秒）
const remindTime = Date.now() + 15000;

// 2. 調(diào)用函數(shù)發(fā)送預(yù)約通知
desktopNotifier(
  '團(tuán)隊(duì)會(huì)議提醒', // 通知標(biāo)題
  '?? 下午3點(diǎn)在會(huì)議室A召開(kāi)項(xiàng)目進(jìn)度會(huì)議\n?? 請(qǐng)?zhí)崆皽?zhǔn)備上周進(jìn)度報(bào)告', // 通知內(nèi)容（支持換行）
  remindTime, // 通知時(shí)間
  // path.join(__dirname, 'reminder-sound.mp3') // 可選：自定義提示音路徑
);

const fs = require('fs');
const path = require('path');

/**
 * 自動(dòng)清理舊文件函數(shù)
 * @param {string} folder - 待清理的目錄路徑（需替換為實(shí)際路徑）
 * @param {number} days - 過(guò)期天數(shù)（超過(guò)此天數(shù)的文件將被刪除）
 * @param {boolean} [dryRun=false] - 模擬清理（true=只打印要?jiǎng)h除的文件，不實(shí)際刪除）
 */
function cleanOldFiles(folder, days, dryRun = false) {
  // 驗(yàn)證目錄是否存在
  if (!fs.existsSync(folder)) {
    throw new Error(`待清理的目錄不存在：${folder}`);
  }

  // 計(jì)算“過(guò)期時(shí)間點(diǎn)”（當(dāng)前時(shí)間 - 天數(shù)×毫秒數(shù)）
  const now = Date.now();
  const cutoffTime = now - days * 24 * 60 * 60 * 1000; // 1天=24h×60min×60s×1000ms

  console.log(`???  開(kāi)始清理目錄：${folder}`);
  console.log(`? 清理規(guī)則：刪除超過(guò) ${days} 天未修改的文件`);
  console.log(`?? 過(guò)期時(shí)間點(diǎn)：${new Date(cutoffTime).toLocaleString()}`);
  console.log(`?? 正在掃描文件...`);

  // 讀取目錄下的所有文件/文件夾
  fs.readdir(folder, (err, files) => {
    if (err) throw new Error(`讀取清理目錄失?。?{err.message}`);

    // 存儲(chǔ)待刪除的文件列表（用于最終統(tǒng)計(jì)）
    const filesToDelete = [];

    // 遍歷每個(gè)文件，檢查是否過(guò)期
    files.forEach((file) => {
      const filePath = path.join(folder, file);

      // 獲取文件的狀態(tài)信息（如修改時(shí)間、是否為目錄）
      fs.stat(filePath, (err, stat) => {
        if (err) {
          console.error(`?? 獲取文件 ${file} 狀態(tài)失敗：${err.message}`);
          return;
        }

        // 跳過(guò)目錄（只刪除文件，不刪除子目錄）
        if (stat.isDirectory()) {
          console.log(`?? 跳過(guò)目錄：${file}`);
          return;
        }

        // 檢查文件修改時(shí)間是否早于過(guò)期時(shí)間點(diǎn)
        const fileModifyTime = stat.mtime.getTime();
        if (fileModifyTime < cutoffTime) {
          filesToDelete.push(file);
          // 若不是模擬清理，則執(zhí)行刪除操作
          if (!dryRun) {
            fs.unlink(filePath, (err) => {
              if (err) {
                console.error(`? 刪除文件 ${file} 失?。?{err.message}`);
              } else {
                console.log(`? 已刪除過(guò)期文件：${file}（最后修改時(shí)間：${new Date(fileModifyTime).toLocaleString()}）`);
              }
            });
          } else {
            // 模擬清理：只打印，不刪除
            console.log(`?? 模擬刪除：${file}（最后修改時(shí)間：${new Date(fileModifyTime).toLocaleString()}）`);
          }
        }
      });
    });

    // 掃描完成后輸出統(tǒng)計(jì)信息（延遲1秒，確保文件狀態(tài)讀取完成）
    setTimeout(() => {
      console.log('----------------------------------------');
      console.log(`?? 掃描完成！共發(fā)現(xiàn) ${filesToDelete.length} 個(gè)過(guò)期文件`);
      if (dryRun) {
        console.log(`??  提示：當(dāng)前為模擬清理模式，未實(shí)際刪除文件。若需執(zhí)行刪除，請(qǐng)將dryRun設(shè)為false。`);
      }
    }, 1000);
  });
}

// ------------------- 使用示例 -------------------
const targetDir = '/Users/your-name/Downloads'; // 待清理目錄（如下載目錄）
const expireDays = 30; // 清理超過(guò)30天的文件
const isDryRun = true; // 先執(zhí)行模擬清理（確認(rèn)無(wú)誤后改為false）

// 執(zhí)行清理（首次使用建議先模擬，避免誤刪重要文件）
cleanOldFiles(targetDir, expireDays, isDryRun);

const fs = require('fs');
const path = require('path');
// 引入HTTP請(qǐng)求庫(kù)axios（需安裝：npm install axios）
const axios = require('axios');

/**
 * 翻譯文本函數(shù)（基于LibreTranslate免費(fèi)API）
 * @param {string} text - 待翻譯的文本內(nèi)容
 * @param {string} sourceLang - 源語(yǔ)言（如："en"=英文，"zh"=中文，"es"=西班牙語(yǔ)）
 * @param {string} targetLang - 目標(biāo)語(yǔ)言（同上）
 * @returns {Promise<string>} 翻譯后的文本
 */
async function translateText(text, sourceLang = 'en', targetLang = 'zh') {
  try {
    // 發(fā)送POST請(qǐng)求到LibreTranslate API（免費(fèi)，無(wú)需API密鑰）
    const response = await axios.post('https://libretranslate.de/translate', {
      q: text, // 待翻譯文本
      source: sourceLang, // 源語(yǔ)言
      target: targetLang, // 目標(biāo)語(yǔ)言
      format: 'text', // 文本格式（支持"text"或"html"）
    });

    // 返回翻譯后的文本
    return response.data.translatedText;
  } catch (err) {
    throw new Error(`翻譯失敗：${err.response?.data?.error || err.message}`);
  }
}

/**
 * 翻譯文本文件（批量處理整個(gè)文件）
 * @param {string} inputPath - 輸入文本文件路徑（如："original.txt"）
 * @param {string} outputPath - 輸出翻譯文件路徑（如："translated-zh.txt"）
 * @param {string} sourceLang - 源語(yǔ)言
 * @param {string} targetLang - 目標(biāo)語(yǔ)言
 */
async function translateTextFile(inputPath, outputPath, sourceLang, targetLang) {
  // 驗(yàn)證輸入文件是否存在
  if (!fs.existsSync(inputPath)) {
    throw new Error(`輸入文件不存在：${inputPath}`);
  }

  console.log(`?? 開(kāi)始翻譯文件：${inputPath}`);
  console.log(`?? 翻譯方向：${sourceLang} → ${targetLang}`);

  try {
    // 1. 讀取輸入文件的文本內(nèi)容（支持UTF-8編碼）
    const originalText = fs.readFileSync(inputPath, 'utf8');
    console.log(`?? 成功讀取輸入文件，文本長(zhǎng)度：${originalText.length} 字符`);

    // 2. 調(diào)用翻譯函數(shù)處理文本
    const translatedText = await translateText(originalText, sourceLang, targetLang);

    // 3. 將翻譯后的文本寫(xiě)入輸出文件
    fs.writeFileSync(outputPath, translatedText, 'utf8');
    console.log(`? 翻譯完成！輸出文件路徑：${path.resolve(outputPath)}`);
  } catch (err) {
    console.error(`? 翻譯文件失?。?{err.message}`);
  }
}

// ------------------- 使用示例 -------------------
// 示例1：將英文文件翻譯成中文
translateTextFile(
  '/Users/your-name/Documents/product-en.txt', // 輸入英文文件
  '/Users/your-name/Documents/product-zh.txt', // 輸出中文文件
  'en', // 源語(yǔ)言：英文
  'zh'  // 目標(biāo)語(yǔ)言：中文
);

// 示例2：將中文文件翻譯成西班牙語(yǔ)（需將sourceLang改為"zh"，targetLang改為"es"）
// translateTextFile(
//   '/Users/your-name/Documents/notes-zh.txt',
//   '/Users/your-name/Documents/notes-es.txt',
//   'zh',
//   'es'
// );

const fs = require('fs');
const path = require('path');
// 引入PDF合并庫(kù)（需安裝：npm install pdf-merger-js）
const PDFMerger = require('pdf-merger-js');

/**
 * 批量合并PDF文件
 * @param {string} pdfFolder - 存放待合并PDF的目錄路徑
 * @param {string} outputPDF - 合并后的輸出PDF路徑
 * @param {function} [sortFn] - 自定義排序函數(shù)（可選，用于調(diào)整PDF合并順序）
 */
async function mergePDFs(pdfFolder, outputPDF, sortFn) {
  // 驗(yàn)證PDF目錄是否存在
  if (!fs.existsSync(pdfFolder)) {
    throw new Error(`PDF目錄不存在：${pdfFolder}`);
  }

  // 1. 讀取目錄下的所有PDF文件
  const files = fs.readdirSync(pdfFolder);
  // 篩選出后綴為.pdf的文件（不區(qū)分大小寫(xiě)）
  let pdfFiles = files.filter(file => 
    path.extname(file).toLowerCase() === '.pdf'
  );

  // 若未找到PDF文件，拋出錯(cuò)誤
  if (pdfFiles.length === 0) {
    throw new Error(`PDF目錄中未找到任何PDF文件：${pdfFolder}`);
  }

  // 2. 按自定義規(guī)則排序（默認(rèn)按文件名升序，可選傳入sortFn調(diào)整順序）
  if (sortFn && typeof sortFn === 'function') {
    pdfFiles.sort(sortFn);
  } else {
    // 默認(rèn)按文件名升序排序（如：1.pdf → 2.pdf → 3.pdf）
    pdfFiles.sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
  }

  console.log(`?? 找到 ${pdfFiles.length} 個(gè)待合并PDF文件`);
  console.log(`?? 合并順序：${pdfFiles.join(' → ')}`);

  // 3. 創(chuàng)建PDF合并實(shí)例
  const merger = new PDFMerger();

  try {
    // 遍歷PDF文件，添加到合并隊(duì)列
    for (const file of pdfFiles) {
      const pdfPath = path.join(pdfFolder, file);
      // 驗(yàn)證文件是否為有效PDF（避免目錄或非PDF文件）
      if (fs.statSync(pdfPath).isFile()) {
        await merger.add(pdfPath); // 添加PDF到合并隊(duì)列
        console.log(`? 已添加：${file}`);
      }
    }

    // 4. 執(zhí)行合并并保存到輸出文件
    await merger.save(outputPDF);
    console.log(`?? PDF合并完成！輸出路徑：${path.resolve(outputPDF)}`);
  } catch (err) {
    throw new Error(`PDF合并失?。?{err.message}`);
  }
}

// ------------------- 使用示例 -------------------
// 示例1：默認(rèn)按文件名升序合并（如：chapter1.pdf → chapter2.pdf）
const pdfDir = '/Users/your-name/Documents/項(xiàng)目報(bào)告章節(jié)'; // 待合并PDF目錄
const outputPath = '/Users/your-name/Documents/項(xiàng)目報(bào)告-完整版.pdf'; // 輸出路徑

// 執(zhí)行合并（默認(rèn)排序）
mergePDFs(pdfDir, outputPath)
  .catch(err => console.error(`? 操作失?。?{err.message}`));

// 示例2：按“文件修改時(shí)間”排序（最新修改的PDF排在前面）
// mergePDFs(
//   pdfDir,
//   outputPath,
//   (a, b) => {
//     // 獲取兩個(gè)文件的修改時(shí)間
//     const timeA = fs.statSync(path.join(pdfDir, a)).mtime.getTime();
//     const timeB = fs.statSync(path.join(pdfDir, b)).mtime.getTime();
//     return timeB - timeA; // 降序排序（最新的在前）
//   }
// ).catch(err => console.error(`? 操作失?。?{err.message}`));

const fs = require('fs');
const path = require('path');

/**
 * 批量重命名文件函數(shù)
 * @param {string} folder - 待重命名文件所在的目錄路徑
 * @param {string} prefix - 新文件名的前綴（如："image" → "image_001.jpg"）
 * @param {number} [startIndex=1] - 起始序號(hào)（默認(rèn)從1開(kāi)始）
 * @param {number} [digitLength=3] - 序號(hào)位數(shù)（默認(rèn)3位，如：001、002）
 * @param {string[]} [excludeExts=[]] - 排除的文件擴(kuò)展名（如：['.txt']，不重命名txt文件）
 */
function batchRename(folder, prefix, startIndex = 1, digitLength = 3, excludeExts = []) {
  // 驗(yàn)證目錄是否存在
  if (!fs.existsSync(folder)) {
    throw new Error(`待重命名的目錄不存在：${folder}`);
  }

  // 讀取目錄下的所有文件（不包含子目錄）
  fs.readdir(folder, (err, files) => {
    if (err) throw new Error(`讀取目錄失敗：${err.message}`);

    // 過(guò)濾掉目錄，只保留文件
    const fileList = files.filter(file => 
      fs.statSync(path.join(folder, file)).isFile()
    );

    if (fileList.length === 0) {
      console.warn('??  目錄中未找到任何文件，無(wú)需重命名');
      return;
    }

    console.log(`?? 開(kāi)始批量重命名目錄：${folder}`);
    console.log(`?? 重命名規(guī)則：${prefix}_[序號(hào)].擴(kuò)展名（序號(hào)從${startIndex}開(kāi)始，共${digitLength}位）`);
    console.log(`?? 排除的擴(kuò)展名：${excludeExts.length > 0 ? excludeExts.join(', ') : '無(wú)'}`);
    console.log('----------------------------------------');

    // 遍歷文件，執(zhí)行重命名
    fileList.forEach((oldFileName, index) => {
      // 1. 獲取文件原始擴(kuò)展名（如：.jpg、.pdf）
      const ext = path.extname(oldFileName).toLowerCase();

      // 2. 檢查是否需要排除該擴(kuò)展名
      if (excludeExts.includes(ext)) {
        console.log(`??  排除文件：${oldFileName}（擴(kuò)展名${ext}在排除列表中）`);
        return;
      }

      // 3. 計(jì)算當(dāng)前文件的序號(hào)（起始序號(hào) + 索引）
      const currentIndex = startIndex + index;
      // 用0填充序號(hào)，確保位數(shù)統(tǒng)一（如：1 → 001，10 → 010）
      const paddedIndex = String(currentIndex).padStart(digitLength, '0');

      // 4. 拼接新文件名（前綴 + 序號(hào) + 原始擴(kuò)展名）
      const newFileName = `${prefix}_${paddedIndex}${ext}`;

      // 5. 拼接舊路徑與新路徑
      const oldPath = path.join(folder, oldFileName);
      const newPath = path.join(folder, newFileName);

      // 6. 避免新文件名與現(xiàn)有文件沖突
      if (fs.existsSync(newPath) && oldPath !== newPath) {
        console.error(`? 重命名失?。?{newFileName} 已存在，跳過(guò) ${oldFileName}`);
        return;
      }

      // 7. 執(zhí)行重命名操作
      fs.rename(oldPath, newPath, (err) => {
        if (err) {
          console.error(`? 重命名 ${oldFileName} 失?。?{err.message}`);
        } else {
          console.log(`? 重命名成功：${oldFileName} → ${newFileName}`);
        }
      });
    });
  });
}

// ------------------- 使用示例 -------------------
// 示例1：批量重命名下載的圖片（前綴"vacation_photo"，序號(hào)3位，排除.txt文件）
batchRename(
  '/Users/your-name/Downloads/旅行照片', // 待重命名目錄
  'vacation_photo', // 文件名前綴
  1, // 起始序號(hào)
  3, // 序號(hào)位數(shù)（001~999）
  ['.txt'] // 排除.txt文件（不重命名文本文件）
);

// 示例2：重命名項(xiàng)目文檔（前綴"project_report"，序號(hào)2位，從10開(kāi)始）
// batchRename(
//   '/Users/your-name/Documents/項(xiàng)目文檔',
//   'project_report',
//   10, // 起始序號(hào)10 → 10、11、12...
//   2, // 序號(hào)位數(shù)（01~99，10 → 10，11 → 11）
//   [] // 不排除任何擴(kuò)展名
// );

const axios = require('axios');

/**
 * 獲取指定城市的當(dāng)前天氣信息
 * @param {string} city - 城市名稱(chēng)（如："New York"、"Beijing"）
 * @param {string} apiKey - OpenWeatherMap API密鑰（需自行注冊(cè)獲?。?
 * @param {string} [units=metric] - 溫度單位（metric=攝氏度，imperial=華氏度）
 * @param {string} [lang=zh_cn] - 語(yǔ)言（zh_cn=中文，en=英文）
 */
async function getWeather(city, apiKey, units = 'metric', lang = 'zh_cn') {
  // 驗(yàn)證API密鑰是否存在（需用戶(hù)自行注冊(cè)獲?。?
  if (!apiKey) {
    throw new Error('請(qǐng)?zhí)峁㎡penWeatherMap API密鑰（注冊(cè)地址：https://openweathermap.org/）');
  }

  try {
    // 調(diào)用OpenWeatherMap API獲取天氣數(shù)據(jù)
    const response = await axios.get('https://api.openweathermap.org/data/2.5/weather', {
      params: {
        q: city, // 城市名
        appid: apiKey, // API密鑰
        units: units, // 溫度單位
        lang: lang // 響應(yīng)語(yǔ)言
      }
    });

    // 提取關(guān)鍵天氣數(shù)據(jù)（從API響應(yīng)中篩選有用信息）
    const weatherData = response.data;
    const { temp, feels_like, humidity, pressure } = weatherData.main; // 溫度、體感溫度、濕度、氣壓
    const { description, icon } = weatherData.weather[0]; // 天氣狀況描述、圖標(biāo)
    const { speed } = weatherData.wind; // 風(fēng)速
    const { country } = weatherData.sys; // 國(guó)家代碼
    const sunriseTime = new Date(weatherData.sys.sunrise * 1000).toLocaleTimeString(); // 日出時(shí)間
    const sunsetTime = new Date(weatherData.sys.sunset * 1000).toLocaleTimeString(); // 日落時(shí)間

    // 格式化輸出天氣信息
    console.log(`???  ${city}, ${country} 當(dāng)前天氣`);
    console.log('----------------------------------------');
    console.log(`天氣狀況：${description.charAt(0).toUpperCase() + description.slice(1)}`); // 首字母大寫(xiě)
    console.log(`當(dāng)前溫度：${temp} °C（體感溫度：${feels_like} °C）`);
    console.log(`濕度：${humidity}% | 氣壓：${pressure} hPa | 風(fēng)速：${speed} m/s`);
    console.log(`日出時(shí)間：${sunriseTime} | 日落時(shí)間：${sunsetTime}`);
    console.log('----------------------------------------');

    // 返回完整天氣數(shù)據(jù)（便于后續(xù)擴(kuò)展，如寫(xiě)入文件或發(fā)送郵件）
    return weatherData;
  } catch (err) {
    // 處理API調(diào)用錯(cuò)誤（如城市不存在、API密鑰無(wú)效）
    const errorMsg = err.response?.data?.message || err.message;
    throw new Error(`獲取天氣失?。?{errorMsg}`);
  }
}

// ------------------- 使用示例 -------------------
// 1. 替換為你的OpenWeatherMap API密鑰（免費(fèi)注冊(cè)獲取：https://openweathermap.org/api）
const apiKey = 'your-openweathermap-api-key';

// 2. 獲取指定城市的天氣（示例：北京）
getWeather('Beijing', apiKey)
  .then(() => console.log('? 天氣數(shù)據(jù)獲取完成'))
  .catch(err => console.error(`? 操作失?。?{err.message}`));

// 3. 獲取其他城市天氣（示例：紐約，英文輸出，華氏度）
// getWeather('New York', apiKey, 'imperial', 'en')
//   .then(() => console.log('? Weather data retrieved successfully'))
//   .catch(err => console.error(`? Failed: ${err.message}`));

const axios = require('axios');

/**
 * 獲取隨機(jī)名言（支持篩選標(biāo)簽、作者）
 * @param {string[]} [tags=[]] - 篩選標(biāo)簽（如：["inspirational", "life"]，勵(lì)志、人生主題）
 * @param {string} [author=undefined] - 篩選作者（如："Albert Einstein"，只獲取該作者的名言）
 * @returns {Promise<object>} 名言對(duì)象（包含content=名言?xún)?nèi)容，author=作者，tags=標(biāo)簽）
 */
async function getRandomQuote(tags = [], author = undefined) {
  try {
    // 構(gòu)建API請(qǐng)求參數(shù)
    const params = {};
    // 若有標(biāo)簽篩選，拼接標(biāo)簽參數(shù)（多個(gè)標(biāo)簽用逗號(hào)分隔）
    if (tags.length > 0) params.tags = tags.join(',');
    // 若有作者篩選，添加作者參數(shù)
    if (author) params.author = author;

    // 調(diào)用quotable API獲取隨機(jī)名言（免費(fèi)，無(wú)需API密鑰）
    const response = await axios.get('https://api.quotable.io/random', { params });
    const quote = response.data;

    // 格式化輸出名言（帶樣式，便于閱讀）
    console.log('========================================');
    console.log(`"${quote.content}"`);
    console.log(`\n— ${quote.author}`);
    if (quote.tags.length > 0) {
      console.log(`\n主題：${quote.tags.map(tag => `#${tag}`).join(' ')}`);
    }
    console.log('========================================');

    // 返回名言對(duì)象（便于后續(xù)擴(kuò)展，如寫(xiě)入文件、生成圖片）
    return quote;
  } catch (err) {
    const errorMsg = err.response?.data?.message || err.message;
    throw new Error(`獲取名言失敗：${errorMsg}`);
  }
}

// ------------------- 使用示例 -------------------
// 示例1：獲取任意隨機(jī)名言（無(wú)篩選）
console.log('?? 獲取任意隨機(jī)名言：');
getRandomQuote()
  .then(() => console.log('? 名言獲取完成'))
  .catch(err => console.error(`? 操作失?。?{err.message}`));

// 示例2：獲取“勵(lì)志”主題的名言（標(biāo)簽篩選）
// console.log('\n?? 獲取勵(lì)志主題名言：');
// getRandomQuote(['inspirational'])
//   .then(() => console.log('? 名言獲取完成'))
//   .catch(err => console.error(`? 操作失敗：${err.message}`));

// 示例3：獲取愛(ài)因斯坦的名言（作者篩選）
// console.log('\n?? 獲取愛(ài)因斯坦的名言：');
// getRandomQuote([], 'Albert Einstein')
//   .then(() => console.log('? 名言獲取完成'))
//   .catch(err => console.error(`? 操作失?。?{err.message}`));