const axios = require('axios');

class HotspotCollector {
  constructor() {
    this.sources = {
      weibo: 'https://weibo.com/ajax/side/hotSearch',
      zhihu: 'https://www.zhihu.com/api/v3/feed/topstory/hot-lists/total',
      twitter: 'https://api.twitter.com/1.1/trends/place.json?id=1'
    };
  }

  async collectWeibo() {
    try {
      const response = await axios.get(this.sources.weibo);
      const hotspots = response.data.data.realtime;
      return hotspots.map(item => ({
        platform: '微博',
        title: item.word,
        heat: item.num,
        category: item.category,
        url: `https://s.weibo.com/weibo?q=${encodeURIComponent(item.word)}`,
        timestamp: new Date().toISOString()
      }));
    } catch (error) {
      console.error('微博采集失败:', error.message);
      return [];
    }
  }

  async collectZhihu() {
    try {
      const response = await axios.get(this.sources.zhihu);
      const hotspots = response.data.data;
      return hotspots.map(item => ({
        platform: '知乎',
        title: item.target.title,
        heat: item.detail_text,
        url: item.target.url,
        timestamp: new Date().toISOString()
      }));
    } catch (error) {
      console.error('知乎采集失败:', error.message);
      return [];
    }
  }

  async collectAll() {
    const results = await Promise.allSettled([
      this.collectWeibo(),
      this.collectZhihu()
    ]);

    const allHotspots = results
      .filter(r => r.status === 'fulfilled')
      .flatMap(r => r.value);

    return allHotspots.sort((a, b) => b.heat - a.heat);
  }
}

module.exports = HotspotCollector;

const cron = require('node-cron');
const HotspotCollector = require('./agents/hotspot-collector');

const collector = new HotspotCollector();

// 每小时采集一次热点
cron.schedule('0 * * * *', async () => {
  console.log('开始采集热点...');
  const hotspots = await collector.collectAll();

  // 保存到飞书多维表格
  await saveToFeishu(hotspots);

  console.log(`采集完成，共获取 ${hotspots.length} 条热点`);
});

// 保存到飞书多维表格
async function saveToFeishu(hotspots) {
  const FeishuAPI = require('./services/feishu');
  const feishu = new FeishuAPI();

  await feishu.appendRows('你的多维表格Token', hotspots);
}

const OpenAI = require('openai');

class TopicRecommender {
  constructor() {
    this.openai = new OpenAI({
      apiKey: process.env.OPENAI_API_KEY
    });
  }

  async recommend(hotspots, userProfile) {
    const prompt = `
基于以下热点和账号画像，推荐3个最佳选题：

热点数据：
${JSON.stringify(hotspots.slice(0, 20), null, 2)}

账号画像：
${JSON.stringify(userProfile, null, 2)}

请分析并返回：
1. 推荐选题（标题）
2. 推荐理由（1-2句话）
3. 预期热度（高/中/低）
4. 竞争难度（高/中/低）
5. 建议发布时间

以 JSON 格式返回。
    `;

    const response = await this.openai.chat.completions.create({
      model: 'gpt-4',
      messages: [{ role: 'user', content: prompt }],
      temperature: 0.7
    });

    return JSON.parse(response.choices[0].message.content);
  }
}

module.exports = TopicRecommender;

class ContentGenerator {
  async generateOutline(topic) {
    const prompt = `
为以下主题生成详细的文章大纲：

主题：${topic}

要求：
1. 标题（3个候选）
2. 开头钩子
3. 正文结构（3-5个小标题）
4. 结尾行动号召
5. SEO 关键词建议
    `;

    // 调用 AI 生成大纲
    return this.callAI(prompt);
  }

  async expandSection(sectionTitle, brief) {
    const prompt = `
扩展以下章节内容：

章节标题：${sectionTitle}

简要说明：${brief}

要求：
- 字数：800-1200字
- 风格：轻松有趣
- 包含：案例、数据、金句
    `;

    return this.callAI(prompt);
  }
}

async function createFeishuDocument(topic, outline) {
  const FeishuAPI = require('./services/feishu');
  const feishu = new FeishuAPI();

  // 创建文档
  const doc = await feishu.createDocument({
    title: topic,
    content: this.formatOutline(outline)
  });

  return doc;
}

const { QQBot } = require('qq-boty');

class Publisher {
  constructor() {
    this.bot = new QQBot({
      appId: process.env.QQ_APP_ID,
      appKey: process.env.QQ_APP_KEY
    });
  }

  async publishToQQGroups(content, targetGroups) {
    for (const groupId of targetGroups) {
      try {
        await this.bot.sendMessageToGroup(groupId, content);
        console.log(`已发布到群 ${groupId}`);
      } catch (error) {
        console.error(`发布到群 ${groupId} 失败:`, error.message);
      }
    }
  }

  async publishToQZone(content) {
    // 发布到 QQ 空间
    await this.bot.publishToQZone(content);
  }
}

class MultiPlatformPublisher {
  async publish(content, platforms) {
    const tasks = platforms.map(platform => {
      switch (platform) {
        case 'qq':
          return this.publishToQQ(content);
        case 'weibo':
          return this.publishToWeibo(content);
        case 'wechat':
          return this.publishToWechat(content);
        default:
          console.log(`不支持的平台: ${platform}`);
      }
    });

    return Promise.allSettled(tasks);
  }
}

class AnalyticsLoop {
  async analyzePerformance(contentId) {
    // 获取各平台数据
    const stats = await this.getPlatformStats(contentId);

    // 分析最佳发布时间
    const bestTime = await this.findBestTime();

    // 分析最佳标题
    const bestTitle = await this.findBestTitle();

    // 更新推荐算法
    await this.updateRecommender({
      bestTime,
      bestTitle,
      stats
    });
  }
}

// 测试不同标题
const titleVariants = await generateTitleVariations(topic);
const testResults = await runABTest(titleVariants);

// 选择最佳标题
const bestTitle = testResults.sort((a, b) => b.ctr - a.ctr)[0];