import { createApi } from "@reduxjs/toolkit/query/react";
import baseQueryWithAuth from "../baseQueryWithAuth";
import type {
  ApiEnvelope,
  ChatConversation,
  ChatMessage,
  PaginatedConversations,
  PaginatedMessages,
} from "@/types/chat";

export const ChatAPI = createApi({
  reducerPath: "ChatAPI",
  baseQuery: baseQueryWithAuth,
  tagTypes: ["Conversations", "Messages", "UnreadCount"],
  endpoints: (builder) => ({
    getConversations: builder.query<
      PaginatedConversations,
      { token: string; page?: number; limit?: number; search?: string }
    >({
      query: ({ token, page = 1, limit = 50, search }) => ({
        url: "user/chat/conversations",
        params: { page, limit, ...(search ? { search } : {}) },
        headers: { Authorization: `Bearer ${token}` },
      }),
      transformResponse: (response: ApiEnvelope<PaginatedConversations>) =>
        response.data,
      providesTags: ["Conversations"],
    }),
    getUnreadCount: builder.query<{ unreadCount: number }, { token: string }>({
      query: ({ token }) => ({
        url: "user/chat/conversations/unread-count",
        headers: { Authorization: `Bearer ${token}` },
      }),
      transformResponse: (response: ApiEnvelope<{ unreadCount: number }>) =>
        response.data,
      providesTags: ["UnreadCount"],
    }),
    getOrCreateConversation: builder.query<
      { conversation: ChatConversation },
      { token: string; otherUserId: string }
    >({
      query: ({ token, otherUserId }) => ({
        url: `user/chat/conversations/with/${otherUserId}`,
        headers: { Authorization: `Bearer ${token}` },
      }),
      transformResponse: (
        response: ApiEnvelope<{ conversation: ChatConversation }>
      ) => response.data,
      providesTags: ["Conversations"],
    }),
    getMessages: builder.query<
      PaginatedMessages,
      { token: string; conversationId: string; page?: number; limit?: number }
    >({
      query: ({ token, conversationId, page = 1, limit = 20 }) => ({
        url: `user/chat/conversations/${conversationId}/messages`,
        params: { page, limit },
        headers: { Authorization: `Bearer ${token}` },
      }),
      transformResponse: (response: ApiEnvelope<PaginatedMessages>) =>
        response.data,
      providesTags: (_r, _e, arg) => [
        { type: "Messages", id: arg.conversationId },
      ],
    }),
    sendMessage: builder.mutation<
      { message: ChatMessage },
      {
        token: string;
        conversationId: string;
        content?: string;
        attachments?: File[];
      }
    >({
      query: ({ token, conversationId, content, attachments }) => {
        const formData = new FormData();
        if (content?.trim()) formData.append("content", content.trim());
        attachments?.forEach((file) => formData.append("attachments", file));
        return {
          url: `user/chat/conversations/${conversationId}/messages`,
          method: "POST",
          body: formData,
          headers: { Authorization: `Bearer ${token}` },
        };
      },
      transformResponse: (response: ApiEnvelope<{ message: ChatMessage }>) =>
        response.data,
      invalidatesTags: ["Conversations", "UnreadCount"],
    }),
    markConversationRead: builder.mutation<
      { updatedCount: number },
      { token: string; conversationId: string }
    >({
      query: ({ token, conversationId }) => ({
        url: `user/chat/conversations/${conversationId}/read`,
        method: "PATCH",
        headers: { Authorization: `Bearer ${token}` },
      }),
      transformResponse: (
        response: ApiEnvelope<{ updatedCount: number }>
      ) => response.data,
      invalidatesTags: ["Conversations", "UnreadCount"],
    }),
    deleteMessage: builder.mutation<
      unknown,
      { token: string; messageId: string }
    >({
      query: ({ token, messageId }) => ({
        url: `user/chat/messages/${messageId}`,
        method: "DELETE",
        headers: { Authorization: `Bearer ${token}` },
      }),
      invalidatesTags: ["Conversations"],
    }),
  }),
});

export const {
  useGetConversationsQuery,
  useGetUnreadCountQuery,
  useLazyGetOrCreateConversationQuery,
  useLazyGetMessagesQuery,
  useSendMessageMutation,
} = ChatAPI;