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.UserData;
import me.totalfreedom.totalfreedommod.perms.UserWrapper;
import me.totalfreedom.totalfreedommod.util.FLog;
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.entity.Player;

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

    public static Hierarchy getHierarchy()
    {
        return hierarchy;
    }

    public TrackWrapper tw()
    {
        return trackWrapper;
    }

    public GroupWrapper gw()
    {
        return groupWrapper;
    }

    public UserWrapper uw()
    {
        return userWrapper;
    }

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

    public boolean isUserOnAdminTrack(Player player)
    {
        User user = uw().getUser(player);
        return user
                .getNodes(NodeType.INHERITANCE)
                .contains(GroupProvider
                        .inheritanceNode(
                                GroupProvider
                                        .ADMIN
                                        .getGroup()));
    }

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

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

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

    public void asyncInheritFrom(DisplayableGroup inherited, DisplayableGroup inheritor)
    {
        inheritor
                .getLuckPermsGroup()
                .data()
                .add(inherited.getInheritance());

        gw().saveGroup(inheritor
                        .getLuckPermsGroup()
                        .getName());

        FLog.info("Inherited " + inherited.getName() + " to " + inheritor.getName());
    }

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

    public void asyncTrackGroup(Track track, DisplayableGroup group)
    {
        Track t = tw().getTrack(track.getName());
        t.appendGroup(group.getLuckPermsGroup());
        tw().saveTrack(t.getName());
        gw().saveGroup(group.getLuckPermsGroup().getName());
        FLog.info("Added " + group.getName() + " to track " + track.getName());
    }

    public PromotionResult promoteUser(Track track, Player player)
    {
        User user = UserData.fromPlayer(player);
        return track.promote(user, UserData.getContextSet(user));
    }

    public DemotionResult demoteUser(Track track, Player player)
    {
        User user = UserData.fromPlayer(player);
        return track.demote(user, UserData.getContextSet(user));
    }

    public void addUserToGroup(DisplayableGroup group, Player player)
    {
        User user = UserData.fromPlayer(player);
        uw().addToGroup(user, group);
        FLog.info("Successfully added " + player.getName() + " to " + group.getName());
    }

    public void dropUser(Track track, Player player)
    {
        User user = UserData.fromPlayer(player);

        for (String group : track.getGroups())
        {
            Group g = gw().getGroup(group);
            InheritanceNode node = GroupProvider.directFromLPG(g).getInheritance();

            if (user.getNodes(NodeType.INHERITANCE).contains(node))
                uw().removeFromGroup(user, GroupProvider.wrappedFromLPG(g).getGroup());
        }
    }
}