/**
 * 推荐API Service
 * 处理类案推荐和法条推荐相关接口
 * 接口前缀: /api/v1/case/similarity 和 /api/v1/law/similarity
 */

import { request } from './request';

class RecommendAPIService {
  /**
   * 类案推荐查询
   * POST /api/v1/case/similarity
   * @param {Object} data - 请求数据
   * @param {string} data.caseId - 案件ID
   * @param {string} data.caseContent - 案件内容
   * @param {number} data.topK - 返回相似案例数量
   * @param {Object} data.filters - 筛选条件
   * @returns {Promise} 相似案例推荐结果
   */
  static getSimilarCases(data = {}) {
    return request.post('/api/v1/case/similarity', data);
  }

  /**
   * 法条推荐查询
   * POST /api/v1/law/similarity
   * @param {Object} data - 请求数据
   * @param {string} data.caseId - 案件ID
   * @param {string} data.caseContent - 案件内容
   * @param {number} data.topK - 返回相似法条数量
   * @param {Object} data.filters - 筛选条件
   * @returns {Promise} 相似法条推荐结果
   */
  static getSimilarLaws(data = {}) {
    return request.post('/api/v1/law/similarity', data);
  }

  /**
   * 综合推荐（同时获取类案和法条推荐）
   * @param {Object} params - 推荐参数
   * @param {string} params.caseId - 案件ID
   * @param {string} params.caseContent - 案件内容
   * @param {number} params.caseTopK - 类案推荐数量
   * @param {number} params.lawTopK - 法条推荐数量
   * @param {Object} params.filters - 通用筛选条件
   * @returns {Promise} 综合推荐结果
   */
  static async getComprehensiveRecommendations(params = {}) {
    const {
      caseId,
      caseContent,
      caseTopK = 5,
      lawTopK = 10,
      filters = {}
    } = params;

    try {
      // 并行获取类案推荐和法条推荐
      const [casesResult, lawsResult] = await Promise.all([
        this.getSimilarCases({
          caseId,
          caseContent,
          topK: caseTopK,
          filters
        }),
        this.getSimilarLaws({
          caseId,
          caseContent,
          topK: lawTopK,
          filters
        })
      ]);

      return {
        cases: casesResult.data || [],
        laws: lawsResult.data || []
      };
    } catch (error) {
      return Promise.reject(error);
    }
  }

  /**
   * 基于案件特征的智能推荐
   * @param {Object} caseFeatures - 案件特征对象
   * @param {string} caseFeatures.disputeType - 纠纷类型
   * @param {string} caseFeatures.amount - 涉及金额
   * @param {string} caseFeatures.region - 地区
   * @param {string} caseFeatures.industry - 行业
   * @param {Array} caseFeatures.keywords - 关键词数组
   * @param {Object} options - 推荐选项
   * @returns {Promise} 智能推荐结果
   */
  static getSmartRecommendations(caseFeatures = {}, options = {}) {
    const {
      caseTopK = 5,
      lawTopK = 10,
      includeCourtCases = true,
      includeMediationCases = true
    } = options;

    // 构造推荐请求数据
    const requestData = {
      caseContent: this._buildCaseContent(caseFeatures),
      topK: Math.max(caseTopK, lawTopK),
      filters: {
        disputeType: caseFeatures.disputeType,
        region: caseFeatures.region,
        industry: caseFeatures.industry
      }
    };

    return this.getComprehensiveRecommendations({
      ...requestData,
      caseTopK,
      lawTopK
    });
  }

  /**
   * 构建案件内容字符串（用于推荐算法）
   * @private
   * @param {Object} features - 案件特征
   * @returns {string} 格式化的案件内容
   */
  static _buildCaseContent(features) {
    const parts = [];
    
    if (features.disputeType) {
      parts.push(`纠纷类型：${features.disputeType}`);
    }
    
    if (features.amount) {
      parts.push(`涉及金额：${features.amount}`);
    }
    
    if (features.region) {
      parts.push(`地区：${features.region}`);
    }
    
    if (features.industry) {
      parts.push(`行业：${features.industry}`);
    }
    
    if (features.keywords && features.keywords.length > 0) {
      parts.push(`关键词：${features.keywords.join('、')}`);
    }
    
    if (features.description) {
      parts.push(`案件描述：${features.description}`);
    }

    return parts.join('\n');
  }

  /**
   * 获取推荐历史记录
   * @param {string} userId - 用户ID
   * @param {number} page - 页码
   * @param {number} size - 每页数量
   * @returns {Promise} 推荐历史
   */
  static getRecommendationHistory(userId, page = 1, size = 10) {
    return request.get('/api/v1/recommend/history', {
      userId,
      page,
      size
    });
  }

  /**
   * 反馈推荐结果质量
   * @param {Object} feedback - 反馈数据
   * @param {string} feedback.recommendationId - 推荐ID
   * @param {number} feedback.rating - 评分(1-5)
   * @param {string} feedback.comment - 评论
   * @returns {Promise} 反馈结果
   */
  static submitFeedback(feedback = {}) {
    return request.post('/api/v1/recommend/feedback', feedback);
  }
}

export default RecommendAPIService;