import { defineStore } from 'pinia'
import { ref, computed, watch, nextTick } from 'vue'
import type { ChatMessage, ChatSession } from '@/types'
import { stompWebSocketService, type WebSocketMessage, type ConnectionStatus } from '@/services/stomp-websocket'
import { useAuthStore } from './auth'
import { chatApi } from '@/services/chat'
import MessageService, { messageApi } from '@/services/message'

// 聊天消息类型
export interface ChatMessage {
  id: string
  content: string
  type: 'user' | 'ai'
  timestamp: string
  conversationId?: string
  status?: 'sending' | 'sent' | 'delivered' | 'read' | 'failed'
  error?: string
}

// 聊天会话类型
export interface ChatSession {
  id: string
  title: string
  userId?: string
  createTime: string
  updateTime: string
  messageCount: number
}

// 消息队列项
interface QueuedMessage {
  message: ChatMessage
  timestamp: number
}

export const useChatStore = defineStore('chat', () => {
  const authStore = useAuthStore()

  // 聊天状态
  const currentSession = ref<ChatSession | null>(null)
  const messages = ref<ChatMessage[]>([])
  const sessions = ref<ChatSession[]>([])
  const isTyping = ref(false)
  const isConnected = ref(false)
  const connectionStatus = ref<ConnectionStatus>('DISCONNECTED')
  const wsConnected = ref(false)

  // 消息队列和处理状态
  const messageQueue = ref<QueuedMessage[]>([])
  const isProcessingQueue = ref(false)
  const queueProcessingInterval = ref<number | null>(null)

  // 计算属性
  const currentMessages = computed(() => {
    if (!currentSession.value) return []
    return messages.value.filter(msg =>
      msg.conversationId === currentSession.value?.id ||
      msg.sessionId === currentSession.value?.id
    )
  })

  // 已处理的消息ID集合 - 用于防止重复处理
  const processedMessageIds = ref<Set<string>>(new Set())

  // 处理消息队列 - 批量处理消息以避免竞态条件
  const processMessageQueue = async () => {
    if (isProcessingQueue.value || messageQueue.value.length === 0) {
      return
    }

    isProcessingQueue.value = true
    try {
      // 一次性取出所有待处理消息
      const batch = messageQueue.value.splice(0, messageQueue.value.length)

      // 过滤掉已存在的消息（基于ID去重）
      const newMessages = batch
        .map(item => item.message)
        .filter(msg => {
          // 检查是否已存在于当前消息列表中
          const exists = messages.value.some(m => m.id === msg.id)
          if (exists) {
            console.log(`⚠️ 消息已存在，跳过: ${msg.id}`)
          }
          return !exists
        })

      if (newMessages.length > 0) {
        messages.value.push(...newMessages)
        console.log(`✅ 消息队列处理完成，添加了 ${newMessages.length} 条消息，当前总数: ${messages.value.length}`)
      } else {
        console.log(`⏭️ 队列中的消息都已存在，无需添加`)
      }
    } finally {
      isProcessingQueue.value = false
    }
  }

  // 将消息加入队列而不是直接添加
  const queueMessage = (message: ChatMessage) => {
    // 先检查是否已处理过该消息ID
    if (processedMessageIds.value.has(message.id)) {
      console.log(`⚠️ 消息已处理过，跳过队列: ${message.id}`)
      return
    }

    // 标记消息ID为已处理
    processedMessageIds.value.add(message.id)

    messageQueue.value.push({
      message,
      timestamp: Date.now()
    })
    console.log(`📝 消息已加入队列，队列长度: ${messageQueue.value.length}`)
  }

  // 添加消息 - 现在返回消息但不直接添加到数组
  const addMessage = (message: Omit<ChatMessage, 'id' | 'timestamp'> & { id?: string, timestamp?: string }) => {
    const newMessage: ChatMessage = {
      ...message,
      id: message.id || Date.now().toString(),  // 优先使用传入的ID
      timestamp: message.timestamp || new Date().toISOString(),  // 优先使用传入的时间戳
      status: message.type === 'user' ? 'sending' : 'sent'
    }
    // 将消息加入队列而不是直接添加
    queueMessage(newMessage)
    return newMessage
  }

  // 更新消息状态
  const updateMessageStatus = (messageId: string, status: ChatMessage['status'], error?: string) => {
    const message = messages.value.find(m => m.id === messageId)
    if (message) {
      message.status = status
      if (error) {
        message.error = error
      }
    }
  }

  // 发送消息：仅通过WebSocket推送，后端统一处理保存
  const sendMessage = async (content: string) => {
    if (!wsConnected.value) {
      console.error('WebSocket未连接，无法发送消息')
      addMessage({
        content: '连接已断开，请刷新页面重试。',
        type: 'ai',
        sessionId: currentSession.value?.id
      })
      return
    }

    // 添加用户消息到前端显示
    const userMessage = addMessage({
      content,
      type: 'user',
      sessionId: currentSession.value?.id
    })

    try {
      // 仅通过STOMP WebSocket推送，后端会统一处理消息保存
      stompWebSocketService.sendChatMessage(content, currentSession.value?.id)

      // 更新消息状态为已发送
      updateMessageStatus(userMessage.id, 'sent')

      // 注意：移除了重复的REST API调用，避免重复保存消息
      // 后端WebSocket处理器会统一保存用户消息到数据库

    } catch (error) {
      console.error('消息发送失败:', error)

      // 更新消息状态为失败
      updateMessageStatus(userMessage.id, 'failed', '发送失败')

      addMessage({
        content: '抱歉，消息发送失败，请稍后重试。',
        type: 'ai',
        sessionId: currentSession.value?.id
      })
    }
    return userMessage
  }

  // 创建会话：同步后端
  const createSession = async (title?: string) => {
    let newSession: ChatSession
    const currentUserId = authStore.userInfo?.id || authStore.userId

    console.log('📝 创建会话，当前用户ID:', currentUserId)

    if (currentUserId) {
      newSession = await chatApi.createSession(currentUserId, title || `对话${sessions.value.length + 1}`)
      console.log('✅ 已为登录用户创建会话:', newSession)
    } else {
      newSession = {
        id: Date.now().toString(),
        title: title || `对话${sessions.value.length + 1}`,
        createTime: new Date().toISOString(),
        updateTime: new Date().toISOString(),
        messageCount: 0
      }
      console.log('⚠️ 为访客创建本地会话:', newSession)
    }
    sessions.value.unshift(newSession)
    currentSession.value = newSession
    messages.value = []

    // 如果WebSocket已连接，设置新的会话ID
    if (wsConnected.value) {
      stompWebSocketService.setConversationId(newSession.id)
    }

    return newSession
  }

  // 切换会话：加载消息
  const switchSession = async (sessionId: string) => {
    const session = sessions.value.find(s => s.id === sessionId)
    if (session) {
      currentSession.value = session
      await loadSessionMessages(sessionId)

      // 如果WebSocket已连接，更新会话ID
      if (wsConnected.value) {
        stompWebSocketService.setConversationId(sessionId)
      }
    }
  }

  // 加载会话消息：使用现有的消息API
  const loadSessionMessages = async (sessionId: string) => {
    console.log('📨 开始加载会话消息:', sessionId)
    console.log('💡 注意：后端没有按会话ID获取消息的接口，使用最近消息代替')

    try {
      // 由于后端没有按会话ID获取消息的接口，我们使用最近消息
      // 这是一个临时方案，理想情况下应该在后端添加相应接口
      console.log('📨 使用最近消息API代替会话消息...')
      const response = await messageApi.getRecentMessages(50)
      console.log('📨 最近消息API响应:', response)

      // 处理API响应数据结构
      const messageList = response.data || response || []
      console.log('📨 提取的消息列表:', messageList)

      const chatMessages = MessageService.convertToChatMessages(messageList)
      console.log('📨 转换后的聊天消息:', chatMessages)

      // 使用优化的排序和去重方法
      const sortedMessages = MessageService.sortAndDeduplicateMessages(chatMessages)

      // 如果需要过滤特定会话的消息，可以在这里添加过滤逻辑
      // const sessionMessages = sortedMessages.filter(msg => msg.sessionId === sessionId)

      // 清空并重新设置已处理消息ID集合
      processedMessageIds.value.clear()
      sortedMessages.forEach(msg => processedMessageIds.value.add(msg.id))

      messages.value = sortedMessages
      console.log('📨 会话消息加载完成，消息数量:', messages.value.length, '已处理ID数量:', processedMessageIds.value.size)

    } catch (error) {
      console.error('❌ 加载会话消息失败:', error)
      messages.value = []
      processedMessageIds.value.clear()
    }
  }

  // 删除会话：同步后端
  const deleteSession = async (sessionId: string) => {
    try {
      await chatApi.deleteSession(sessionId)
      const index = sessions.value.findIndex(s => s.id === sessionId)
      if (index > -1) {
        sessions.value.splice(index, 1)
        if (currentSession.value?.id === sessionId) {
          currentSession.value = sessions.value[0] || null
          if (currentSession.value) {
            await loadSessionMessages(currentSession.value.id)
          } else {
            messages.value = []
          }
        }
      }
    } catch (error) {
      console.error('删除会话失败:', error)
    }
  }

  // 清空消息
  const clearMessages = () => {
    messages.value = []
    // 同时清空已处理消息ID集合，避免后续加载时被错误过滤
    processedMessageIds.value.clear()
    console.log('✅ 消息和已处理ID集合已清空')
  }

  // 搜索消息：支持本地搜索和远程搜索
  const searchMessages = async (keyword: string) => {
    console.log('🔍 开始搜索消息:', { keyword })

    if (!keyword.trim()) {
      console.log('🔍 搜索关键词为空，返回空结果')
      return []
    }

    try {
      // 先尝试远程搜索
      console.log('🔍 尝试远程搜索...')
      const response = await messageApi.searchUserMessages(keyword, 50)
      console.log('🔍 远程搜索API响应:', response)

      // 处理API响应数据结构
      const searchResults = response.data || response || []
      console.log('🔍 提取的搜索结果:', searchResults)

      const chatMessages = MessageService.convertToChatMessages(searchResults)
      console.log('🔍 转换后的搜索结果:', chatMessages)

      return chatMessages
    } catch (error) {
      console.error('❌ 远程搜索失败，使用本地搜索:', error)
      // 如果远程搜索失败，使用本地搜索
      const localResults = messages.value.filter(message =>
        message.content.toLowerCase().includes(keyword.toLowerCase())
      )
      console.log('🔍 本地搜索结果:', localResults)
      return localResults
    }
  }

  // 加载用户历史消息
  const loadUserMessages = async (page: number = 1, size: number = 20) => {
    console.log('📨 开始加载用户历史消息:', { page, size })
    try {
      const response = await messageApi.getUserMessages(page, size)
      console.log('📨 API响应原始数据:', response)

      // 处理API响应数据结构
      const result = response.data || response
      const messageList = result.records || result.list || []

      console.log('📨 提取的消息列表:', messageList)

      const chatMessages = MessageService.convertToChatMessages(messageList)
      console.log('📨 转换后的聊天消息:', chatMessages)

      if (page === 1) {
        // 第一页，替换现有消息
        const sortedMessages = MessageService.sortAndDeduplicateMessages(chatMessages)
        messages.value = sortedMessages
        console.log('📨 第一页数据已加载，消息总数:', messages.value.length)
      } else {
        // 后续页，追加到现有消息并重新排序
        const combinedMessages = [...messages.value, ...chatMessages]
        const sortedMessages = MessageService.sortAndDeduplicateMessages(combinedMessages)
        messages.value = sortedMessages
        console.log('📨 追加数据已加载，消息总数:', messages.value.length)
      }

      const returnData = {
        list: messageList,
        total: result.total || 0,
        page: result.current || page,
        size: result.size || size,
        pages: result.pages || 0
      }

      console.log('📨 返回的分页数据:', returnData)
      return returnData
    } catch (error) {
      console.error('❌ 加载用户历史消息失败:', error)
      return { list: [], total: 0, page, size, pages: 0 }
    }
  }

  // 加载最近消息
  const loadRecentMessages = async (limit: number = 10) => {
    console.log('📝 开始加载最近消息:', { limit })
    try {
      // 直接使用messageApi，避免多层封装
      const response = await messageApi.getRecentMessages(limit)
      console.log('📝 最近消息API响应:', response)

      // 处理响应数据 - 根据您的修改，messageApi现在返回 response.data || response
      let messageList = []
      if (Array.isArray(response)) {
        messageList = response
        console.log('📝 直接使用响应数组，消息数量:', messageList.length)
      } else if (response && response.data && Array.isArray(response.data)) {
        messageList = response.data
        console.log('📝 使用response.data，消息数量:', messageList.length)
      } else {
        console.warn('📝 无法识别的响应格式:', response)
        messageList = []
      }

      console.log('📝 提取的最近消息列表:', messageList)
      console.log('📝 第一条消息示例:', messageList[0])

      if (messageList.length === 0) {
        console.log('📝 没有找到最近消息')
        messages.value = []
        return []
      }

      const chatMessages = MessageService.convertToChatMessages(messageList)
      console.log('📝 转换后的最近消息:', chatMessages)

      // 详细检查每条消息的转换结果
      chatMessages.forEach((msg, index) => {
        console.log(`📝 消息${index + 1}:`, {
          id: msg.id,
          content: msg.content.substring(0, 20) + '...',
          sender: msg.sender,
          type: msg.type,
          role: msg.role,
          timestamp: msg.timestamp
        })
      })

      // 使用优化的排序和去重方法
      const sortedMessages = MessageService.sortAndDeduplicateMessages(chatMessages)

      // 清空并重新设置已处理消息ID集合
      processedMessageIds.value.clear()
      sortedMessages.forEach(msg => processedMessageIds.value.add(msg.id))

      // 直接设置消息数组（初始加载时不使用队列）
      messages.value = sortedMessages
      console.log('📝 最近消息已加载并排序，消息总数:', messages.value.length, '已处理ID数量:', processedMessageIds.value.size)

      return chatMessages
    } catch (error) {
      console.error('❌ 加载最近消息失败:', error)
      messages.value = []
      processedMessageIds.value.clear()
      return []
    }
  }

  // 添加AI回复消息（使用队列处理）
  const addAiReplyMessages = async (wsMessage: WebSocketMessage) => {
    // 停止输入状态
    isTyping.value = false

    // 使用后端提供的messageId，确保去重能正常工作
    const messageId = wsMessage.messageId || Date.now().toString()

    // 检查是否已处理过该消息（基于后端messageId去重）
    if (processedMessageIds.value.has(messageId)) {
      console.log(`⚠️ AI消息已处理过，跳过: ${messageId}`)
      return
    }

    // 添加AI消息到队列，使用后端的messageId
    const aiMessage = addMessage({
      id: messageId,
      content: wsMessage.content.trim(),
      type: 'ai',
      conversationId: wsMessage.conversationId || currentSession.value?.id,
      timestamp: wsMessage.createTime || new Date().toISOString()
    })

    console.log('✅ AI消息已加入队列，消息ID:', aiMessage.id, '(后端ID:', wsMessage.messageId, ')')

    // 立即处理队列
    await processMessageQueue()
  }

  // WebSocket消息处理 - 使用队列处理所有消息
  let handleWebSocketMessage = async (wsMessage: WebSocketMessage) => {
    console.log('收到WebSocket消息:', wsMessage.type, wsMessage.senderType, '消息ID:', wsMessage.messageId)

    switch (wsMessage.type) {
      case 'TEXT':
        if (wsMessage.senderType === 'AI') {
          // AI回复消息 - 传递完整的wsMessage以获取后端messageId
          await addAiReplyMessages(wsMessage)
        }
        break

      case 'AI_THINKING':
        // AI正在思考 - 不修改响应式数据，避免竞态
        console.log('⏳ AI正在思考中...')
        break

      case 'CONNECTION':
        // 连接状态消息
        console.log('WebSocket连接状态:', wsMessage.content)
        break

      case 'ERROR':
        // 错误消息 - 加入队列处理，使用后端messageId
        addMessage({
          id: wsMessage.messageId || Date.now().toString(),
          content: wsMessage.content,
          type: 'ai',
          sessionId: currentSession.value?.id
        })
        await processMessageQueue()
        break

      case 'SYSTEM':
        // 系统消息 - 加入队列处理，使用后端messageId
        addMessage({
          id: wsMessage.messageId || Date.now().toString(),
          content: wsMessage.content,
          type: 'ai',
          sessionId: currentSession.value?.id
        })
        await processMessageQueue()
        break

      default:
        console.log('未处理的消息类型:', wsMessage.type)
    }
  }

  // WebSocket连接管理
  const connectWebSocket = async () => {
    try {
      // 获取当前登录用户的ID
      const userId = authStore.userInfo?.id || authStore.userId || undefined
      console.log('🔌 准备连接WebSocket，当前用户:', {
        userId,
        userInfo: authStore.userInfo,
        isLoggedIn: authStore.isLoggedIn,
        accessToken: authStore.accessToken ? '已有token' : '无token'
      })

      await stompWebSocketService.connect(userId, {
        onMessage: handleWebSocketMessage,
        onConnect: () => {
          console.log('WebSocket连接成功')
          wsConnected.value = true
          isConnected.value = true

          // 启动消息队列处理器 - 每50ms处理一次队列
          if (queueProcessingInterval.value === null) {
            queueProcessingInterval.value = window.setInterval(() => {
              processMessageQueue()
            }, 50)
            console.log('✅ 消息队列处理器已启动')
          }

          // 设置会话ID
          if (currentSession.value?.id) {
            stompWebSocketService.setConversationId(currentSession.value.id)
          }
        },
        onDisconnect: () => {
          console.log('WebSocket连接断开')
          wsConnected.value = false
          isConnected.value = false

          // 停止消息队列处理器
          if (queueProcessingInterval.value !== null) {
            clearInterval(queueProcessingInterval.value)
            queueProcessingInterval.value = null
            console.log('✅ 消息队列处理器已停止')
          }
        },
        onError: (error) => {
          console.error('WebSocket错误:', error)
          wsConnected.value = false
          isConnected.value = false

          // 显示用户友好的错误信息
          if (error.userMessage) {
            addMessage({
              content: error.userMessage,
              type: 'ai',
              sessionId: currentSession.value?.id
            })
            processMessageQueue()
          }
        },
        onStatusChange: (status) => {
          connectionStatus.value = status
          isConnected.value = status === 'CONNECTED'
        }
      })
    } catch (error) {
      console.error('WebSocket连接失败:', error)
      wsConnected.value = false
      isConnected.value = false
    }
  }

  const disconnectWebSocket = () => {
    stompWebSocketService.disconnect()
    wsConnected.value = false
    isConnected.value = false

    // 停止消息队列处理器
    if (queueProcessingInterval.value !== null) {
      clearInterval(queueProcessingInterval.value)
      queueProcessingInterval.value = null
      console.log('✅ 消息队列处理器已停止')
    }
  }

  // 初始化聊天 - 参考web项目的实现
  const initChat = async () => {
    console.log('🚀 初始化聊天功能...')

    try {
      // 1. 首先尝试加载最近消息（优先显示历史数据）
      console.log('📨 优先加载最近消息...')
      await loadRecentMessages(20)

      // 2. 尝试加载用户的历史会话
      const currentUserId = authStore.userInfo?.id || authStore.userId
      if (currentUserId) {
        try {
          console.log('📂 尝试加载用户会话，用户ID:', currentUserId)
          const userSessions = await chatApi.getUserSessions(currentUserId)
          if (userSessions.length > 0) {
            sessions.value = userSessions
            currentSession.value = userSessions[0]
            console.log('✅ 加载到用户会话:', userSessions.length, '个')
          }
        } catch (error) {
          console.warn('⚠️ 加载用户会话失败，继续使用已加载的消息:', error)
        }
      } else {
        console.log('⚠️ 未找到用户ID，无法加载用户会话')
      }

      // 3. 如果没有会话，创建一个默认会话
      if (sessions.value.length === 0) {
        console.log('📝 创建默认会话...')
        await createSession('与开开的对话')
      }

      // 4. 如果有特定会话但消息为空，尝试加载会话消息
      if (currentSession.value?.id && messages.value.length === 0) {
        console.log('📨 尝试加载特定会话消息...')
        try {
          await loadSessionMessages(currentSession.value.id)
        } catch (error) {
          console.warn('⚠️ 加载会话消息失败，保持当前消息:', error)
        }
      }

      // 5. 连接WebSocket
      console.log('🔌 连接WebSocket...')
      await connectWebSocket()

      console.log('✅ 聊天功能初始化完成，当前消息数量:', messages.value.length)
    } catch (error) {
      console.error('❌ 聊天功能初始化失败:', error)
    }
  }

  // 监听会话变化，更新WebSocket会话ID
  watch(currentSession, (newSession) => {
    if (newSession?.id && wsConnected.value) {
      stompWebSocketService.setConversationId(newSession.id)
    }
  })

  return {
    // 状态
    currentSession,
    messages,
    sessions,
    isTyping,
    isConnected,
    connectionStatus,
    wsConnected,
    currentMessages,

    // 基础方法
    addMessage,
    sendMessage,
    createSession,
    switchSession,
    deleteSession,
    clearMessages,
    initChat,

    // 消息加载方法
    loadSessionMessages,
    loadUserMessages,
    loadRecentMessages,
    searchMessages,

    // WebSocket方法
    connectWebSocket,
    disconnectWebSocket,
    handleWebSocketMessage,

    // 消息监听方法
    onMessage: (callback: (message: any) => void) => {
      // 简单的消息监听实现
      const originalHandler = handleWebSocketMessage
      handleWebSocketMessage = async (message: any) => {
        await originalHandler(message)
        callback(message)
      }
    }
  }
})
