package me.totalfreedom.totalfreedommod.perms;

import me.totalfreedom.totalfreedommod.rank.DisplayableGroup;
import me.totalfreedom.totalfreedommod.rank.GroupProvider;
import net.luckperms.api.cacheddata.CachedMetaData;
import net.luckperms.api.cacheddata.CachedPermissionData;
import net.luckperms.api.context.ImmutableContextSet;
import net.luckperms.api.model.group.Group;
import net.luckperms.api.model.user.User;
import net.luckperms.api.model.user.UserManager;
import net.luckperms.api.node.NodeType;
import net.luckperms.api.node.types.InheritanceNode;
import net.luckperms.api.platform.PlayerAdapter;
import net.luckperms.api.query.QueryOptions;
import org.bukkit.entity.Player;

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CompletableFuture;

public class UserWrapper
{
    private final UserManager manager;
    private final PlayerAdapter<Player> playerAdapter;
    private final Set<UserData> userDataSet;

    public UserWrapper(UserManager manager, PlayerAdapter<Player> adapter)
    {
        this.manager = manager;
        this.playerAdapter = adapter;
        this.userDataSet = new HashSet<>();
    }

    public CompletableFuture<Void> addUserData(Player player)
    {
        User user = playerAdapter.getUser(player);
        CachedPermissionData permissionData = playerAdapter.getPermissionData(player);
        ImmutableContextSet contextSet = playerAdapter.getContext(player);
        QueryOptions queryOptions = playerAdapter.getQueryOptions(player);
        CachedMetaData metaData = playerAdapter.getMetaData(player);

        UserData userData = new UserData(user, metaData, permissionData, contextSet, queryOptions);
        return CompletableFuture.runAsync(() -> userDataSet.add(userData));
    }

    public CompletableFuture<User> getUser(Player player)
    {
        if (!manager.isLoaded(player.getUniqueId()) || !manager.getLoadedUsers().contains(manager.getUser(player.getUniqueId())))
        {
            return manager.loadUser(player.getUniqueId());
        }

        return CompletableFuture.supplyAsync(() -> manager.getUser(player.getUniqueId()));
    }

    public CompletableFuture<UserData> getUserData(Player player)
    {
        return getUser(player).thenApply(user ->
        {
            for (UserData userData : userDataSet)
            {
                if (userData.getUser().getUniqueId().equals(user.getUniqueId()))
                {
                    return userData;
                }
            }
            return null;
        });
    }

    public CompletableFuture<Void> removeUserData(Player player)
    {
        return getUserData(player).thenAccept(userDataSet::remove);
    }

    public CompletableFuture<Void> updateUserData(Player player)
    {
        return getUserData(player).thenApply(userData ->
        {
            UserData newData = userData.copy();
            CachedPermissionData permissionData = playerAdapter.getPermissionData(player);
            ImmutableContextSet contextSet = playerAdapter.getContext(player);
            QueryOptions queryOptions = playerAdapter.getQueryOptions(player);
            CachedMetaData metaData = playerAdapter.getMetaData(player);

            newData.setPermissionData(permissionData);
            newData.setContextSet(contextSet);
            newData.setQueryOptions(queryOptions);
            newData.setMetaData(metaData);

            userDataSet.remove(userData);
            return newData;
        }).thenAccept(userDataSet::add);
    }

    public void addToGroup(User user, DisplayableGroup group)
    {
        CompletableFuture.runAsync(() ->
                manager.modifyUser(user.getUniqueId(), c ->
                {
                    if (!c.getNodes(NodeType.INHERITANCE)
                            .contains(GroupProvider.inheritanceNode(group)))
                        c.data().add(GroupProvider.inheritanceNode(group));
                }));
    }

    public void removeFromGroup(User user, Group group)
    {
        InheritanceNode groupNode = InheritanceNode.builder(group).build();

        CompletableFuture.runAsync(() ->
                manager.modifyUser(user.getUniqueId(), userConsumer ->
                {
                    if (userConsumer.getNodes(NodeType.INHERITANCE)
                            .contains(groupNode))
                        userConsumer.data().remove(groupNode);
                }));
    }

    public void saveUser(User user)
    {
        CompletableFuture.runAsync(() -> manager.saveUser(user));
    }
}