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 { IBanUserSchema, ICredentialsBanUserSchema } from "@/src/entities/models/users/ban-user.model";
import { 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";

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({
        queryKey: ["user", "current"],
        queryFn: async () => await getCurrentUser()
    });

    const getUserByIdQuery = (id: string) => ({
        queryKey: ["user", id],
        queryFn: async () => await getUserById(id)
    });

    const getUserByEmailQuery = (email: string) => ({
        queryKey: ["user", "email", email],
        queryFn: async () => await getUserByEmail({ email })
    });

    const getUserByUsernameQuery = (username: string) => ({
        queryKey: ["user", "username", username],
        queryFn: async () => await getUserByUsername(username)
    });

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

    const unbanUserMutation = useMutation({
        mutationKey: ["unbanUser"],
        mutationFn: async (params: IUnbanUserSchema) => await unbanUser(params.id)
    });

    // 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 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,
    }
}