import { apiSlice } from ".";
import { generateQueryString } from "@/utils/queryStringUtil";
import URLS from "./constants";

export interface Phone {
  dialCode: number;
  number: number;
}

export interface Role {
  name: string;
}

export interface UserCompany {
  id: string;
  role: Role[];
}

export interface Team {
  name: string;
}

export interface User {
  id: string;
  firstName: string;
  lastName: string;
  email: string;
  phone?: Phone;
  company?: UserCompany;
  subCompany?: { role: string[] };
  team?: Team[];
  reportingTo?: { id?: string };
  password?: string;
  isEmailVerified: boolean;
  status: "active" | "inActive" | "inactive";
  isDeleted: boolean;
  memberType: "internal" | "external";
  joiningDate: string;
  message?: string;
  success?: boolean;
  userType?: string;
  role?: string;
  isMetaConnected?: boolean;
  accountAccessibleForMeta?: boolean;
}

export type UserNode = User & {
  children: UserNode[];
};

interface GetUsersListResponse {
  data: {
    results: User[];
    page: number;
    limit: number;
    totalPages: number;
    totalResults: number;
    totalActiveUsers: number;
  };
  code: number;
  message: string;
  success: boolean;
  error?: object;
}

interface GetUserByIdResponse {
  data: User;
  code: number;
  message: string;
  success: boolean;
  error?: object;
}

interface GetUserByIdArgs {
  id: string;
  params?: Record<string, unknown>;
}

export const userApi = apiSlice.injectEndpoints({
  endpoints: (builder) => ({
    getUsers: builder.query<
      GetUsersListResponse,
      {
        page?: number;
        limit?: number;
        search?: string;
        populate?: string;
        includeTimeStamps?: boolean;
        company?: string;
        status?: string;
        companyType?: string;
        sortBy?: string;
        team?: string;
        role?: string;
        totalActiveUsers?: boolean;
      }
    >({
      query: (params) => ({
        url: `${URLS.USERS}?${generateQueryString(
          params as Record<string, unknown>
        )}`,
        method: "GET",
      }),
      providesTags: ["User"],
    }),

    getUserById: builder.query<GetUserByIdResponse, string>({
      query: (id) => ({
        url: `${URLS.USERS}/${id}`,
        method: "GET",
      }),
    }),

    getUserProfile: builder.query<GetUserByIdResponse, GetUserByIdArgs>({
      query: ({ id, params }) => ({
        url: `${URLS.USERS}/${id}/profile?${generateQueryString(params ?? {})}`,
        method: "GET",
      }),
      providesTags: ["ProfileUser"],
    }),

    createUser: builder.mutation<User, Partial<User>>({
      query: (body) => ({
        url: `${URLS.USERS}`,
        method: "POST",
        body,
      }),
      invalidatesTags: ["User", "Team"],
    }),

    updateUser: builder.mutation<User, { id: string } & Partial<User>>({
      query: ({ id, ...body }) => ({
        url: `${URLS.USERS}/${id}`,
        method: "PATCH",
        body,
      }),
      invalidatesTags: ["User", "ProfileUser"],
    }),

    deleteUser: builder.mutation<{ success: boolean }, string>({
      query: (id) => ({
        url: `${URLS.USERS}/${id}`,
        method: "DELETE",
      }),
      invalidatesTags: ["User"],
    }),

    resetUserPassword: builder.mutation<
      { success: boolean; message: string },
      { id: string; oldPassword: string; newPassword: string }
    >({
      query: ({ id, ...body }) => ({
        url: `${URLS.USERS}/${id}/reset-password`,
        method: "PATCH",
        body,
      }),
    }),

    getUserSidebarAnalytics: builder.query({
      query: () => ({
        url: `${URLS.USERS}/sidebar-analytics`,
        method: "GET",
      }),
      providesTags: ["SidebarAnalytics"],
    }),
  }),
});

export const {
  useGetUsersQuery,
  useGetUserByIdQuery,
  useCreateUserMutation,
  useUpdateUserMutation,
  useDeleteUserMutation,
  useResetUserPasswordMutation,
  useGetUserProfileQuery,
  useGetUserSidebarAnalyticsQuery,
} = userApi;