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.event.EventBus;
import net.luckperms.api.event.EventSubscription;
import net.luckperms.api.event.node.NodeAddEvent;
import net.luckperms.api.event.node.NodeRemoveEvent;
import net.luckperms.api.model.group.Group;
import net.luckperms.api.model.user.User;
import net.luckperms.api.node.NodeType;
import net.luckperms.api.node.types.InheritanceNode;
import net.luckperms.api.platform.PlayerAdapter;
import net.luckperms.api.track.DemotionResult;
import net.luckperms.api.track.PromotionResult;
import net.luckperms.api.track.Track;
import org.bukkit.Bukkit;
import org.bukkit.NamespacedKey;
import org.bukkit.entity.Player;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CompletableFuture;

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 final PlayerAdapter<Player> playerAdapter;

    private Hierarchy()
    {
        this.playerAdapter = TotalFreedomMod.getPlugin().lpb.getAPI().getPlayerAdapter(Player.class);
        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(),
                getPlayerAdapter());
        new LuckPermsUserDataListener().register();
    }

    public static Hierarchy getHierarchy()
    {
        return hierarchy;
    }

    public PlayerAdapter<Player> getPlayerAdapter()
    {
        return playerAdapter;
    }

    public boolean isUserOnAdminTrack(Player player)
    {
        return userWrapper.getUser(player)
                .thenApply(user -> user.getNodes(NodeType.INHERITANCE)
                        .contains(GroupProvider.inheritanceNode(GroupProvider.ADMIN.getGroup())))
                .join();
    }

    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 -> track.promote(data.getUser(), data.getContextSet()));
    }

    public CompletableFuture<DemotionResult> demoteUser(Track track, Player player)
    {
        return userWrapper.getUserData(player)
                .thenApply(data -> track.demote(data.getUser(), data.getContextSet()));
    }

    public void addUserToGroup(DisplayableGroup group, Player player)
    {
        userWrapper.getUserData(player).thenAccept(user ->
                        userWrapper.addToGroup(user.getUser(), group))
                .whenComplete((a, b) ->
                {
                    if (b != null)
                    {
                        FLog.severe(b);
                    }
                });
    }

    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;
                    }

                    if (data.getUser().getNodes(NodeType.INHERITANCE)
                            .contains(InheritanceNode.builder(g).build()))
                        userWrapper.removeFromGroup(data.getUser(), g);
                });
            }
        }).whenComplete((a, b) ->
        {
            if (b != null)
            {
                FLog.severe(b);
            }
        });
    }

    private class LuckPermsUserDataListener
    {
        private final Map<NamespacedKey, EventSubscription<?>> subscriptions = new HashMap<>();

        public void register()
        {
            EventBus eventBus = TotalFreedomMod.getPlugin().lpb.getAPI().getEventBus();
            subscriptions.put(new NamespacedKey(TotalFreedomMod.getPlugin(), "node_add"), eventBus.subscribe(TotalFreedomMod.getPlugin(), NodeAddEvent.class, this::onNodeAdd));
            subscriptions.put(new NamespacedKey(TotalFreedomMod.getPlugin(), "node_remove"), eventBus.subscribe(TotalFreedomMod.getPlugin(), NodeRemoveEvent.class, this::onNodeRemove));
        }

        public void unregister()
        {
            subscriptions.forEach((key, subscription) -> subscription.close());
            subscriptions.clear();
        }

        private void onNodeAdd(NodeAddEvent event)
        {
            if (event.isUser())
            {
                User user = (User) event.getTarget();
                Player player = Bukkit.getPlayer(user.getUniqueId());
                if (player != null)
                {
                    TotalFreedomMod.getPlugin().rm.updateDisplay(player);
                    updateUserData(player);
                }
            }
        }

        private void onNodeRemove(NodeRemoveEvent event)
        {
            if (event.isUser())
            {
                User user = (User) event.getTarget();
                Player player = Bukkit.getPlayer(user.getUniqueId());
                if (player != null)
                {
                    TotalFreedomMod.getPlugin().rm.updateDisplay(player);
                    updateUserData(player);
                }
            }
        }
    }
}