package mineplex.hub.modules;

import java.util.HashMap;
import java.util.Iterator;

import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;

import mineplex.core.MiniPlugin;
import mineplex.core.common.util.C;
import mineplex.core.common.util.Callback;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilDisplay;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.common.util.UtilServer;
import mineplex.core.common.util.UtilTime;
import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
import mineplex.hub.HubManager;
import mineplex.hub.HubRepository;
import mineplex.hub.mount.Mount;
import mineplex.hub.mount.types.Dragon;

public class NewsManager extends MiniPlugin
{
	public HubManager Manager;
	
	private String[] _news;
	private int _newsIndex = 0;
	private long _newsTime = System.currentTimeMillis();
	
	private int _mineplexIndex = 0;

	private HubRepository _repository = new HubRepository();
	
	public NewsManager(HubManager manager)
	{
		super("News Manager", manager.GetPlugin());
	
		Manager = manager;
		
		_repository.initialize(manager.GetPlugin().getConfig().getBoolean("serverstatus.us"));
		
		_news = new String[] 
				{
				"Champions: " + C.cYellow + C.Bold + "Team Deathmatch Beta",
				"Survival: " + C.cGreen + C.Bold + "UHC Alpha",	
				};
		
		RefreshNews();
	}
	
	private void RefreshNews()
	{		
		RetriveNewsEntries(new Callback<HashMap<String, String>>()
		{
			public void run(final HashMap<String, String> newsEntries)
			{
				// Order newsEntries set or its output by newsPosition, not hash order...
				RetrieveMaxNewsPosition(new Callback<Integer>()
				{
					public void run(Integer maxPosition)
					{
						String[] newsStrings = new String[maxPosition];
						for (Iterator<String> iterator = newsEntries.keySet().iterator(); iterator.hasNext();)
						{
							String newsPosition = iterator.next();
							newsStrings[Integer.parseInt(newsPosition) - 1] = newsEntries.get(newsPosition);
						}
					
						_news = newsStrings;
					}
				});
			}
		});
	}

	public void RetriveNewsEntries(final Callback<HashMap<String, String>> callback)
	{
		if (callback == null)
			return;
		
		Bukkit.getScheduler().runTaskAsynchronously(GetPlugin(), new Runnable()
		{
			public void run()
			{
				final HashMap<String, String> newsEntries = _repository.retrieveNewsEntries();
				
				Bukkit.getScheduler().runTask(GetPlugin(), new Runnable()
				{
					public void run()
					{
						callback.run(newsEntries);
					}
				});
			}
		});
	}
	
	public void SetNewsEntry(final String newsEntry, final int newsPosition, final Callback<Boolean> callback)
	{
		if (callback == null)
			return;
		
		Bukkit.getScheduler().runTaskAsynchronously(GetPlugin(), new Runnable()
		{
			public void run()
			{
				final Boolean success = _repository.setNewsEntry(newsEntry, newsPosition);
				
				Bukkit.getScheduler().runTask(GetPlugin(), new Runnable()
				{
					public void run()
					{
						callback.run(success);
					}
				});
			}
		});
	}
	
	public void AddNewsEntry(final String newsEntry, final Callback<Boolean> callback)
	{
		if (callback == null)
			return;
		
		Bukkit.getScheduler().runTaskAsynchronously(GetPlugin(), new Runnable()
		{
			public void run()
			{
				final Boolean success = _repository.addNewsEntry(newsEntry);
				
				Bukkit.getScheduler().runTask(GetPlugin(), new Runnable()
				{
					public void run()
					{
						callback.run(success);
					}
				});
			}
		});
	}
	
	public void DeleteNewsEntry(final int newsPosition, final Callback<Boolean> callback)
	{
		if (callback == null)
			return;
		
		Bukkit.getScheduler().runTaskAsynchronously(GetPlugin(), new Runnable()
		{
			public void run()
			{
				final Boolean success = _repository.deleteNewsEntry(newsPosition);
				
				Bukkit.getScheduler().runTask(GetPlugin(), new Runnable()
				{
					public void run()
					{
						callback.run(success);
					}
				});
			}
		});
	}

	public void RetrieveMaxNewsPosition(final Callback<Integer> callback)
	{
		if (callback == null)
			return;
		
		Bukkit.getScheduler().runTaskAsynchronously(GetPlugin(), new Runnable()
		{
			public void run()
			{
				final Integer position = _repository.retrieveMaxNewsPosition();
				
				Bukkit.getScheduler().runTask(GetPlugin(), new Runnable()
				{
					public void run()
					{
						callback.run(position);
					}
				});
			}
		});
	}
	
	@EventHandler
	public void NewsUpdate(UpdateEvent event)
	{
		if (event.getType() != UpdateType.MIN_04)
			return;
		
		RefreshNews();
	}
	
	@EventHandler
	public void FlightUpdate(UpdateEvent event)
	{
		if (event.getType() != UpdateType.FASTEST)
			return;

		//Mineplex Color
		ChatColor col = ChatColor.RED;
		if (_mineplexIndex == 1)	col = ChatColor.GOLD;
		else if (_mineplexIndex == 2)	col = ChatColor.YELLOW;
		else if (_mineplexIndex == 3)	col = ChatColor.GREEN;
		else if (_mineplexIndex == 4)	col = ChatColor.AQUA;
		else if (_mineplexIndex == 5)	col = ChatColor.LIGHT_PURPLE;
		_mineplexIndex = (_mineplexIndex + 1)%6;
		
		//News Change
		if (UtilTime.elapsed(_newsTime, 4500))
		{
			_newsIndex = (_newsIndex + 1)%_news.length;
			_newsTime = System.currentTimeMillis();
		}		
		if (_newsIndex >= _news.length)
		{
			// Resets newsIndex if outside of bounds of news array after RefreshNews but before UtilTime.elapsed above
			_newsIndex = 0;
		}
		
		//Text
		String text = col + C.Bold + "MINEPLEX" + ChatColor.RESET + " - " + _news[_newsIndex];
		if (text.length() > 64)
			text = text.substring(0, 64);
			
		for (Player player : UtilServer.getPlayers())
			UtilDisplay.displayTextBar(Manager.GetPlugin(), player, (double)_newsIndex/(double)(_news.length-1), text);
		
		for (Mount mount : Manager.GetMount().getMounts())
		{
			if (mount instanceof Dragon)
			{
				((Dragon)mount).SetName(text);
			}
		}	
	}
}