package nautilus.game.arcade.managers;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

import mineplex.core.common.Rank;
import mineplex.core.common.util.C;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilGear;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.common.util.UtilTime;
import mineplex.core.itemstack.ItemStackFactory;
import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
import nautilus.game.arcade.ArcadeManager;
import nautilus.game.arcade.GameType;
import nautilus.game.arcade.game.Game.GameState;
import nautilus.game.arcade.gui.privateServer.PrivateServerShop;

import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.HandlerList;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;

public class GameHostManager implements Listener
{
	private HashSet<GameType> ultraGames = new HashSet<GameType>();
	private HashSet<GameType> heroGames = new HashSet<GameType>();
	private HashSet<GameType> legendGames = new HashSet<GameType>();

	ArcadeManager Manager;
	
	private Player _host;
	private long _serverStartTime = System.currentTimeMillis();
	private long _serverExpireTime = 43200000;
	private long _lastOnline = System.currentTimeMillis();
	private long _expireTime = 300000;

	private HashSet<Player> _onlineAdmins = new HashSet<Player>();
	private HashSet<String> _adminList = new HashSet<String>();
	private HashSet<String> _whitelist = new HashSet<String>();
	private HashSet<String> _blacklist = new HashSet<String>();

	private PrivateServerShop _shop;
	
	public GameHostManager(ArcadeManager manager)
	{
		Manager = manager;
		_shop = new PrivateServerShop(manager, manager.GetClients(), manager.GetDonation());
		Manager.GetPluginManager().registerEvents(this, Manager.GetPlugin());

		//Ultra Games
		ultraGames.add(GameType.Smash);
		ultraGames.add(GameType.BaconBrawl);
		ultraGames.add(GameType.DeathTag);
		ultraGames.add(GameType.DragonEscape);
		ultraGames.add(GameType.Dragons);
		ultraGames.add(GameType.Micro);
		ultraGames.add(GameType.Paintball);
		ultraGames.add(GameType.Quiver);
		ultraGames.add(GameType.Runner);
		ultraGames.add(GameType.Sheep);
		ultraGames.add(GameType.Snake);
		ultraGames.add(GameType.SneakyAssassins);
		ultraGames.add(GameType.TurfWars);
		ultraGames.add(GameType.Spleef);

		//Hero Games
		heroGames.add(GameType.ChampionsDominate);
		heroGames.add(GameType.ChampionsTDM);
		heroGames.add(GameType.HideSeek);
		heroGames.add(GameType.Draw);

		//Legend Games
		legendGames.add(GameType.Bridge);
		legendGames.add(GameType.SurvivalGames);
		legendGames.add(GameType.CastleSiege);
		legendGames.add(GameType.MineStrike);

		_blacklist.add("Chiss");
		_blacklist.add("defek7");
		_blacklist.add("Ayreloc");
	}

	@EventHandler
	public void updateHost(UpdateEvent event)
	{
		if (event.getType() != UpdateType.FAST)
			return;
		
		//No Host - Not MPS
		if (Manager.GetHost() == null || Manager.GetHost().length() == 0)
			return;
		
		//Host Update
		if (_host != null)
		{
			giveAdminItem(_host);
			
			_lastOnline = System.currentTimeMillis();
		}

		// Admins update
		for (Player admin : _onlineAdmins)
		{
			giveAdminItem(admin);
		}
	}

	@EventHandler
	public void adminJoin(PlayerJoinEvent event)
	{
		if (!isPrivateServer())
			return;

		if (Manager.GetHost().equals(event.getPlayer().getName()))
		{
			_host = event.getPlayer();
			System.out.println("Game Host Joined.");
		}
		else if (isAdmin(event.getPlayer()))
		{
			System.out.println("Admin Joined.");
			_onlineAdmins.add(event.getPlayer());
		}
	}
	
	@EventHandler
	public void adminQuit(PlayerQuitEvent event)
	{
		if (!isPrivateServer())
			return;
		
		if (isHost(event.getPlayer()))
		{
			System.out.println("Game Host Quit.");
			_host = null;
		}
		else if (isAdmin(event.getPlayer()))
		{
			_onlineAdmins.remove(event.getPlayer());
		}
	}
	
	public boolean isHostExpired()
	{
		if (Manager.GetHost() == null || Manager.GetHost().length() == 0)
			return false;
		
		return UtilTime.elapsed(_lastOnline, _expireTime) || UtilTime.elapsed(_serverStartTime, _serverExpireTime);
	}
	
	private void giveAdminItem(Player player)
	{
		if (Manager.GetGame() == null)
			return;

		if (UtilGear.isMat(player.getInventory().getItem(5), Material.BOOK_AND_QUILL))
			return;
		
		player.getInventory().setItem(5, ItemStackFactory.Instance.CreateStack(Material.BOOK, (byte)0, 1, C.cGreen + C.Bold + "/menu"));
	}
	
	public HashSet<String> getWhitelist()
	{
		return _whitelist;
	}
	
	public HashSet<String> getBlacklist()
	{
		return _blacklist;
	}

	public HashSet<String> getAdminList()
	{
		return _adminList;
	}
	
	@EventHandler
	public void menuCommand(PlayerCommandPreprocessEvent event)
	{
		if (!isAdmin(event.getPlayer()))
			return;
		
		if (!event.getMessage().toLowerCase().startsWith("/menu"))
			return;
		
		openMenu(event.getPlayer());
	}
	
	@EventHandler
	public void menuInteract(PlayerInteractEvent event)
	{
		if (!isAdmin(event.getPlayer()))
			return;
		
		if (!UtilGear.isMat(_host.getItemInHand(), Material.BOOK))
			return;
		
		openMenu(event.getPlayer());
		event.setCancelled(true);
	}
	
	private void openMenu(Player player)
	{
		_shop.attemptShopOpen(player);
	}

	public boolean isAdmin(Player player)
	{
		return player.equals(_host) || _adminList.contains(player.getName());
	}

	public boolean isHost(Player player)
	{
		return player.equals(Manager.GetHost());
	}

	public boolean isPrivateServer()
	{
		return Manager.GetHost() != null || Manager.GetHost().length() > 0;
	}

	@EventHandler
	public void whitelistCommand(PlayerCommandPreprocessEvent event)
	{
		if (_host == null || !event.getPlayer().equals(_host))
			return;
		
		if (!event.getMessage().toLowerCase().startsWith("/whitelist "))
			return;
		
		String[] args = event.getMessage().split(" ");
		
		for (int i=1 ; i<args.length ; i++)
		{
			String name = args[i].toLowerCase();
			
			if (_whitelist.add(name))
			{
				UtilPlayer.message(event.getPlayer(), F.main("Host", "Added " + F.elem(name) + " to the whitelist."));
			}
		}
	}
	
	@EventHandler
	public void setHostDebug(PlayerCommandPreprocessEvent event)
	{
		if (!event.getPlayer().isOp())
			return;
		
		if (!event.getMessage().toLowerCase().startsWith("/sethost "))
			return;
		
		Manager.GetServerConfig().HostName = event.getMessage().split(" ")[1];

		event.getPlayer().sendMessage("Set host to: " + event.getMessage().split(" ")[1]);

		_host = Bukkit.getPlayerExact(Manager.GetServerConfig().HostName);
	}
	
	public void setGame(GameType type)
	{
		if (_host == null)
			return;
		
		Manager.GetGameCreationManager().SetNextGameType(type);
		
		//End Current
		if (Manager.GetGame().GetState() == GameState.Recruit)
		{
			Manager.GetGame().SetState(GameState.Dead);
			
			Bukkit.broadcastMessage(C.cGreen + C.Bold + _host.getName() + " has changed game to " + type.GetName() + ".");
		}
		else
		{
			Bukkit.broadcastMessage(C.cGreen + C.Bold + _host.getName() + " set next game to " + type.GetName() + ".");
		}
	}
	
	public void startGame()
	{
		if (_host == null)
			return;
		
		Manager.GetGameManager().StateCountdown(Manager.GetGame(), 10, true);

		Manager.GetGame().Announce(C.cGreen + C.Bold + _host.getName() + " has started the game.");
	}
	
	public void stopGame()
	{
		if (_host == null)
			return;
		
		if (Manager.GetGame() == null)
			return; 

		HandlerList.unregisterAll(Manager.GetGame());
		
		if (Manager.GetGame().GetState() == GameState.End || Manager.GetGame().GetState() == GameState.End)
		{
			_host.sendMessage("Game is already ending..."); 
			return;
		}
		else if (Manager.GetGame().GetState() == GameState.Recruit)
		{
			Manager.GetGame().SetState(GameState.Dead);
		}
		else
		{
			Manager.GetGame().SetState(GameState.End);
		}


		Manager.GetGame().Announce(C.cGreen + C.Bold + _host.getName() + " has stopped the game.");
	}

	public boolean hasRank(Player player, Rank rank)
	{
		return Manager.GetClients().Get(player).GetRank().Has(rank);
	}

	public List<GameType> getAvailableGames(Player player)
	{
		List<GameType> games = new ArrayList<GameType>();

		if (hasRank(player, Rank.ULTRA))
			games.addAll(ultraGames);
		if (hasRank(player, Rank.HERO))
			games.addAll(heroGames);
		if (hasRank(player, Rank.MODERATOR))
			games.addAll(legendGames);

		return games;
	}

	public void ban(Player player)
	{
		_blacklist.add(player.getName());
		player.kickPlayer("You were banned by the game host");
	}

	public void giveAdmin(Player player)
	{
		_adminList.add(player.getName());
		_onlineAdmins.add(player);
		UtilPlayer.message(player, F.main("Server", "You were given admin privileges for this private server"));
	}
	
	
	public boolean isAdminOnline()
	{
		return _onlineAdmins.isEmpty();
	}
}