package fr.nathan.skybattle.manager;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;

import org.bukkit.Bukkit;
import org.bukkit.entity.Player;

import com.google.common.collect.Maps;

import fr.nathan.skybattle.SkyBattle;
import fr.nathan.skybattle.SkyBattle.GameStatus;
import fr.nathan.skybattle.listener.PlayerDeathEventListener;
import fr.nathan.skybattle.utils.Reflection;

public class ScoreboardManager
{
	private static Map<UUID, ScoreboardManager> players = Maps.newHashMap();
	private static String display;

	private static SkyBattle main;
	public static void init(SkyBattle main) {
		ScoreboardManager.main = main;
	}

	public static void updateScoreboard()
	{
		if(!main.getStatus().equals(GameStatus.FINISHED))
		{
			display = main.getStatus().equals(GameStatus.WAITING) ? main.getSkyConfig().getScoreWaitingName() : main.getSkyConfig().getScoreIGName();
			List<String> lines;
			if(main.getStatus().equals(GameStatus.WAITING))
				lines = main.getSkyConfig().getScoreLinesWaiting().stream().map(line -> line
						.replace("%cooldown%", main.getCooldownManager().getCooldown() + "")
						.replace("%players%", Bukkit.getOnlinePlayers().size() + "")
						.replace("%max%", main.getSkyConfig().getMinPlayer() + "")
						.replace("%map%", main.getSkyConfig().getMapName()))
				.collect(Collectors.toList());
			else
				lines = main.getSkyConfig().getScoreLinesIG().stream().map(line -> line
						.replace("%redhearth%", main.getGameManager().getRedHearth().toString())
						.replace("%bluehearth%", main.getGameManager().getBlueHearth().toString())
						.replace("%time%", main.getGameManager().getTimer())
						.replace("%map%", main.getSkyConfig().getMapName()))
				.collect(Collectors.toList());

			int j = lines.size();
			for(int i = 0; i < j; i++)
				setLine(lines.get(i), j - i - 1);
		}
	}

	public static void init(Player p)
	{
		ScoreboardManager manager = new ScoreboardManager(p, display);
		players.put(p.getUniqueId(), manager);
		updateScoreboard();
	}

	public static void remove(Player p)
	{
		if(players.containsKey(p.getUniqueId()))
		{
			players.get(p.getUniqueId()).destroy();
			players.remove(p.getUniqueId());
		}
	}

	public static void setBoardName(String name)
	{
		players.values().forEach(m -> m.setDisplayName(name));
	}

	public static void setLine(String text, int line)
	{
		players.forEach((k, v) -> v.setLine(text
				.replace("%kill%", PlayerDeathEventListener.getKill(k).toString())
				.replace("%death%", PlayerDeathEventListener.getDeath(k).toString())
				.replace("%kit%", main.getKitManager().getKit(k) != null ? main.getKitManager().getKit(k).getName() : "Aucun"), line, new boolean[0]));
	}

	private Reflection ref;

	private Player player;
	private HashMap<Integer, String> lines = new HashMap<>();

	public ScoreboardManager(Player player, String name)
	{
		this.ref = new Reflection();
		this.player = player;

		try
		{
			sendPacket(getEditPacket(0, name));
			sendPacket(getSettingPacket());
		}
		catch(Exception e) { e.printStackTrace(); }
	}

	public void setDisplayName(String name)
	{
		try
		{
			sendPacket(getEditPacket(2, name));
		}
		catch(Exception e) { e.printStackTrace(); }
	}

	@SuppressWarnings({ "unchecked", "rawtypes" })
	public void setLine(String text, int line, boolean... force)
	{
		if(lines.containsKey(line))
		{
			if(lines.get(line).equals(text) && (force.length > 0 ? !force[0] : true)) return;
			removeLine(line);
		}

		try
		{
			Object packet = ref.getNMSClass("PacketPlayOutScoreboardScore").getConstructor(String.class).newInstance(text);
			ref.setField(packet, "b", player.getName());
			ref.setField(packet, "c", line);
			ref.setField(packet, "d", Enum.valueOf((Class<Enum>) ref.getNMSClass(getEnumScoreboardAction()), "CHANGE"));

			sendPacket(packet);
			lines.put(line, text);
		}
		catch(Exception e) { e.printStackTrace(); }
	}

	public void removeLine(int line)
	{
		try
		{
			sendPacket(ref.getNMSClass("PacketPlayOutScoreboardScore").getConstructor(String.class).newInstance(lines.get(line)));
			lines.remove(line);
		}
		catch(Exception e) { e.printStackTrace(); }
	}

	public void destroy()
	{
		try
		{
			sendPacket(getEditPacket(1, null));
		}
		catch(Exception e) { e.printStackTrace(); }
	}

	@SuppressWarnings({ "unchecked", "rawtypes" })
	private Object getEditPacket(int mode, String name) throws InstantiationException, IllegalAccessException
	{
		Object packet = ref.getNMSClass("PacketPlayOutScoreboardObjective").newInstance();

		ref.setField(packet, "a", player.getName());
		ref.setField(packet, "d", mode);

		if(mode == 0 || mode == 2)
		{
			ref.setField(packet, "b", name);
			ref.setField(packet, "c", Enum.valueOf((Class<Enum>) ref.getNMSClass(getEnumScoreboardHealthDisplay()), "INTEGER"));
		}

		return packet;
	}

	private Object getSettingPacket() throws InstantiationException, IllegalAccessException
	{
		Object packet = ref.getNMSClass("PacketPlayOutScoreboardDisplayObjective").newInstance();
		ref.setField(packet, "a", 1);
		ref.setField(packet, "b", player.getName());

		return packet;
	}

	private void sendPacket(Object packet)
	{
		ref.sendPacket(player, packet);
	}

	private static String getEnumScoreboardHealthDisplay()
	{
		if(Integer.valueOf(Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3].replace("v", "").replace("R", "").replace("_", "")) <= 181) return "EnumScoreboardHealthDisplay";
		return "IScoreboardCriteria$EnumScoreboardHealthDisplay";
	}

	private static String getEnumScoreboardAction()
	{
		if(Integer.valueOf(Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3].replace("v", "").replace("R", "").replace("_", "")) <= 181) return "EnumScoreboardAction";
		return "PacketPlayOutScoreboardScore$EnumScoreboardAction";
	}
}