import { apiSlice } from "./baseApi";
import {
  HierarchyTreeResponse,
  UnassignedRegistrationsResponse,
  AssignKaryakartaResponse,
  AssignHaridhamIdResponse,
  AssignPersonalHaridhamIdResponse,
  AdminUpdateRegistrationNamesResponse,
  UploadHaridhamReceiptResponse,
  SendHaridhamReceiptWhatsAppResponse,
  AdminRequestDocumentReuploadResponse,
  RegistrationDocumentType,
  KaryakartaDataListResponse,
  KaryakartaDataUpdateResponse,
  KaryakartaDataCreateResponse,
  KaryakartaDataAssignHaridhamResponse,
  AdminMahayagRatesListResponse,
  AdminMahayagRateMutationResponse,
  AdminMahayagRateDeleteResponse,
  AdminAccountsListResponse,
  AdminAccountMutationResponse,
  AdminKaryakartaHaridhamAvailabilityResponse,
  AdminOnlineTransactionsResponse,
  AdminRecentTransactionsResponse,
  AdminCancelOnlineTransactionResponse,
  AdminDeleteRegistrationAndUserResponse,
  AdminApproveChequeTransactionResponse,
  AdminRequestChequeReuploadResponse,
  AdminRegistrationOtpsResponse,
  AdminPasswordResetOtpsResponse,
  RegistrationCountryType,
} from "@/types/api";

const adminApi = apiSlice.injectEndpoints({
  endpoints: (builder) => ({
    getHierarchyTree: builder.query<HierarchyTreeResponse, void>({
      query: () => ({
        url: "/api/form/hierarchy",
        method: "GET",
      }),
      providesTags: ["Admin"],
    }),

    getUnassignedRegistrations: builder.query<
      UnassignedRegistrationsResponse,
      {
        page?: number;
        limit?: number;
        search?: string;
      } | void
    >({
      query: (params) => {
        const queryParams = new URLSearchParams();
        if (params?.page) queryParams.append("page", String(params.page));
        if (params?.limit) queryParams.append("limit", String(params.limit));
        if (params?.search) queryParams.append("search", params.search);

        return {
          url: "/api/admin/unassigned-registrations",
          method: "GET",
          params: queryParams,
        };
      },
      providesTags: ["Admin"],
    }),

    assignKaryakartaToRegistration: builder.mutation<
      AssignKaryakartaResponse,
      {
        registrationId: number;
        haridhamId: string;
      }
    >({
      query: ({ registrationId, haridhamId }) => ({
        url: `/api/admin/registrations/${registrationId}/assign-karyakarta`,
        method: "PATCH",
        body: { haridhamId },
      }),
      invalidatesTags: ["Admin", "Registration", "Analytics"],
    }),

    assignHaridhamIdToRegistration: builder.mutation<
      AssignHaridhamIdResponse,
      {
        registrationId: number;
        haridhamId: string;
      }
    >({
      query: ({ registrationId, haridhamId }) => ({
        url: `/api/admin/registrations/${registrationId}/assign-haridham-id`,
        method: "PATCH",
        body: { haridhamId },
      }),
      invalidatesTags: ["Admin", "Registration", "Analytics"],
    }),

    assignPersonalHaridhamIdByRegistration: builder.mutation<
      AssignPersonalHaridhamIdResponse,
      {
        registrationId: number;
        haridhamId: string;
      }
    >({
      query: ({ registrationId, haridhamId }) => ({
        url: `/api/admin/registrations/${registrationId}/assign-personal-haridham-id`,
        method: "PATCH",
        body: { haridhamId },
      }),
      invalidatesTags: ["Admin", "Registration", "Analytics"],
    }),

    updateRegistrationNamesByAdmin: builder.mutation<
      AdminUpdateRegistrationNamesResponse,
      {
        registrationId: number;
        registrant1?: string;
        registrant2?: string;
      }
    >({
      query: ({ registrationId, registrant1, registrant2 }) => ({
        url: `/api/admin/registrations/${registrationId}/name`,
        method: "PATCH",
        body: { registrant1, registrant2 },
      }),
      invalidatesTags: ["Admin", "Registration", "Analytics"],
    }),

    uploadHaridhamReceipt: builder.mutation<
      UploadHaridhamReceiptResponse,
      {
        transactionId: number;
        receiptImage: File;
      }
    >({
      query: ({ transactionId, receiptImage }) => {
        const body = new FormData();
        body.append("receiptImage", receiptImage);

        return {
          url: `/api/admin/transactions/${transactionId}/haridham-receipt`,
          method: "POST",
          body,
        };
      },
      invalidatesTags: ["Registration", "Admin"],
    }),

    sendHaridhamReceiptWhatsApp: builder.mutation<
      SendHaridhamReceiptWhatsAppResponse,
      {
        transactionId: number;
      }
    >({
      query: ({ transactionId }) => ({
        url: `/api/admin/transactions/${transactionId}/haridham-receipt/send-whatsapp`,
        method: "POST",
      }),
    }),

    requestRegistrationDocumentReupload: builder.mutation<
      AdminRequestDocumentReuploadResponse,
      {
        registrationId: number;
        documentType: RegistrationDocumentType;
      }
    >({
      query: ({ registrationId, documentType }) => ({
        url: `/api/admin/registrations/${registrationId}/request-document-reupload`,
        method: "PATCH",
        body: { documentType },
      }),
      invalidatesTags: ["Registration", "Admin"],
    }),

    getAdminKaryakartaData: builder.query<
      KaryakartaDataListResponse,
      {
        page?: number;
        limit?: number;
        name?: string;
        mandal?: string;
        pradeshId?: number;
        haridhamId?: string;
        sortBy?: string;
        sortOrder?: "asc" | "desc";
      } | void
    >({
      query: (params) => {
        const queryParams = new URLSearchParams();
        if (params?.page) queryParams.append("page", String(params.page));
        if (params?.limit) queryParams.append("limit", String(params.limit));
        if (params?.name) queryParams.append("name", params.name);
        if (params?.mandal) queryParams.append("mandal", params.mandal);
        if (params?.pradeshId) queryParams.append("pradeshId", String(params.pradeshId));
        if (params?.haridhamId) queryParams.append("haridhamId", params.haridhamId);
        if (params?.sortBy) queryParams.append("sortBy", params.sortBy);
        if (params?.sortOrder) queryParams.append("sortOrder", params.sortOrder);

        return {
          url: "/api/admin/karyakarta-data",
          method: "GET",
          params: queryParams,
        };
      },
      providesTags: ["Admin"],
    }),

    updateAdminKaryakartaData: builder.mutation<
      KaryakartaDataUpdateResponse,
      {
        id: number;
        name: string;
        phone: string;
        mandal: string;
        district: string;
      }
    >({
      query: ({ id, ...body }) => ({
        url: `/api/admin/karyakarta-data/${id}`,
        method: "PATCH",
        body,
      }),
      invalidatesTags: ["Admin", "Analytics"],
    }),

    createAdminKaryakartaData: builder.mutation<
      KaryakartaDataCreateResponse,
      FormData
    >({
      query: (body) => ({
        url: "/api/admin/karyakarta-data",
        method: "POST",
        body,
      }),
      invalidatesTags: ["Admin"],
    }),

    assignAdminKaryakartaDataHaridhamId: builder.mutation<
      KaryakartaDataAssignHaridhamResponse,
      {
        id: number;
        haridhamId: string;
      }
    >({
      query: ({ id, haridhamId }) => ({
        url: `/api/admin/karyakarta-data/${id}/assign-haridham-id`,
        method: "PATCH",
        body: { haridhamId },
      }),
      invalidatesTags: ["Admin", "Analytics"],
    }),

    getAdminMahayagRates: builder.query<AdminMahayagRatesListResponse, { registrationCountryType?: RegistrationCountryType } | void>({
      query: (params) => ({
        url: "/api/admin/mahayag-rates",
        method: "GET",
        params: params?.registrationCountryType
          ? new URLSearchParams({ registrationCountryType: params.registrationCountryType })
          : undefined,
      }),
      providesTags: ["Admin"],
    }),

    createAdminMahayagRate: builder.mutation<
      AdminMahayagRateMutationResponse,
      {
        placeName: string;
        amount: number;
        registrationCountryType?: RegistrationCountryType;
      }
    >({
      query: (body) => ({
        url: "/api/admin/mahayag-rates",
        method: "POST",
        body,
      }),
      invalidatesTags: ["Admin"],
    }),

    updateAdminMahayagRate: builder.mutation<
      AdminMahayagRateMutationResponse,
      {
        id: number;
        placeName: string;
        amount: number;
        registrationCountryType?: RegistrationCountryType;
      }
    >({
      query: ({ id, ...body }) => ({
        url: `/api/admin/mahayag-rates/${id}`,
        method: "PATCH",
        body,
      }),
      invalidatesTags: ["Admin"],
    }),

    deleteAdminMahayagRate: builder.mutation<AdminMahayagRateDeleteResponse, { id: number; registrationCountryType?: RegistrationCountryType }>({
      query: ({ id, registrationCountryType }) => ({
        url: `/api/admin/mahayag-rates/${id}`,
        method: "DELETE",
        params: registrationCountryType
          ? new URLSearchParams({ registrationCountryType })
          : undefined,
      }),
      invalidatesTags: ["Admin"],
    }),

    getAdminAccounts: builder.query<
      AdminAccountsListResponse,
      {
        role: "PRADESH_ADMIN" | "MANDAL_ADMIN" | "KARYAKARTA" | "PERSONAL";
        page?: number;
        limit?: number;
        search?: string;
        pradeshId?: number;
        mandalId?: number;
        haridhamId?: string;
      }
    >({
      query: (params) => {
        const queryParams = new URLSearchParams();
        queryParams.append("role", params.role);
        if (params.page) queryParams.append("page", String(params.page));
        if (params.limit) queryParams.append("limit", String(params.limit));
        if (params.search) queryParams.append("search", params.search);
        if (params.pradeshId) queryParams.append("pradeshId", String(params.pradeshId));
        if (params.mandalId) queryParams.append("mandalId", String(params.mandalId));
        if (params.haridhamId) queryParams.append("haridhamId", params.haridhamId);

        return {
          url: "/api/admin/accounts",
          method: "GET",
          params: queryParams,
        };
      },
      providesTags: ["Admin"],
    }),

    checkKaryakartaHaridhamIdAvailability: builder.query<
      AdminKaryakartaHaridhamAvailabilityResponse,
      { haridhamId: string }
    >({
      query: ({ haridhamId }) => ({
        url: "/api/admin/accounts/karyakarta-haridham-id-availability",
        method: "GET",
        params: new URLSearchParams({ haridhamId }),
      }),
    }),

    createAdminAccount: builder.mutation<
      AdminAccountMutationResponse,
      {
        role: "PRADESH_ADMIN" | "MANDAL_ADMIN" | "KARYAKARTA";
        name: string;
        username?: string;
        phone?: string;
        password: string;
        pradeshId?: number;
        mandalId?: number;
        haridhamId?: string;
      }
    >({
      query: (body) => ({
        url: "/api/admin/accounts",
        method: "POST",
        body,
      }),
      invalidatesTags: ["Admin"],
    }),

    updateAdminAccount: builder.mutation<
      AdminAccountMutationResponse,
      {
        id: number;
        name?: string;
        username?: string;
        phone?: string;
        isDisabled?: boolean;
        pradeshId?: number;
        mandalId?: number;
        haridhamId?: string;
      }
    >({
      query: ({ id, ...body }) => ({
        url: `/api/admin/accounts/${id}`,
        method: "PATCH",
        body,
      }),
      invalidatesTags: ["Admin"],
    }),

    getAdminOnlineTransactions: builder.query<
      AdminOnlineTransactionsResponse,
      {
        page?: number;
        limit?: number;
        razorpayPaymentId?: string;
      } | void
    >({
      query: (params) => {
        const queryParams = new URLSearchParams();
        if (params?.page) queryParams.append("page", String(params.page));
        if (params?.limit) queryParams.append("limit", String(params.limit));
        if (params?.razorpayPaymentId) queryParams.append("razorpayPaymentId", params.razorpayPaymentId);

        return {
          url: "/api/admin/online-transactions",
          method: "GET",
          params: queryParams,
        };
      },
      providesTags: ["Admin", "Registration"],
    }),

    getAdminRecentTransactions: builder.query<
      AdminRecentTransactionsResponse,
      {
        page?: number;
        limit?: number;
        method?: "ALL" | "CASH" | "ONLINE" | "CHEQUE";
        statuses?: string[];
        fromDate?: string;
        toDate?: string;
        exportAll?: boolean;
      } | void
    >({
      query: (params) => {
        const queryParams = new URLSearchParams();
        if (params?.page) queryParams.append("page", String(params.page));
        if (params?.limit) queryParams.append("limit", String(params.limit));
        if (params?.method) queryParams.append("method", params.method);
        params?.statuses?.forEach((status) => {
          if (status) queryParams.append("status", status);
        });
        if (params?.fromDate) queryParams.append("fromDate", params.fromDate);
        if (params?.toDate) queryParams.append("toDate", params.toDate);
        if (params?.exportAll) queryParams.append("exportAll", "true");

        return {
          url: "/api/admin/recent-transactions",
          method: "GET",
          params: queryParams,
        };
      },
      providesTags: ["Admin", "Registration"],
    }),

    cancelAdminOnlineTransaction: builder.mutation<
      AdminCancelOnlineTransactionResponse,
      { razorpayPaymentId: string }
    >({
      query: (body) => ({
        url: "/api/admin/online-transactions/cancel",
        method: "PATCH",
        body,
      }),
      invalidatesTags: ["Admin", "Registration"],
    }),

    deleteRegistrationAndUser: builder.mutation<
      AdminDeleteRegistrationAndUserResponse,
      { registrationId: number; reason: string }
    >({
      query: ({ registrationId, reason }) => ({
        url: `/api/admin/registrations/${registrationId}/delete-with-user`,
        method: "DELETE",
        body: { reason },
      }),
      invalidatesTags: ["Admin", "Registration", "Analytics"],
    }),

    approveChequeTransaction: builder.mutation<
      AdminApproveChequeTransactionResponse,
      { transactionId: number }
    >({
      query: ({ transactionId }) => ({
        url: `/api/admin/transactions/${transactionId}/approve-cheque`,
        method: "POST",
      }),
      invalidatesTags: ["Admin", "Registration", "Cashflow"],
    }),

    requestChequeDocumentReupload: builder.mutation<
      AdminRequestChequeReuploadResponse,
      { transactionId: number }
    >({
      query: ({ transactionId }) => ({
        url: `/api/admin/transactions/${transactionId}/request-cheque-reupload`,
        method: "POST",
      }),
      invalidatesTags: ["Admin", "Registration", "Cashflow"],
    }),

    getAdminRegistrationOtps: builder.query<
      AdminRegistrationOtpsResponse,
      {
        page?: number;
        limit?: number;
        phone?: string;
        sortBy?: string;
        sortOrder?: "asc" | "desc";
      } | void
    >({
      query: (params) => {
        const queryParams = new URLSearchParams();
        if (params?.page) queryParams.append("page", String(params.page));
        if (params?.limit) queryParams.append("limit", String(params.limit));
        if (params?.phone) queryParams.append("phone", params.phone);
        if (params?.sortBy) queryParams.append("sortBy", params.sortBy);
        if (params?.sortOrder) queryParams.append("sortOrder", params.sortOrder);

        return {
          url: "/api/admin/otp/registration",
          method: "GET",
          params: queryParams,
        };
      },
      providesTags: ["Admin"],
    }),

    getAdminPasswordResetOtps: builder.query<
      AdminPasswordResetOtpsResponse,
      {
        page?: number;
        limit?: number;
        phone?: string;
        sortBy?: string;
        sortOrder?: "asc" | "desc";
      } | void
    >({
      query: (params) => {
        const queryParams = new URLSearchParams();
        if (params?.page) queryParams.append("page", String(params.page));
        if (params?.limit) queryParams.append("limit", String(params.limit));
        if (params?.phone) queryParams.append("phone", params.phone);
        if (params?.sortBy) queryParams.append("sortBy", params.sortBy);
        if (params?.sortOrder) queryParams.append("sortOrder", params.sortOrder);

        return {
          url: "/api/admin/otp/reset-password",
          method: "GET",
          params: queryParams,
        };
      },
      providesTags: ["Admin"],
    }),
  }),
});

export const {
  useGetHierarchyTreeQuery,
  useGetUnassignedRegistrationsQuery,
  useAssignKaryakartaToRegistrationMutation,
  useAssignHaridhamIdToRegistrationMutation,
  useAssignPersonalHaridhamIdByRegistrationMutation,
  useUpdateRegistrationNamesByAdminMutation,
  useUploadHaridhamReceiptMutation,
  useSendHaridhamReceiptWhatsAppMutation,
  useRequestRegistrationDocumentReuploadMutation,
  useGetAdminKaryakartaDataQuery,
  useUpdateAdminKaryakartaDataMutation,
  useCreateAdminKaryakartaDataMutation,
  useAssignAdminKaryakartaDataHaridhamIdMutation,
  useGetAdminMahayagRatesQuery,
  useCreateAdminMahayagRateMutation,
  useUpdateAdminMahayagRateMutation,
  useDeleteAdminMahayagRateMutation,
  useGetAdminAccountsQuery,
  useLazyCheckKaryakartaHaridhamIdAvailabilityQuery,
  useCreateAdminAccountMutation,
  useUpdateAdminAccountMutation,
  useGetAdminOnlineTransactionsQuery,
  useGetAdminRecentTransactionsQuery,
  useLazyGetAdminRecentTransactionsQuery,
  useCancelAdminOnlineTransactionMutation,
  useDeleteRegistrationAndUserMutation,
  useApproveChequeTransactionMutation,
  useRequestChequeDocumentReuploadMutation,
  useGetAdminRegistrationOtpsQuery,
  useGetAdminPasswordResetOtpsQuery,
} = adminApi;