import request from "@/utils/request";
import { getToken } from '@/utils/auth';

/**
 * 知识库管理接口
 * 传参规范:
 * - GET请求: 使用 params
 * - POST请求: 使用 data
 * - DELETE请求: 使用 data
 * - 流式请求: 使用 Fetch API
 */

// ==================== 知识库CRUD接口 ====================

/**
 * 查询知识库列表
 * @param {Object} query - 查询参数
 * @param {number} query.current - 当前页码(必填)
 * @param {number} query.size - 每页条数(必填)
 * @param {string} [query.title] - 知识标题(可选,模糊搜索)
 * @param {string} [query.type] - 知识类型(可选,精确匹配)
 * @returns {Promise}
 */
export function listKnowledgeBase(query) {
  return request({
    url: "/knowledgeBase/getList",
    method: "get",
    params: query,  // GET请求使用params
  });
}

/**
 * 新增知识库
 * @param {Object} data - 知识库数据
 * @param {string} data.title - 知识标题(必填)
 * @param {string} data.type - 知识类型(必填)
 * @param {string} [data.scenario] - 适用场景(可选)
 * @param {string} [data.efficiency] - 解决效率(可选)
 * @param {string} data.problem - 问题描述(必填)
 * @param {string} data.solution - 解决方案(必填)
 * @param {string} [data.keyPoints] - 关键要点(可选)
 * @param {string} [data.creator] - 创建人(可选)
 * @param {number} [data.usageCount=0] - 使用次数(可选)
 * @returns {Promise}
 */
export function addKnowledgeBase(data) {
  return request({
    url: "/knowledgeBase/add",
    method: "post",
    data: data,  // POST请求使用data
  });
}

/**
 * 修改知识库
 * @param {Object} data - 知识库数据
 * @param {number} data.id - 知识库ID(必填)
 * @param {string} data.title - 知识标题(必填)
 * @param {string} data.type - 知识类型(必填)
 * @returns {Promise}
 */
export function updateKnowledgeBase(data) {
  return request({
    url: "/knowledgeBase/update",
    method: "post",
    data: data,  // POST请求使用data
  });
}

/**
 * 删除知识库(支持批量删除)
 * @param {number[]} ids - 知识库ID数组
 * @returns {Promise}
 */
export function delKnowledgeBase(ids) {
  return request({
    url: "/knowledgeBase/delete",
    method: "delete",
    data: ids,  // DELETE请求使用data传递数组
  });
}

// ==================== 文件管理接口 ====================

/**
 * 查询知识库文件向量化状态
 * @param {number} knowledgeBaseId - 知识库ID
 * @returns {Promise} 返回文件列表及向量化状态
 */
export function getVectorStatus(knowledgeBaseId) {
  return request({
    url: `/knowledgeBase/vector/status/${knowledgeBaseId}`,
    method: "get",
  });
}

/**
 * 保存知识库文件关联(触发向量化)
 * @param {Object} data - 文件关联数据
 * @param {number} data.knowledgeBaseId - 知识库ID(必填)
 * @param {number[]} data.storageBlobIds - 文件blob ID数组(必填)
 * @returns {Promise}
 */
export function saveKnowledgeBaseFiles(data) {
  return request({
    url: "/knowledgeBase/file/save",
    method: "post",
    data: data,  // POST请求使用data
  });
}

/**
 * 删除知识库文件
 * @param {number[]} ids - 向量记录ID数组
 * @returns {Promise}
 */
export function deleteKnowledgeBaseFile(ids) {
  return request({
    url: "/knowledgeBase/file/delete",
    method: "delete",
    data: ids,  // DELETE请求使用data传递数组
  });
}

/**
 * 重新向量化文件
 * @param {number} vectorId - 向量记录ID
 * @returns {Promise}
 */
export function reprocessVector(vectorId) {
  return request({
    url: `/knowledgeBase/vector/reprocess/${vectorId}`,
    method: "post",
  });
}

// ==================== 知识问答接口 ====================

/**
 * 知识库问答(流式)
 * 后端接口: POST /ai/knowledge/chat
 * 响应类型: text/stream;charset=utf-8 (Spring Flux<String>)
 *
 * @param {Object} data - 问答参数
 * @param {number} data.knowledgeBaseId - 知识库ID(必填)
 * @param {string} data.memoryId - 会话ID(必填,用于保持上下文)
 * @param {string} data.question - 用户问题(必填)
 * @returns {Promise<Response>} 返回Fetch Response对象
 */
export function knowledgeChat(data) {
  const token = getToken();
  return fetch(import.meta.env.VITE_APP_BASE_API + '/ai/knowledge/chat', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer ' + token
    },
    body: JSON.stringify(data)
  });
}

/**
 * 查询知识库问答历史
 * @param {string} memoryId - 会话ID
 * @returns {Promise}
 */
export function getKnowledgeHistory(memoryId) {
  return request({
    url: `/ai/knowledge/history/${memoryId}`,
    method: "get",
  });
}