import { useMutation, useQuery } from "@tanstack/react-query";
import {
    banUser,
    getCurrentUser,
    getUserByEmail,
    getUserById,
    getUsers,
    unbanUser,
    inviteUser,
    createUser,
    updateUser,
    deleteUser,
    getUserByUsername
} from "./action";
import { IUserSchema } from "@/src/entities/models/users/users.model";
import { IBanDuration, IBanUserSchema, ICredentialsBanUserSchema } from "@/src/entities/models/users/ban-user.model";
import { ICredentialsUnbanUserSchema, IUnbanUserSchema } from "@/src/entities/models/users/unban-user.model";
import { ICreateUserSchema } from "@/src/entities/models/users/create-user.model";
import { IUpdateUserSchema } from "@/src/entities/models/users/update-user.model";
import { ICredentialsInviteUserSchema } from "@/src/entities/models/users/invite-user.model";
import { ICredentialGetUserByEmailSchema, ICredentialGetUserByIdSchema, ICredentialGetUserByUsernameSchema, IGetUserByEmailSchema, IGetUserByIdSchema, IGetUserByUsernameSchema } from "@/src/entities/models/users/read-user.model";

const useUsersAction = () => {

    // For all users (no parameters needed)
    const getUsersQuery = useQuery<IUserSchema[]>({
        queryKey: ["users"],
        queryFn: async () => await getUsers()
    });

    // Current user query doesn't need parameters
    const getCurrentUserQuery = useQuery<IUserSchema>({
        queryKey: ["user", "current"],
        queryFn: async () => await getCurrentUser()
    });

    const getUserByIdQuery = (credential: ICredentialGetUserByIdSchema) => useQuery<IUserSchema>({
        queryKey: ["user", "id", credential.id],
        queryFn: async () => await getUserById(credential)
    });

    const getUserByEmailQuery = (credential: IGetUserByEmailSchema) => useQuery<IUserSchema>({
        queryKey: ["user", "email", credential.email],
        queryFn: async () => await getUserByEmail(credential)
    });

    const getUserByUsernameQuery = (credential: IGetUserByUsernameSchema) => useQuery<IUserSchema>({
        queryKey: ["user", "username", credential.username],
        queryFn: async () => await getUserByUsername(credential)
    });

    // Mutations that don't need dynamic parameters
    const banUserMutation = useMutation({
        mutationKey: ["banUser"],
        mutationFn: async ({ credential, data }: { credential: ICredentialsBanUserSchema; data: IBanUserSchema }) => await banUser(credential, data)
    });

    const unbanUserMutation = useMutation({
        mutationKey: ["unbanUser"],
        mutationFn: async (credential: ICredentialsUnbanUserSchema) => await unbanUser(credential)
    });

    // Create functions that return configured hooks
    const inviteUserMutation = useMutation({
        mutationKey: ["inviteUser"],
        mutationFn: async (credential: ICredentialsInviteUserSchema) => await inviteUser(credential) 
    });

    const createUserMutation = useMutation({
        mutationKey: ["createUser"],
        mutationFn: async (data: ICreateUserSchema) => await createUser(data)
    });

    const updateUserMutation = useMutation({
        mutationKey: ["updateUser"],
        mutationFn: async (params: { id: string; data: IUpdateUserSchema }) => updateUser(params.id, params.data)
    });

    const deleteUserMutation = useMutation({
        mutationKey: ["deleteUser"],
        mutationFn: async (id: string) => await deleteUser(id)
    });

    return {
        getUsers: getUsersQuery,
        getCurrentUser: getCurrentUserQuery,
        getUserById: getUserByIdQuery,
        getUserByEmailQuery,
        getUserByUsernameQuery,
        banUser: banUserMutation,
        unbanUser: unbanUserMutation,
        inviteUser: inviteUserMutation,
        createUser: createUserMutation,
        updateUser: updateUserMutation,
        deleteUser: deleteUserMutation
    };
}

export const useGetUsersQuery = () => {
    const { getUsers } = useUsersAction();

    return {
        data: getUsers.data,
        isPending: getUsers.isPending,
        error: getUsers.error,
        refetch: getUsers.refetch,
    };
}

export const useGetCurrentUserQuery = () => {
    const { getCurrentUser } = useUsersAction();

    return {
        data: getCurrentUser.data,
        isPending: getCurrentUser.isPending,
        error: getCurrentUser.error,
        refetch: getCurrentUser.refetch,
    };
}

export const useGetUserByIdQuery = (credential: ICredentialGetUserByIdSchema) => {
    const { getUserById } = useUsersAction();

    return {
        data: getUserById(credential).data,
        isPending: getUserById(credential).isPending,
        error: getUserById(credential).error,
        refetch: getUserById(credential).refetch,
    };
}

export const useGetUserByEmailQuery = (credential: ICredentialGetUserByEmailSchema) => {
    const { getUserByEmailQuery } = useUsersAction();

    return {
        data: getUserByEmailQuery(credential).data,
        isPending: getUserByEmailQuery(credential).isPending,
        error: getUserByEmailQuery(credential).error,
        refetch: getUserByEmailQuery(credential).refetch,
    };
}

export const useGetUserByUsernameQuery = (credential: ICredentialGetUserByUsernameSchema) => {
    const { getUserByUsernameQuery } = useUsersAction();

    return {
        data: getUserByUsernameQuery(credential).data,
        isPending: getUserByUsernameQuery(credential).isPending,
        error: getUserByUsernameQuery(credential).error,
        refetch: getUserByUsernameQuery(credential).refetch,
    };
}

export const useCreateUserMutation = () => {
    const { createUser } = useUsersAction();

    return {
        createUser: createUser.mutateAsync,
        isPending: createUser.isPending,
        errors: createUser.error,
    }
}

export const useInviteUserMutation = () => {
    const { inviteUser } = useUsersAction();

    return {
        inviteUser: inviteUser.mutateAsync,
        isPending: inviteUser.isPending,
        errors: inviteUser.error,
    }
}

export const useUpdateUserMutation = () => {
    const { updateUser } = useUsersAction();

    return {
        updateUser: updateUser.mutateAsync,
        isPending: updateUser.isPending,
        errors: updateUser.error,
    }
}

export const useBanUserMutation = () => {
    const { banUser } = useUsersAction();

    return {
        banUser: banUser.mutateAsync,
        isPending: banUser.isPending,
        errors: banUser.error,
    }
}

export const useUnbanUserMutation = () => {
    const { unbanUser } = useUsersAction();

    return {
        unbanUser: unbanUser.mutateAsync,
        isPending: unbanUser.isPending,
        errors: unbanUser.error,
    }
}

export const useDeleteUserMutation = () => {
    const { deleteUser } = useUsersAction();

    return {
        deleteUser: deleteUser.mutateAsync,
        isPending: deleteUser.isPending,
        errors: deleteUser.error,
    }
}