package me.totalfreedom.totalfreedommod.rank;

import me.totalfreedom.totalfreedommod.TotalFreedomMod;
import me.totalfreedom.totalfreedommod.perms.GroupWrapper;
import me.totalfreedom.totalfreedommod.perms.TrackWrapper;
import me.totalfreedom.totalfreedommod.perms.UserWrapper;
import me.totalfreedom.totalfreedommod.util.FLog;
import net.luckperms.api.model.group.Group;
import net.luckperms.api.node.NodeEqualityPredicate;
import net.luckperms.api.node.NodeType;
import net.luckperms.api.node.types.InheritanceNode;
import net.luckperms.api.track.DemotionResult;
import net.luckperms.api.track.PromotionResult;
import net.luckperms.api.track.Track;
import org.bukkit.entity.Player;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicBoolean;

public class Hierarchy
{
    private static final Hierarchy hierarchy = new Hierarchy(); // static singleton for global state.
    private final GroupWrapper groupWrapper;
    private final TrackWrapper trackWrapper;
    private final UserWrapper userWrapper;

    private Hierarchy()
    {
        this.groupWrapper = new GroupWrapper(TotalFreedomMod.getPlugin().lpb.getAPI().getGroupManager());
        this.trackWrapper = new TrackWrapper(TotalFreedomMod.getPlugin().lpb.getAPI().getTrackManager());
        this.userWrapper = new UserWrapper(TotalFreedomMod.getPlugin().lpb.getAPI().getUserManager(),
                TotalFreedomMod.getPlugin().lpb.getAPI().getPlayerAdapter(Player.class));
    }

    public static Hierarchy getHierarchy()
    {
        return hierarchy;
    }

    public boolean isUserOnAdminTrack(Player player)
    {
        AtomicBoolean isOnAdminTrack = new AtomicBoolean(false);
        userWrapper.getUser(player).thenAccept(user ->
                user.data().toCollection().stream()
                        .filter(NodeType.INHERITANCE::matches)
                        .map(NodeType.INHERITANCE::cast)
                        .filter(NodeEqualityPredicate.ONLY_KEY
                                .equalTo(InheritanceNode
                                        .builder(GroupProvider.ADMIN.getGroup().getLuckPermsGroup().getName())
                                        .build()))
                        .forEach(node ->
                        {
                            if (node.getGroupName().startsWith("admin"))
                            {
                                isOnAdminTrack.set(true);
                            }
                        })).whenComplete((a, b) ->
        {
            if (b != null)
            {
                FLog.severe(b);
            }
        });

        return isOnAdminTrack.get();
    }

    public Track op()
    {
        return trackWrapper.getTrack("OP").join();
    }

    public Track builder()
    {
        return trackWrapper.getTrack("BUILDER").join();
    }

    public Track admin()
    {
        return trackWrapper.getTrack("ADMIN").join();
    }

    public void addInheritance(DisplayableGroup previous, DisplayableGroup current)
    {
        CompletableFuture.runAsync(() ->
        {
            current.getLuckPermsGroup().data().add(InheritanceNode.builder(previous.getLuckPermsGroup()).build());
            groupWrapper.saveGroup(current.getLuckPermsGroup().getName());
        }).whenComplete((a, b) ->
        {
            if (b != null)
            {
                FLog.severe(b);
            }
        });
    }

    public Group getGroup(String name)
    {
        return groupWrapper.getGroup(name).join();
    }

    public void addGroupToTrack(Track track, DisplayableGroup group)
    {
        trackWrapper.getTrack(track.getName()).thenAccept(t ->
        {
            t.appendGroup(group.getLuckPermsGroup());
            trackWrapper.saveTrack(t.getName());
        }).whenComplete((a, b) ->
        {
            if (b != null)
            {
                FLog.severe(b);
            }
        });
    }

    public void addUserData(Player player) {
        userWrapper.addUserData(player).whenComplete((a, b) ->
        {
            if (b != null)
            {
                FLog.severe(b);
            }
        });
    }

    public void updateUserData(Player player) {
        userWrapper.updateUserData(player).whenComplete((a, b) ->
        {
            if (b != null)
            {
                FLog.severe(b);
            }
        });
    }

    public void dropUserData(Player player) {
        userWrapper.removeUserData(player).whenComplete((a, b) ->
        {
            if (b != null)
            {
                FLog.severe(b);
            }
        });
    }

    public CompletableFuture<PromotionResult> promoteUser(Track track, Player player)
    {
        return userWrapper.getUserData(player).thenApply(data ->
        {
            boolean isOnTrack = false;
            for (String trackGroup : track.getGroups())
            {
                for (Group userGroup : data.getUser().getInheritedGroups(data.getQueryOptions()))
                {
                    if (userGroup.getName().equals(trackGroup))
                    {
                        isOnTrack = true;
                    }
                }
            }

            if (isOnTrack)
            {
                return track.promote(data.getUser(), data.getContextSet());
            } else
            {
                addUserToGroup(GroupProvider.fromString(track.getGroups().get(0)).getGroup(), player);
                return null;
            }
        });
    }

    public CompletableFuture<DemotionResult> demoteUser(Track track, Player player)
    {
        return userWrapper.getUserData(player).thenApply(data ->
        {
            boolean isOnTrack = false;
            for (String trackGroup : track.getGroups())
            {
                for (Group userGroup : data.getUser().getInheritedGroups(data.getQueryOptions()))
                {
                    if (userGroup.getName().equals(trackGroup))
                    {
                        isOnTrack = true;
                    }
                }
            }

            if (isOnTrack)
            {
                return track.demote(data.getUser(), data.getContextSet());
            } else
            {
                return null;
            }
        });
    }

    public void addUserToGroup(DisplayableGroup group, Player player)
    {
        userWrapper.getUserData(player).thenAccept(user ->
        {
            for (InheritanceNode node : group.getLuckPermsGroup().getNodes(NodeType.INHERITANCE))
            {
                user.getUser().data().add(node);
            }

            user.getUser().getInheritedGroups(user.getQueryOptions()).add(group.getLuckPermsGroup());

            userWrapper.saveUser(user.getUser());
        }).whenComplete((a, b) ->
        {
            if (b != null)
            {
                FLog.severe(b);
            }

            updateUserData(player);
        });
    }

    public void dropUserFromAll(Track track, Player player)
    {
        userWrapper.getUserData(player).thenAccept(data ->
        {
            for (String group : track.getGroups())
            {
                groupWrapper.getGroup(group).whenComplete((g, b) ->
                {
                    if (b != null)
                    {
                        FLog.severe(b);
                        return;
                    }

                    for (InheritanceNode node : g.getNodes(NodeType.INHERITANCE))
                    {
                        data.getUser().data().remove(node);
                    }
                });
            }
            userWrapper.saveUser(data.getUser());
        }).whenComplete((a, b) ->
        {
            if (b != null)
            {
                FLog.severe(b);
            }

            updateUserData(player);
        });
    }
}