/*
 * @Author: 赵丽婷
 * @Date: 2025-11-13 10:50:32
 * @LastEditors: 赵丽婷
 * @LastEditTime: 2026-01-08 14:29:39
 * @FilePath: \LinkMed\linkmed-vue3\src\stores\settings.ts
 * @Description:
 * Copyright (c) 2025 by 北京连心医疗科技有限公司, All Rights Reserved.
 */
import { defineStore } from "pinia";
import { ref } from "vue";
import {
  getKeyboardShortcuts,
  saveKeyboardShortcuts,
  getSearchSettings,
  saveSearchSettings,
} from "@/api/settings";

export const useSettingsStore = defineStore("settings", () => {
  type DeepSearchMode = "quick" | "standard" | "deep";
  // State
  // 深度检索配置
  const autoAcceptPlan = ref(true); // 自动继续请求
  const maxPlanIterations = ref(1); // 最大计划迭代次数
  const maxStepNum = ref(1); // 计划内容最大步骤数
  const maxSearchResults = ref(10); // 最终结果文献查询最大数量

  // 高级筛选
  const keyboardShortcuts = ref<Record<string, any>>({});
  const searchSettings = ref<Record<string, any>>({});
  const loading = ref(false);
  const error = ref<string | null>(null);

  // 知识库筛选
  const selectedKnowledgeBaseDirectory = ref<string | null>(null);
  const selectedKnowledgeBaseDirectoryName = ref<string | null>(null);
  const knowledgeBaseFileIds = ref<string[]>([]);
  const knowledgeBaseFiles = ref<any[]>([]);

  /** 高级筛选的内容 **/
  // 1.获取快捷键设置
  async function fetchKeyboardShortcuts() {
    try {
      loading.value = true;
      error.value = null;
      const { data } = await getKeyboardShortcuts();
      keyboardShortcuts.value = data || {};
      return data;
    } catch (err: any) {
      error.value = err?.message || "获取快捷键设置失败";
      console.error("获取快捷键设置失败:", err);
      throw err;
    } finally {
      loading.value = false;
    }
  }
  // 2.快捷键设置新
  async function updateKeyboardShortcuts(shortcutData: Record<string, any>) {
    try {
      loading.value = true;
      error.value = null;
      const { data } = await saveKeyboardShortcuts({ data: shortcutData });
      keyboardShortcuts.value = { ...keyboardShortcuts.value, ...shortcutData };
      return data;
    } catch (err: any) {
      error.value = err?.message || "保存快捷键设置失败";
      console.error("保存快捷键设置失败:", err);
      throw err;
    } finally {
      loading.value = false;
    }
  }

  function getShortcut(key: string, defaultValue?: string): string {
    return keyboardShortcuts.value[key] || defaultValue || "";
  }

  function setShortcut(key: string, value: string) {
    keyboardShortcuts.value[key] = value;
  }

  // 3.获取高级筛选设置
  async function fetchSearchSettings() {
    try {
      loading.value = true;
      error.value = null;
      const { data } = await getSearchSettings();
      searchSettings.value = data || {};
      // 同步更新深度检索配置到 store 的 ref 值
      if (data?.researchConfig) {
        autoAcceptPlan.value = data.researchConfig.autoAcceptPlan ?? true;
        maxPlanIterations.value = data.researchConfig.maxPlanIterations ?? 1;
        maxStepNum.value = data.researchConfig.maxStepNum ?? 1;
        maxSearchResults.value = data.researchConfig.maxSearchResults ?? 10;
      } else {
        // 如果没有配置，默认开启自动接受计划
        autoAcceptPlan.value = true;
      }

      return data;
    } catch (err: any) {
      error.value = err?.message || "获取检索设置失败";
      console.error("获取检索设置失败:", err);
      throw err;
    } finally {
      loading.value = false;
    }
  }

  // 4.更新高级筛选设置
  async function updateSearchSettings(settingsData: Record<string, any>) {
    try {
      loading.value = true;
      error.value = null;
      const { data } = await saveSearchSettings({ data: settingsData });
      searchSettings.value = { ...searchSettings.value, ...settingsData };
      return data;
    } catch (err: any) {
      error.value = err?.message || "保存检索设置失败";
      console.error("保存检索设置失败:", err);
      throw err;
    } finally {
      loading.value = false;
    }
  }
  // 5.保存当前检索设置到后端
  async function saveCurrentSearchSettings() {
    // 获取当前所有的检索设置，保留其他配置
    const currentSettings = { ...searchSettings.value };

    // 验证并过滤 literatureFilters 中的 selected 值
    // 只保留在 options 中存在的选项，并且只保存 key 和 selected 字段
    const literatureFilters = (
      searchSettings.value.literatureFilters || []
    ).map((filter: any) => {
      if (!filter.options || !Array.isArray(filter.options)) {
        // 如果没有 options，只返回 key 和 selected
        return {
          key: filter.key,
          selected: filter.selected || [],
        };
      }
      // 获取所有有效的 option id
      const validOptionIds = filter.options.map((opt: any) => opt.id);
      // 过滤掉不在 options 中的 selected 值
      const filteredSelected = (filter.selected || []).filter((id: string) =>
        validOptionIds.includes(id),
      );
      // 如果过滤后为空，且没有选择知识库，使用第一个 option 的 id 作为默认值（通常是第一个选项）
      const finalSelected =
        filteredSelected.length > 0
          ? filteredSelected
          : validOptionIds.length > 0 && !selectedKnowledgeBaseDirectory.value
            ? [validOptionIds[0]]
            : [];
      // 只返回 key 和 selected 字段，不包含 options 和 titleKey
      return {
        key: filter.key,
        selected: finalSelected,
      };
    });

    // 高级筛选
    const settingsData: Record<string, any> = {
      ...currentSettings,
      literatureDateRange: searchSettings.value.literatureDateRange, // 文献日期范围
      literatureQuickTime: searchSettings.value.literatureQuickTime, // 文献快捷时间
      literatureFilters, // 文献筛选配置（已验证和过滤）
    };

    // 定时任务
    const scheduledTask = searchSettings.value.scheduledTask;
    if (scheduledTask) {
      settingsData.scheduledTask = {
        taskList: scheduledTask.taskList,
        customRepeatOptions: scheduledTask.customRepeatOptions,
      };
    }

    // 检索配置
    settingsData.researchConfig = {
      autoAcceptPlan: autoAcceptPlan.value,
      maxPlanIterations: maxPlanIterations.value,
      maxStepNum: maxStepNum.value,
      maxSearchResults: maxSearchResults.value,
    };

    return await updateSearchSettings(settingsData);
  }

  // 获取文献日期范围
  function getLiteratureDateRange(): [string, string] | null {
    return searchSettings.value.literatureDateRange || null;
  }

  // 设置文献日期范围
  function setLiteratureDateRange(dateRange: [string, string] | null): void {
    searchSettings.value.literatureDateRange = dateRange;
  }

  // 获取文献快捷时间
  function getLiteratureQuickTime(): string | null {
    return searchSettings.value.literatureQuickTime || null;
  }

  // 设置文献快捷时间
  function setLiteratureQuickTime(quickTime: string | null): void {
    searchSettings.value.literatureQuickTime = quickTime;
  }

  // 获取文献筛选配置
  function getLiteratureFilters(): any[] {
    return searchSettings.value.literatureFilters || [];
  }

  // 设置文献筛选配置
  function setLiteratureFilters(filters: any[]): void {
    searchSettings.value.literatureFilters = filters;
  }

  // 获取深度检索速度模式
  function getDeepSearchMode(): DeepSearchMode | null {
    return searchSettings.value.deepSearchMode || null;
  }

  // 设置深度检索速度模式
  function setDeepSearchMode(mode: DeepSearchMode | null): void {
    searchSettings.value.deepSearchMode = mode;
  }

  // 设置知识库目录
  function setKnowledgeBaseDirectory(id: string | null, name: string | null) {
    selectedKnowledgeBaseDirectory.value = id;
    selectedKnowledgeBaseDirectoryName.value = name;
  }

  // 设置知识库文件列表
  function setKnowledgeBaseFiles(files: any[]) {
    knowledgeBaseFiles.value = files;
    knowledgeBaseFileIds.value = files.map((f) => f.id?.toString());
  }

  // 移除知识库文件
  function removeKnowledgeBaseFile(fileId: string) {
    knowledgeBaseFiles.value = knowledgeBaseFiles.value.filter(
      (f) => f.id?.toString() !== fileId,
    );
    knowledgeBaseFileIds.value = knowledgeBaseFileIds.value.filter(
      (id) => id !== fileId,
    );
  }

  /** 定时任务的内容 **/

  return {
    // state
    autoAcceptPlan,
    maxPlanIterations,
    maxStepNum,
    maxSearchResults,
    keyboardShortcuts,
    searchSettings,
    loading,
    error,
    selectedKnowledgeBaseDirectory,
    selectedKnowledgeBaseDirectoryName,
    knowledgeBaseFileIds,
    knowledgeBaseFiles,
    // actions
    fetchKeyboardShortcuts,
    updateKeyboardShortcuts,
    getShortcut,
    setShortcut,
    fetchSearchSettings,
    updateSearchSettings,
    getLiteratureDateRange,
    setLiteratureDateRange,
    getLiteratureQuickTime,
    setLiteratureQuickTime,
    getLiteratureFilters,
    setLiteratureFilters,
    getDeepSearchMode,
    setDeepSearchMode,
    saveCurrentSearchSettings,
    setKnowledgeBaseDirectory,
    setKnowledgeBaseFiles,
    removeKnowledgeBaseFile,
  };
});