interface Conversation {
  id: string;
  title: string;
  messages: Message[];
  activeTaskId?: string;
  status: 'idle' | 'streaming' | 'error';
  updatedAt: number;
}

interface Message {
  id: string;
  conversationId: string;
  role: 'user' | 'assistant';
  content: string;
  status: 'pending' | 'streaming' | 'completed' | 'error';
  createdAt: number;
}

interface StreamTask {
  taskId: string;
  conversationId: string;
  assistantMessageId: string;
  controller: AbortController;
  status: 'running' | 'completed' | 'cancelled' | 'error';
}

export const useChatStore = defineStore('chat', {
  state: () => ({
    conversations: {} as Record<string, Conversation>,
    activeConversationId: '',
    tasks: {} as Record<string, StreamTask>
  }),

  getters: {
    currentConversation(state) {
      return state.conversations[state.activeConversationId];
    }
  },

  actions: {
    switchConversation(id: string) {
      this.activeConversationId = id;
    },

    updateMessage(
      conversationId: string,
      messageId: string,
      delta: string
    ) {
      const conversation = this.conversations[conversationId];
      if (!conversation) return;

      const message = conversation.messages.find(
        item => item.id === messageId
      );

      if (message) {
        message.content += delta;
      }
    }
  }
});

let controller = new AbortController();

async function sendMessage(
  conversationId: string,
  content: string
) {
  const store = useChatStore();

  const userMessageId = crypto.randomUUID();
  const assistantMessageId = crypto.randomUUID();
  const taskId = crypto.randomUUID();

  const conversation = store.conversations[conversationId];

  // 1. 添加用户消息
  conversation.messages.push({
    id: userMessageId,
    conversationId,
    role: 'user',
    content,
    status: 'completed',
    createdAt: Date.now()
  });

  // 2. 添加 AI 占位消息
  conversation.messages.push({
    id: assistantMessageId,
    conversationId,
    role: 'assistant',
    content: '',
    status: 'streaming',
    createdAt: Date.now()
  });

  // 3. 创建独立控制器
  const controller = new AbortController();

  store.tasks[taskId] = {
    taskId,
    conversationId,
    assistantMessageId,
    controller,
    status: 'running'
  };

  conversation.activeTaskId = taskId;
  conversation.status = 'streaming';

  try {
    const response = await fetch('/api/chat/stream', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        conversationId,
        taskId,
        userMessageId,
        assistantMessageId,
        content
      }),
      signal: controller.signal
    });

    if (!response.ok || !response.body) {
      throw new Error('流式请求失败');
    }

    const reader = response.body.getReader();
    const decoder = new TextDecoder();

    let buffer = '';

    while (true) {
      const { done, value } = await reader.read();
      if (done) break;

      buffer += decoder.decode(value, { stream: true });

      // 生产环境建议使用完整的 SSE 解析器，
      // 处理跨 chunk、跨行和多事件情况。
      const events = buffer.split('\n\n');
      buffer = events.pop() ?? '';

      for (const event of events) {
        const dataLine = event
          .split('\n')
          .find(line => line.startsWith('data:'));

        if (!dataLine) continue;

        const data = JSON.parse(
          dataLine.slice(5).trim()
        );

        // 4. 根据消息 ID 定位更新对象
        if (data.type === 'delta') {
          store.updateMessage(
            conversationId,
            assistantMessageId,
            data.content
          );
        }

        if (data.type === 'done') {
          store.tasks[taskId].status = 'completed';
        }
      }
    }

  } catch (error: any) {
    if (error.name === 'AbortError') {
      console.log('任务已取消');
    } else {
      console.error(error);
      store.tasks[taskId].status = 'error';
    }
  } finally {
    const task = store.tasks[taskId];

    if (task) {
      const current = store.conversations[conversationId];

      if (current?.activeTaskId === taskId) {
        current.activeTaskId = undefined;
        current.status = 'idle';
      }
    }
  }
}

function switchChat(conversationId: string) {
  chatStore.activeConversationId = conversationId;
}

function stopGeneration(taskId: string) {
  const store = useChatStore();
  const task = store.tasks[taskId];

  if (!task) return;

  // 立即停止当前客户端的数据接收
  task.controller.abort();

  // 同时通知后端停止模型任务
  fetch(`/api/tasks/${taskId}/cancel`, {
    method: 'POST'
  });
}