import { apiSlice } from "./baseApi";
import {
  LoginRequest,
  LoginResponse,
  MeResponse,
  PasswordResetOtpRequest,
  PasswordResetOtpResponse,
  PersonalDashboardResponse,
  ProfileImageMutationResponse,
  ResetPasswordWithOtpRequest,
  ResetPasswordWithOtpResponse,
  UploadRequestedDocumentResponse,
  VerifyPasswordResetOtpRequest,
  VerifyPasswordResetOtpResponse,
  UpdatePreferredLanguageResponse,
  RegistrationDocumentType,
  RegisterResponse,
  RegistrationRequest,
  PreferredLanguage,
  ResetOwnPasswordRequest,
  ResetOwnPasswordResponse,
} from "@/types/api";
import { persistAuthSession, persistUserProfile } from "@/lib/auth";

const authApi = apiSlice.injectEndpoints({
  endpoints: (builder) => ({
    login: builder.mutation<LoginResponse, LoginRequest>({
      query: (credentials) => ({
        url: "/api/auth/login",
        method: "POST",
        body: credentials,
      }),
      async onQueryStarted(arg, { queryFulfilled }) {
        try {
          const { data } = await queryFulfilled;
          if (typeof window !== "undefined" && data.token) {
            persistAuthSession(data.token, data.user);
          }
        } catch {
        }
      },
    }),

    requestPasswordResetOtp: builder.mutation<PasswordResetOtpResponse, PasswordResetOtpRequest>({
      query: (payload) => ({
        url: "/api/auth/password-reset/request-otp",
        method: "POST",
        body: payload,
      }),
    }),

    verifyPasswordResetOtp: builder.mutation<VerifyPasswordResetOtpResponse, VerifyPasswordResetOtpRequest>({
      query: (payload) => ({
        url: "/api/auth/password-reset/verify-otp",
        method: "POST",
        body: payload,
      }),
    }),

    resetPasswordWithOtp: builder.mutation<ResetPasswordWithOtpResponse, ResetPasswordWithOtpRequest>({
      query: (payload) => ({
        url: "/api/auth/password-reset/reset",
        method: "POST",
        body: payload,
      }),
    }),

    resetOwnPassword: builder.mutation<ResetOwnPasswordResponse, ResetOwnPasswordRequest>({
      query: (payload) => ({
        url: "/api/auth/password-reset/self",
        method: "POST",
        body: payload,
      }),
    }),

    getPersonalDashboard: builder.query<PersonalDashboardResponse, void>({
      query: () => ({
        url: "/api/auth/personal-dashboard",
        method: "GET",
      }),
      providesTags: ["Registration"],
    }),

    getMe: builder.query<MeResponse, void>({
      query: () => ({
        url: "/api/auth/me",
        method: "GET",
      }),
      async onQueryStarted(arg, { queryFulfilled }) {
        try {
          const { data } = await queryFulfilled;
          if (typeof window !== "undefined" && data?.user) {
            persistUserProfile(data.user);
          }
        } catch {
        }
      },
      providesTags: ["Registration", "Admin"],
    }),

    uploadProfileImage: builder.mutation<ProfileImageMutationResponse, File>({
      query: (file) => {
        const body = new FormData();
        body.append("profileImage", file);

        return {
          url: "/api/auth/profile-image",
          method: "POST",
          body,
        };
      },
      invalidatesTags: ["Registration", "Admin"],
    }),

    removeProfileImage: builder.mutation<ProfileImageMutationResponse, void>({
      query: () => ({
        url: "/api/auth/profile-image",
        method: "DELETE",
      }),
      invalidatesTags: ["Registration", "Admin"],
    }),

    updatePreferredLanguage: builder.mutation<UpdatePreferredLanguageResponse, PreferredLanguage>({
      query: (preferredLanguage) => ({
        url: "/api/auth/preferred-language",
        method: "PATCH",
        body: { preferredLanguage },
      }),
      invalidatesTags: ["Registration", "Admin"],
    }),

    uploadRequestedRegistrationDocument: builder.mutation<
      UploadRequestedDocumentResponse,
      {
        registrationId: number;
        documentType: RegistrationDocumentType;
        documentImage: File;
      }
    >({
      query: ({ registrationId, documentType, documentImage }) => {
        const body = new FormData();
        body.append("documentType", documentType);
        body.append("documentImage", documentImage);

        return {
          url: `/api/auth/registrations/${registrationId}/reupload-document`,
          method: "POST",
          body,
        };
      },
      invalidatesTags: ["Registration", "Admin"],
    }),

    register: builder.mutation<RegisterResponse, RegistrationRequest | FormData>({
      query: (registration) => ({
        url: "/api/registrations/register",
        method: "POST",
        body: registration,
      }),
      async onQueryStarted(arg, { queryFulfilled }) {
        try {
          const { data } = await queryFulfilled;
          if (typeof window !== "undefined" && data.token) {
            persistAuthSession(data.token, data.user);
          }
        } catch {
        }
      },
      invalidatesTags: ["Registration"],
    }),
  }),
});

export const {
  useLoginMutation,
  useRequestPasswordResetOtpMutation,
  useVerifyPasswordResetOtpMutation,
  useResetPasswordWithOtpMutation,
  useResetOwnPasswordMutation,
  useGetMeQuery,
  useGetPersonalDashboardQuery,
  useRegisterMutation,
  useUploadProfileImageMutation,
  useRemoveProfileImageMutation,
  useUpdatePreferredLanguageMutation,
  useUploadRequestedRegistrationDocumentMutation,
} = authApi;