import { create } from 'zustand';
import { persist } from 'zustand/middleware';
import useChatBoxStore from '../Mid/ChatBoxSlice'; // ✅ 导入 ChatBoxStore (default export)

/**
 * 动态表格 Store
 * 管理角色卡的动态表格数据（键值对结构）
 */
const useTableStore = create(
  persist(
    (set, get) => ({
      // ==================== 状态 ====================
      
      // ✅ 动态表格数据（键值对结构）
      tableHeaders: [],      // 表头数组
      tableDefaults: {},     // 默认值对象
      
      // 当前角色和聊天
      currentRole: null,
      currentChat: null,
      
      // 加载状态
      isLoading: false,
      
      // 最后更新时间
      lastUpdated: null,

      // ==================== Actions ====================

      /**
       * 加载动态表格数据
       * @param {string} role - 角色名
       * @param {string} chat - 聊天名
       */
      loadTags: async (role, chat) => {
        if (!role) {
          set({ 
            tableHeaders: [], 
            tableDefaults: {},
            currentRole: null, 
            currentChat: null 
          });
          return;
        }

        set({ isLoading: true, currentRole: role, currentChat: chat });
        
        try {
          let tableHeaders = [];
          let tableDefaults = {};

          // ✅ 优先级1：从聊天文件读取（如果聊天中有动态表格数据）
          if (chat) {
            console.log('[TableStore] 尝试从聊天文件读取动态表格数据');
            const response = await fetch(`/api/chat/${encodeURIComponent(role)}/${encodeURIComponent(chat)}`);
            
            if (response.ok) {
              const chatData = await response.json();
              const header = chatData.header || {};
              
              // 读取聊天中的动态表格数据
              tableHeaders = header.tableHeaders || [];
              tableDefaults = header.tableDefaults || {};
              
              if (tableHeaders.length > 0) {
                set({ 
                  tableHeaders,
                  tableDefaults,
                  lastUpdated: Date.now(),
                  isLoading: false
                });
                console.log(`[TableStore] ✅ 已从聊天加载动态表格: ${tableHeaders.length} 个字段`);
                return;
              }
            }
          }

          // ✅ 优先级2：从角色卡读取（降级）
          console.log('[TableStore] 聊天中无动态表格，从角色卡读取');
          const charResponse = await fetch(`/api/characters/${encodeURIComponent(role)}`);
          
          if (!charResponse.ok) throw new Error('获取角色卡失败');
          
          const charData = await charResponse.json();
          tableHeaders = charData.tableHeaders || [];
          tableDefaults = charData.tableDefaults || {};
          
          set({ 
            tableHeaders,
            tableDefaults,
            lastUpdated: Date.now(),
            isLoading: false
          });
          console.log(`[TableStore] ✅ 已从角色卡加载动态表格: ${tableHeaders.length} 个字段`);
          
        } catch (error) {
          console.error('[TableStore] 获取动态表格数据失败:', error);
          set({ 
            tableHeaders: [], 
            tableDefaults: {},
            isLoading: false 
          });
        }
      },

      /**
       * 清空状态
       */
      clear: () => {
        set({ 
          tableHeaders: [],
          tableDefaults: {},
          currentRole: null,
          currentChat: null,
          isLoading: false,
          lastUpdated: null
        });
      },

      /**
       * 强制刷新（立即从后端重新加载）
       */
      refresh: async () => {
        const { currentRole, currentChat } = get();
        if (!currentRole) return;
        
        await get().loadTags(currentRole, currentChat);
      },

      /**
       * 更新动态表格数据并保存到后端
       * @param {Object} updates - 要更新的字段 { tableHeaders?, tableDefaults? }
       */
      updateTableData: async (updates) => {
        const { currentRole } = get();
        
        if (!currentRole) {
          console.warn('[TableStore] 无法保存：缺少角色信息');
          return;
        }

        // 乐观更新：先更新本地状态
        set((state) => ({
          tableHeaders: updates.tableHeaders ?? state.tableHeaders,
          tableDefaults: updates.tableDefaults ?? state.tableDefaults,
          lastUpdated: Date.now()
        }));

        // 异步保存到后端
        try {
          const response = await fetch(`/api/characters/${encodeURIComponent(currentRole)}`, {
            method: 'PUT',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(updates)
          });

          if (!response.ok) {
            throw new Error('保存失败');
          }

          console.log('[TableStore] ✅ 动态表格数据已保存到后端');
        } catch (error) {
          console.error('[TableStore] 保存动态表格数据失败:', error);
          alert('保存失败: ' + error.message);
          
          // 如果保存失败，重新加载数据以恢复状态
          await get().refresh();
        }
      }
    }),
    {
      name: 'table-storage', // localStorage key
      partialize: (state) => ({ 
        tableHeaders: state.tableHeaders,
        tableDefaults: state.tableDefaults,
        currentRole: state.currentRole,
        currentChat: state.currentChat,
        lastUpdated: state.lastUpdated
      })
    }
  )
);

// ✅ 监听 ChatBoxStore 的变化，自动更新 TableStore 的 currentRole 和 currentChat
useChatBoxStore.subscribe(
  (state) => ({ role: state.currentRole, chat: state.currentChat }),
  ({ role, chat }, prevState) => {
    const tableStore = useTableStore.getState();
    
    // 只有当角色或聊天真正变化时才更新
    if (tableStore.currentRole !== role || tableStore.currentChat !== chat) {
      const changeType = tableStore.currentRole !== role ? '角色切换' : '聊天切换';
      console.log(`[TableStore] 🔄 检测到${changeType}:`, { 
        from: { role: tableStore.currentRole, chat: tableStore.currentChat },
        to: { role, chat }
      });
      
      useTableStore.setState({ 
        currentRole: role, 
        currentChat: chat 
      });
      
      // 自动加载动态表格数据
      if (role) {
        console.log('[TableStore] 📊 开始加载动态表格数据...');
        useTableStore.getState().loadTags(role, chat);
      } else {
        console.log('[TableStore] ⚠️ 角色为空，清空动态表格');
        useTableStore.getState().clear();
      }
    }
  }
);

export default useTableStore;
