import 'dotenv/config';
import express from 'express';
import cors from 'cors';
import axios from 'axios';
import * as cheerio from 'cheerio';
import iconv from 'iconv-lite';
import { sendReportEmail } from './emailService.js';
import { initScheduler, runTaskNow, reloadScheduler, getSchedulerStatus } from './scheduler.js';
import { extractBudgetWithLLM, testLLMConnection, getLLMStatus, isLLMEnabled } from './llmService.js';

const app = express();
const PORT = process.env.PORT || 5000;

app.use(cors());
app.use(express.json());
app.use(express.static('public'));

const BASE_URL = 'https://gjzx.nanjing.gov.cn/gggs/';

// 获取分页URL
function getPageUrl(pageIndex, baseUrl = BASE_URL) {
  if (pageIndex === 0) {
    return baseUrl;
  }
  const cleanBaseUrl = baseUrl.replace(/\/$/, '');
  return `${cleanBaseUrl}/index_${pageIndex}.html`;
}

// 检查日期是否在范围内
function isDateInRange(dateStr, startDate, endDate) {
  if (!dateStr) return false;
  const date = new Date(dateStr);
  if (isNaN(date.getTime())) return false;

  if (startDate && date < new Date(startDate)) return false;
  if (endDate && date > new Date(endDate)) return false;
  return true;
}

// 按时间范围采集多页列表
async function fetchListByDateRange(startDate, endDate, maxPages = 23) {
  const allItems = [];
  let shouldContinue = true;
  let pageIndex = 0;

  console.log(`开始按时间范围采集: ${startDate || '不限'} 至 ${endDate || '不限'}`);

  while (shouldContinue && pageIndex < maxPages) {
    const pageUrl = getPageUrl(pageIndex);
    console.log(`正在采集第 ${pageIndex + 1} 页: ${pageUrl}`);

    try {
      const html = await fetchHtml(pageUrl);
      const items = parseList(html);

      if (items.length === 0) {
        console.log(`第 ${pageIndex + 1} 页没有数据，停止采集`);
        break;
      }

      let hasItemsInRange = false;
      let allItemsBeforeRange = true;

      for (const item of items) {
        if (isDateInRange(item.date, startDate, endDate)) {
          allItems.push(item);
          hasItemsInRange = true;
          allItemsBeforeRange = false;
        } else if (startDate && new Date(item.date) < new Date(startDate)) {
          allItemsBeforeRange = allItemsBeforeRange && true;
        } else {
          allItemsBeforeRange = false;
        }
      }

      if (allItemsBeforeRange && startDate) {
        console.log(`第 ${pageIndex + 1} 页所有项目都早于起始日期，停止采集`);
        shouldContinue = false;
      }

      console.log(`第 ${pageIndex + 1} 页找到 ${items.length} 条，符合条件 ${hasItemsInRange ? '有' : '无'}`);

      pageIndex++;

      if (shouldContinue && pageIndex < maxPages) {
        await new Promise(resolve => setTimeout(resolve, 500));
      }
    } catch (err) {
      console.error(`采集第 ${pageIndex + 1} 页失败: ${err.message}`);
      break;
    }
  }

  console.log(`总共采集了 ${pageIndex} 页，找到 ${allItems.length} 条符合条件的公告`);
  return allItems;
}

const http = axios.create({
  responseType: 'arraybuffer',
  timeout: 10000,
  headers: {
    'User-Agent': 'Mozilla/5.0 (compatible; gjzx-scraper/1.0)',
  },
});

function pickEncoding(contentType = '') {
  const match = /charset=([^;]+)/i.exec(contentType);
  if (!match) return 'utf-8';
  const charset = match[1].trim().toLowerCase();
  if (charset.includes('gb')) return 'gbk';
  return charset;
}

async function fetchHtml(url) {
  const res = await http.get(url);
  const encoding = pickEncoding(res.headers['content-type']);
  const html = iconv.decode(res.data, encoding || 'utf-8');
  return html;
}

// 从jszbcg.com的API获取PDF URL
async function fetchPdfUrlFromApi(pageUrl) {
  try {
    // 从URL中提取公告ID和bulletinType
    // URL格式: https://www.jszbcg.com/#/bulletinDetails/招标公告/2c9180899a7e34d2019a95630c931a8e?bulletinType=1
    const bulletinIdMatch = pageUrl.match(/bulletinDetails\/[^\/]+\/([a-f0-9]+)/i);
    const bulletinTypeMatch = pageUrl.match(/bulletinType=(\d+)/);

    if (!bulletinIdMatch) {
      console.log('无法从URL中提取公告ID');
      return null;
    }

    const bulletinId = bulletinIdMatch[1];
    const bulletinType = bulletinTypeMatch ? bulletinTypeMatch[1] : '1';

    // 调用API获取公告详情
    const apiUrl = `https://api.jszbtb.com/DataGatewayApi/PublishBulletin/BulletinType/${bulletinType}/ID/${bulletinId}`;
    console.log(`调用API获取公告详情: ${apiUrl}`);

    const response = await http.get(apiUrl, {
      headers: {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
        'Accept': 'application/json',
        'Referer': 'https://www.jszbcg.com/'
      },
      responseType: 'arraybuffer'
    });

    // 解析返回的数据
    const responseText = iconv.decode(response.data, 'utf-8');
    const data = JSON.parse(responseText);

    if (data.success && data.data && data.data.signedPdfUrl) {
      const pdfUrl = data.data.signedPdfUrl;
      console.log(`成功从API获取PDF URL: ${pdfUrl}`);
      return pdfUrl;
    }

    console.log('API返回数据中没有PDF URL');
    return null;
  } catch (err) {
    console.error(`从API获取PDF URL失败: ${err.message}`);
    return null;
  }
}

// 从iframe嵌入页面提取PDF URL（备用方案）
function extractPdfUrl(html, pageUrl) {
  const $ = cheerio.load(html);

  // 尝试多种iframe选择器
  let iframe = $('iframe').first();
  if (!iframe.length) {
    iframe = $('iframe[src*="pdf"]').first();
  }
  if (!iframe.length) {
    iframe = $('iframe[src*="viewer"]').first();
  }

  if (iframe.length) {
    const src = iframe.attr('src');
    if (!src) return null;

    // 从viewer.html?file=xxx.pdf中提取PDF URL
    const match = src.match(/[?&]file=([^&]+)/);
    if (match) {
      let pdfUrl = decodeURIComponent(match[1]);

      // 检查是否是绝对路径
      if (!pdfUrl.startsWith('http://') && !pdfUrl.startsWith('https://')) {
        try {
          pdfUrl = new URL(pdfUrl, pageUrl).toString();
        } catch (err) {
          console.error(`URL拼接失败: ${err.message}`);
          return null;
        }
      }

      return pdfUrl;
    }
  }

  return null;
}

// 下载并解析PDF内容
async function fetchPdfContent(pdfUrl) {
  console.log(`正在下载PDF: ${pdfUrl}`);
  try {
    // 导入pdf-parse v2
    const { PDFParse } = await import('pdf-parse');

    const response = await http.get(pdfUrl, {
      responseType: 'arraybuffer',
      timeout: 30000, // PDF文件可能较大，增加超时时间
    });

    // 使用pdf-parse v2 API
    const parser = new PDFParse({ data: response.data });
    const result = await parser.getText();
    await parser.destroy();

    console.log(`PDF解析成功，文本长度: ${result.text.length}`);
    return result.text;
  } catch (err) {
    console.error(`PDF下载或解析失败: ${err.message}`);
    console.error(err.stack);
    throw err;
  }
}

function parseList(html) {
  const $ = cheerio.load(html);
  const items = [];

  // 查找所有表格行中的链接
  $('table tr').each((_, row) => {
    const $row = $(row);
    const link = $row.find('td:first-child a').first();
    const dateCell = $row.find('td:nth-child(2)');

    if (link.length && dateCell.length) {
      const title = link.attr('title') || link.text().trim();
      const rawHref = link.attr('href') || '';
      const dateText = dateCell.text().trim();

      // 过滤掉导航链接和空链接
      if (!rawHref || !title || title.length < 5) return;
      if (rawHref === './' || rawHref === '../') return;

      // 验证日期格式 (YYYY-MM-DD)
      if (!/^\d{4}-\d{2}-\d{2}$/.test(dateText)) return;

      try {
        const href = new URL(rawHref, BASE_URL).toString();
        items.push({ title, href, date: dateText });
      } catch (err) {
        // 跳过无效URL
        return;
      }
    }
  });

  return items;
}

function parseDetail(html) {
  const $ = cheerio.load(html);

  // 尝试多种标题选择器
  let title = $('.title18').text().trim();
  if (!title) {
    title = $('.article-info h1').text().trim();
  }
  if (!title) {
    title = $('h1').first().text().trim();
  }

  // 尝试提取发布时间
  const publishTd = $('td:contains("发布部门")').filter((_, el) => {
    return $(el).text().includes('发布时间');
  });
  const publishText = publishTd.text().trim();
  let timeMatch = publishText.match(/(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})/);
  let publishTime = timeMatch ? timeMatch[1] : '';

  // 如果第一种方式没找到，尝试其他方式
  if (!publishTime) {
    const infoText = $('.info-sources').text() || $('body').text();
    timeMatch = infoText.match(/(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2})/);
    publishTime = timeMatch ? timeMatch[1] : '';
  }

  // 尝试多种内容选择器
  let content = '';
  const contentSelectors = [
    '.zhenwen td',      // 原有格式
    '.con',             // 新格式（宁易新系统）
    '.article-content', // 通用格式
    '.ewb-article-content',
    'body'              // 兜底方案
  ];

  for (const selector of contentSelectors) {
    const el = $(selector).first();
    if (el.length > 0) {
      const text = el.text().trim();
      if (text.length > content.length) {
        content = text;
      }
    }
  }

  const budget = extractBudget(content);

  return {
    title,
    publishTime,
    content,
    budget,
  };
}

// 增强版parseDetail，支持PDF解析和LLM金额提取
async function parseDetailEnhanced(html, pageUrl) {
  const $ = cheerio.load(html);

  let pdfUrl = null;

  // 优先尝试从API获取PDF URL（适用于jszbcg.com）
  if (pageUrl.includes('jszbcg.com')) {
    pdfUrl = await fetchPdfUrlFromApi(pageUrl);
  }

  // 如果API获取失败，回退到从HTML中提取
  if (!pdfUrl) {
    pdfUrl = extractPdfUrl(html, pageUrl);
  }

  let content = '';
  let pdfParsed = false;

  if (pdfUrl) {
    // 如果有PDF，从PDF中提取内容
    console.log(`发现PDF: ${pdfUrl}`);
    try {
      content = await fetchPdfContent(pdfUrl);
      pdfParsed = true;
      console.log(`成功从PDF提取内容，长度: ${content.length}`);
    } catch (err) {
      console.error('PDF解析失败，回退到HTML解析:', err.message);
      // 回退到普通HTML解析
      const htmlDetail = parseDetail(html);
      content = htmlDetail.content;
    }
  } else {
    // 普通HTML页面，使用原有逻辑
    const htmlDetail = parseDetail(html);
    content = htmlDetail.content;
  }

  // 提取金额：优先使用 LLM，失败则降级到正则表达式
  let budget = null;
  if (isLLMEnabled()) {
    console.log('使用 LLM 提取金额...');
    budget = await extractBudgetWithLLM(content);
    if (budget) {
      console.log(`LLM 提取成功: ${budget.amount} ${budget.unit}`);
    } else {
      console.log('LLM 提取失败，降级到正则表达式');
    }
  }

  // 如果 LLM 未启用或提取失败，使用正则表达式
  if (!budget) {
    budget = extractBudget(content);
    if (budget) {
      budget.source = 'regex'; // 标记来源
    }
  }

  // 获取其他基本信息（标题、发布时间等）
  const basicInfo = parseDetail(html);

  return {
    ...basicInfo,
    content,
    budget,
    hasPdf: pdfParsed,
    pdfUrl: pdfParsed ? pdfUrl : null,
  };
}

function extractBudget(content) {
  // 预处理内容：去除数字之间的换行符和空白字符
  // 这样可以匹配被换行符分隔的数字，例如 "1\n1\n0\n9\n0\n0" -> "110900"
  let cleanedContent = content.replace(/(\d)\s*[\n\r]\s*(?=\d)/g, '$1');

  // 直接定义金额匹配模式（从高优先级到低优先级）
  const patterns = [
    // 优先级1: 带货币符号的万元
    { regex: /(?:¥|￥|人民币)\s*([\d,，]+(?:\.\d+)?)\s*万元/i, priority: 1 },

    // 优先级2: 括号内的金额(元)
    { regex: /[（(][¥￥]([\d,，]+(?:\.\d+)?)[)）]/i, priority: 2, divider: 10000 },

    // 优先级3: 普通万元格式
    { regex: /([\d,，]+(?:\.\d+)?)\s*万元/i, priority: 3 },

    // 优先级4: 带货币符号的元(转万元)
    { regex: /(?:¥|￥|人民币)\s*([\d,，]+(?:\.\d+)?)\s*元/i, priority: 4, divider: 10000 },

    // 优先级5: 普通元格式(转万元，最低优先级，排除"元整"避免误匹配中文大写)
    { regex: /([\d,，]+(?:\.\d+)?)\s*元(?!整)/i, priority: 5, divider: 10000 }
  ];

  let bestMatch = null;
  let bestPriority = Infinity;

  // 遍历所有模式,找到优先级最高的匹配
  for (const pattern of patterns) {
    const match = cleanedContent.match(pattern.regex);
    if (match && pattern.priority < bestPriority) {
      // 清理数字中的逗号并转换
      const numberStr = match[1].replace(/[,，]/g, '');
      let amount = parseFloat(numberStr);

      // 如果是元单位,转换为万元
      if (pattern.divider) {
        amount = amount / pattern.divider;
      }

      // 验证金额合理性(0.01万元到100000000万元之间)
      if (!isNaN(amount) && amount >= 0.01 && amount <= 100000000) {
        bestMatch = {
          amount,
          unit: '万元',
          text: match[0],
          originalUnit: pattern.divider ? '元' : '万元'
        };
        bestPriority = pattern.priority;
      }
    }
  }

  return bestMatch;
}

// API 路由

// 获取列表
app.get('/api/list', async (req, res) => {
  try {
    const baseUrl = req.query.url || BASE_URL;
    const page = parseInt(req.query.page) || 1;

    // 根据页码构建URL
    let url = baseUrl;
    if (page > 1) {
      // 移除baseUrl末尾的斜杠
      const cleanBaseUrl = baseUrl.replace(/\/$/, '');
      url = `${cleanBaseUrl}/index_${page - 1}.html`;
    }

    const html = await fetchHtml(url);
    const items = parseList(html);
    res.json({ success: true, data: items, page });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 按时间范围获取列表
app.post('/api/list-daterange', async (req, res) => {
  try {
    const { startDate, endDate, maxPages = 23 } = req.body;
    const items = await fetchListByDateRange(startDate, endDate, maxPages);
    res.json({ success: true, data: items });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 获取详情
app.post('/api/details', async (req, res) => {
  try {
    const { items, limit = 10 } = req.body;
    const results = [];
    const toFetch = items.slice(0, limit);

    for (const item of toFetch) {
      try {
        const html = await fetchHtml(item.href);
        const detail = await parseDetailEnhanced(html, item.href);
        results.push({
          ...item,
          detail,
        });
        await new Promise((resolve) => setTimeout(resolve, 500));
      } catch (err) {
        results.push({
          ...item,
          detail: null,
          error: err.message,
        });
      }
    }

    res.json({ success: true, data: results });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 生成报告
app.post('/api/report', async (req, res) => {
  try {
    const { limit = 15, threshold = 50, url } = req.body;
    const targetUrl = url && url.trim() !== '' ? url : BASE_URL;

    // 按需采集多页以获取足够的数据
    const items = [];
    let pageIndex = 0;
    const maxPagesToFetch = Math.ceil(limit / 10) + 1; // 假设每页约10条，多抓一页保险

    while (items.length < limit && pageIndex < maxPagesToFetch) {
      const pageUrl = getPageUrl(pageIndex, targetUrl);
      console.log(`正在采集第 ${pageIndex + 1} 页: ${pageUrl}`);

      try {
        const html = await fetchHtml(pageUrl);
        const pageItems = parseList(html);

        if (pageItems.length === 0) {
          console.log(`第 ${pageIndex + 1} 页没有数据，停止采集`);
          break;
        }

        items.push(...pageItems);
        pageIndex++;

        if (items.length < limit && pageIndex < maxPagesToFetch) {
          await new Promise(resolve => setTimeout(resolve, 500));
        }
      } catch (err) {
        console.error(`采集第 ${pageIndex + 1} 页失败: ${err.message}`);
        break;
      }
    }

    const results = [];
    const toFetch = items.slice(0, limit);

    for (const item of toFetch) {
      try {
        const html = await fetchHtml(item.href);
        const detail = await parseDetailEnhanced(html, item.href);
        results.push({
          ...item,
          detail,
        });
        await new Promise((resolve) => setTimeout(resolve, 500));
      } catch (err) {
        results.push({
          ...item,
          detail: null,
          error: err.message,
        });
      }
    }

    const filtered = results.filter((item) => {
      return item.detail?.budget && item.detail.budget.amount > threshold;
    });

    const total = filtered.reduce(
      (sum, item) => sum + (item.detail.budget?.amount || 0),
      0
    );

    const report = {
      summary: {
        total_count: results.length,
        filtered_count: filtered.length,
        threshold: `${threshold}万元`,
        total_amount: `${total.toFixed(2)}万元`,
        generated_at: new Date().toISOString(),
      },
      projects: filtered.map((item) => ({
        title: item.title,
        date: item.date,
        publish_time: item.detail.publishTime,
        budget: item.detail.budget,
        url: item.href,
      })),
    };

    res.json({ success: true, data: report });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 按时间范围生成报告
app.post('/api/report-daterange', async (req, res) => {
  try {
    const { startDate, endDate, threshold = 50, maxPages = 23 } = req.body;

    // 按时间范围采集列表
    const items = await fetchListByDateRange(startDate, endDate, maxPages);

    if (items.length === 0) {
      return res.json({
        success: true,
        data: {
          summary: {
            total_count: 0,
            filtered_count: 0,
            threshold: `${threshold}万元`,
            total_amount: '0.00万元',
            generated_at: new Date().toISOString(),
            date_range: { startDate, endDate },
          },
          projects: [],
        },
      });
    }

    // 采集详情
    const results = [];
    for (const item of items) {
      try {
        const html = await fetchHtml(item.href);
        const detail = await parseDetailEnhanced(html, item.href);
        results.push({
          ...item,
          detail,
        });
        await new Promise((resolve) => setTimeout(resolve, 500));
      } catch (err) {
        results.push({
          ...item,
          detail: null,
          error: err.message,
        });
      }
    }

    // 生成报告
    const filtered = results.filter((item) => {
      return item.detail?.budget && item.detail.budget.amount > threshold;
    });

    const total = filtered.reduce(
      (sum, item) => sum + (item.detail.budget?.amount || 0),
      0
    );

    const report = {
      summary: {
        total_count: results.length,
        filtered_count: filtered.length,
        threshold: `${threshold}万元`,
        total_amount: `${total.toFixed(2)}万元`,
        generated_at: new Date().toISOString(),
        date_range: { startDate, endDate },
      },
      projects: filtered.map((item) => ({
        title: item.title,
        date: item.date,
        publish_time: item.detail.publishTime,
        budget: item.detail.budget,
        url: item.href,
      })),
    };

    res.json({ success: true, data: report });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 发送报告邮件
app.post('/api/send-email', async (req, res) => {
  try {
    const { emailConfig, report } = req.body;

    // 验证必需的配置参数
    if (!emailConfig || !emailConfig.smtpHost || !emailConfig.smtpUser || !emailConfig.smtpPass) {
      return res.status(400).json({
        success: false,
        error: '邮件配置不完整,请填写SMTP服务器、用户名和密码',
      });
    }

    if (!emailConfig.recipients || emailConfig.recipients.trim() === '') {
      return res.status(400).json({
        success: false,
        error: '请至少指定一个收件人',
      });
    }

    if (!report) {
      return res.status(400).json({
        success: false,
        error: '没有可发送的报告数据',
      });
    }

    // 发送邮件
    const result = await sendReportEmail(emailConfig, report);

    res.json({
      success: true,
      message: '邮件发送成功',
      messageId: result.messageId,
    });
  } catch (error) {
    console.error('发送邮件API错误:', error);
    res.status(500).json({
      success: false,
      error: error.message,
    });
  }
});

// 测试PDF解析的API
app.post('/api/test-pdf', async (req, res) => {
  try {
    const { pdfUrl } = req.body;

    if (!pdfUrl) {
      return res.status(400).json({ success: false, error: '请提供PDF URL' });
    }

    console.log(`测试PDF URL: ${pdfUrl}`);
    const content = await fetchPdfContent(pdfUrl);
    const budget = extractBudget(content);

    res.json({
      success: true,
      data: {
        contentLength: content.length,
        contentPreview: content.substring(0, 500),
        budget,
      },
    });
  } catch (error) {
    console.error('测试PDF失败:', error);
    res.status(500).json({ success: false, error: error.message });
  }
});

// 获取配置
app.get('/api/config', async (req, res) => {
  try {
    const { readFileSync } = await import('fs');
    const { join } = await import('path');
    const { fileURLToPath } = await import('url');
    const { dirname } = await import('path');

    const __filename = fileURLToPath(import.meta.url);
    const __dirname = dirname(__filename);
    const configPath = join(__dirname, '..', 'config.json');

    const configContent = readFileSync(configPath, 'utf-8');
    const config = JSON.parse(configContent);

    // 不返回敏感信息(密码和API Key)
    if (config.email && config.email.smtpPass) {
      config.email.smtpPass = '***已配置***';
    }
    if (config.llm && config.llm.apiKey) {
      config.llm.apiKey = '***已配置***';
    }

    res.json({ success: true, data: config });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 更新配置
app.post('/api/config', async (req, res) => {
  try {
    const { writeFileSync, readFileSync } = await import('fs');
    const { join } = await import('path');
    const { fileURLToPath } = await import('url');
    const { dirname } = await import('path');

    const __filename = fileURLToPath(import.meta.url);
    const __dirname = dirname(__filename);
    const configPath = join(__dirname, '..', 'config.json');

    const newConfig = req.body;

    // 读取旧配置以保留敏感信息
    const oldConfigContent = readFileSync(configPath, 'utf-8');
    const oldConfig = JSON.parse(oldConfigContent);

    // 如果密码字段是占位符,保留原密码
    if (newConfig.email && newConfig.email.smtpPass === '***已配置***') {
      newConfig.email.smtpPass = oldConfig.email?.smtpPass || '';
    }

    // 如果 LLM API Key 是占位符,保留原 API Key
    if (newConfig.llm && newConfig.llm.apiKey === '***已配置***') {
      newConfig.llm.apiKey = oldConfig.llm?.apiKey || '';
    }

    // 保存配置
    writeFileSync(configPath, JSON.stringify(newConfig, null, 2), 'utf-8');

    // 重新加载定时任务(如果定时任务配置有变化)
    reloadScheduler();

    res.json({ success: true, message: '配置已保存并重新加载定时任务' });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// LLM 状态接口
app.get('/api/llm/status', async (req, res) => {
  try {
    const status = getLLMStatus();
    res.json({ success: true, data: status });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// LLM 连接测试接口
app.post('/api/llm/test', async (req, res) => {
  try {
    const result = await testLLMConnection();
    res.json({ success: result.success, data: result });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 获取定时任务状态
app.get('/api/scheduler/status', async (req, res) => {
  try {
    const status = getSchedulerStatus();
    res.json({ success: true, data: status });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 手动触发定时任务的API(用于测试)
app.post('/api/run-scheduled-task', async (req, res) => {
  try {
    console.log('手动触发定时任务...');
    // 在后台执行任务,不阻塞响应
    runTaskNow().catch(err => {
      console.error('定时任务执行失败:', err);
    });
    res.json({
      success: true,
      message: '定时任务已触发,正在后台执行...'
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

app.listen(PORT, () => {
  console.log(`Server running at http://localhost:${PORT}`);

  // 启动定时任务
  console.log('正在初始化定时任务...');
  initScheduler();
});
