llm-chat/backend/routes/conversations.js

const express = require('express');
const ConversationService = require('../services/ConversationService');

const router = express.Router();
const conversationService = new ConversationService();

/**
 * 创建新对话
 * POST /api/conversations
 */
router.post('/', async (req, res) => {
  try {
    const { title } = req.body;
    
    const conversation = await conversationService.createConversation(title);
    
    res.status(201).json({
      success: true,
      data: conversation,
      message: '对话创建成功'
    });
  } catch (error) {
    console.error('创建对话API错误:', error);
    res.status(500).json({
      success: false,
      error: error.message,
      message: '创建对话失败'
    });
  }
});

/**
 * 获取对话列表
 * GET /api/conversations?limit=50
 */
router.get('/', async (req, res) => {
  try {
    const limit = parseInt(req.query.limit) || 50;
    
    // 限制查询数量
    if (limit > 100) {
      return res.status(400).json({
        success: false,
        error: '查询数量不能超过100',
        message: '参数错误'
      });
    }
    
    const conversations = await conversationService.getConversations(limit);
    
    res.json({
      success: true,
      data: conversations,
      count: conversations.length,
      message: '获取对话列表成功'
    });
  } catch (error) {
    console.error('获取对话列表API错误:', error);
    res.status(500).json({
      success: false,
      error: error.message,
      message: '获取对话列表失败'
    });
  }
});

/**
 * 获取对话详情
 * GET /api/conversations/:id
 */
router.get('/:id', async (req, res) => {
  try {
    const { id } = req.params;
    
    if (!id || isNaN(id)) {
      return res.status(400).json({
        success: false,
        error: '无效的对话ID',
        message: '参数错误'
      });
    }
    
    const conversation = await conversationService.getConversationById(parseInt(id));
    
    if (!conversation) {
      return res.status(404).json({
        success: false,
        error: '对话不存在',
        message: '对话未找到'
      });
    }
    
    res.json({
      success: true,
      data: conversation,
      message: '获取对话详情成功'
    });
  } catch (error) {
    console.error('获取对话详情API错误:', error);
    
    if (error.message === '对话不存在') {
      res.status(404).json({
        success: false,
        error: error.message,
        message: '对话未找到'
      });
    } else {
      res.status(500).json({
        success: false,
        error: error.message,
        message: '获取对话详情失败'
      });
    }
  }
});

/**
 * 获取对话的消息列表
 * GET /api/conversations/:id/messages?limit=100&offset=0
 */
router.get('/:id/messages', async (req, res) => {
  try {
    const { id } = req.params;
    const limit = parseInt(req.query.limit) || 100;
    const offset = parseInt(req.query.offset) || 0;
    
    if (!id || isNaN(id)) {
      return res.status(400).json({
        success: false,
        error: '无效的对话ID',
        message: '参数错误'
      });
    }
    
    // 限制查询数量
    if (limit > 200) {
      return res.status(400).json({
        success: false,
        error: '查询数量不能超过200',
        message: '参数错误'
      });
    }
    
    const messages = await conversationService.getConversationMessages(
      parseInt(id), 
      limit, 
      offset
    );
    
    res.json({
      success: true,
      data: messages,
      count: messages.length,
      limit,
      offset,
      message: '获取消息列表成功'
    });
  } catch (error) {
    console.error('获取消息列表API错误:', error);
    
    if (error.message === '对话不存在') {
      res.status(404).json({
        success: false,
        error: error.message,
        message: '对话未找到'
      });
    } else {
      res.status(500).json({
        success: false,
        error: error.message,
        message: '获取消息列表失败'
      });
    }
  }
});

/**
 * 更新对话标题
 * PUT /api/conversations/:id
 */
router.put('/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const { title } = req.body;
    
    if (!id || isNaN(id)) {
      return res.status(400).json({
        success: false,
        error: '无效的对话ID',
        message: '参数错误'
      });
    }
    
    if (!title || title.trim().length === 0) {
      return res.status(400).json({
        success: false,
        error: '标题不能为空',
        message: '参数错误'
      });
    }
    
    if (title.length > 100) {
      return res.status(400).json({
        success: false,
        error: '标题长度不能超过100个字符',
        message: '参数错误'
      });
    }
    
    const conversation = await conversationService.updateConversationTitle(
      parseInt(id), 
      title.trim()
    );
    
    res.json({
      success: true,
      data: conversation,
      message: '更新对话标题成功'
    });
  } catch (error) {
    console.error('更新对话标题API错误:', error);
    
    if (error.message === '对话不存在') {
      res.status(404).json({
        success: false,
        error: error.message,
        message: '对话未找到'
      });
    } else {
      res.status(500).json({
        success: false,
        error: error.message,
        message: '更新对话标题失败'
      });
    }
  }
});

/**
 * 删除对话
 * DELETE /api/conversations/:id
 */
router.delete('/:id', async (req, res) => {
  try {
    const { id } = req.params;
    
    if (!id || isNaN(id)) {
      return res.status(400).json({
        success: false,
        error: '无效的对话ID',
        message: '参数错误'
      });
    }
    
    await conversationService.deleteConversation(parseInt(id));
    
    res.json({
      success: true,
      message: '删除对话成功'
    });
  } catch (error) {
    console.error('删除对话API错误:', error);
    
    if (error.message === '对话不存在') {
      res.status(404).json({
        success: false,
        error: error.message,
        message: '对话未找到'
      });
    } else {
      res.status(500).json({
        success: false,
        error: error.message,
        message: '删除对话失败'
      });
    }
  }
});

/**
 * 批量删除对话
 * DELETE /api/conversations
 */
router.delete('/', async (req, res) => {
  try {
    const { ids } = req.body;
    
    if (!Array.isArray(ids) || ids.length === 0) {
      return res.status(400).json({
        success: false,
        error: '请提供有效的对话ID列表',
        message: '参数错误'
      });
    }
    
    // 限制批量删除数量
    if (ids.length > 50) {
      return res.status(400).json({
        success: false,
        error: '单次最多删除50个对话',
        message: '参数错误'
      });
    }
    
    const deletedCount = await conversationService.deleteMultipleConversations(ids);
    
    res.json({
      success: true,
      data: { deletedCount },
      message: `成功删除${deletedCount}个对话`
    });
  } catch (error) {
    console.error('批量删除对话API错误:', error);
    res.status(500).json({
      success: false,
      error: error.message,
      message: '批量删除对话失败'
    });
  }
});

/**
 * 搜索对话
 * GET /api/conversations/search?q=关键词&limit=20
 */
router.get('/search', async (req, res) => {
  try {
    const { q: query, limit = 20 } = req.query;
    
    if (!query || query.trim().length === 0) {
      return res.status(400).json({
        success: false,
        error: '搜索关键词不能为空',
        message: '参数错误'
      });
    }
    
    if (query.length > 100) {
      return res.status(400).json({
        success: false,
        error: '搜索关键词长度不能超过100个字符',
        message: '参数错误'
      });
    }
    
    const conversations = await conversationService.searchConversations(
      query.trim(), 
      parseInt(limit)
    );
    
    res.json({
      success: true,
      data: conversations,
      count: conversations.length,
      query: query.trim(),
      message: '搜索对话成功'
    });
  } catch (error) {
    console.error('搜索对话API错误:', error);
    res.status(500).json({
      success: false,
      error: error.message,
      message: '搜索对话失败'
    });
  }
});

/**
 * 获取对话统计信息
 * GET /api/conversations/:id/stats
 */
router.get('/:id/stats', async (req, res) => {
  try {
    const { id } = req.params;
    
    if (!id || isNaN(id)) {
      return res.status(400).json({
        success: false,
        error: '无效的对话ID',
        message: '参数错误'
      });
    }
    
    const stats = await conversationService.getConversationStats(parseInt(id));
    
    res.json({
      success: true,
      data: stats,
      message: '获取对话统计成功'
    });
  } catch (error) {
    console.error('获取对话统计API错误:', error);
    
    if (error.message === '对话不存在') {
      res.status(404).json({
        success: false,
        error: error.message,
        message: '对话未找到'
      });
    } else {
      res.status(500).json({
        success: false,
        error: error.message,
        message: '获取对话统计失败'
      });
    }
  }
});

module.exports = router;