TvT BETA

package net.sf.l2j.gameserver.model.entity.events;

import java.util.Calendar;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

import net.sf.l2j.commons.concurrent.ThreadPool;
import net.sf.l2j.commons.random.Rnd;

import net.sf.l2j.Config;
import net.sf.l2j.gameserver.data.ItemTable;
import net.sf.l2j.gameserver.data.sql.SpawnTable;
import net.sf.l2j.gameserver.data.xml.MapRegionData;
import net.sf.l2j.gameserver.data.xml.NpcData;
import net.sf.l2j.gameserver.enums.MessageType;
import net.sf.l2j.gameserver.enums.TeamType;
import net.sf.l2j.gameserver.model.World;
import net.sf.l2j.gameserver.model.actor.Creature;
import net.sf.l2j.gameserver.model.actor.Npc;
import net.sf.l2j.gameserver.model.actor.Player;
import net.sf.l2j.gameserver.model.actor.Summon;
import net.sf.l2j.gameserver.model.actor.instance.Pet;
import net.sf.l2j.gameserver.model.actor.template.NpcTemplate;
import net.sf.l2j.gameserver.model.entity.Duel.DuelState;
import net.sf.l2j.gameserver.model.group.Party;
import net.sf.l2j.gameserver.model.holder.IntIntHolder;
import net.sf.l2j.gameserver.model.olympiad.OlympiadManager;
import net.sf.l2j.gameserver.model.spawn.L2Spawn;
import net.sf.l2j.gameserver.network.serverpackets.MagicSkillUse;

/**
 * @author Williams
 *
 */
public final class TvTEvent extends Event
{
	private List<Player> _registered = new CopyOnWriteArrayList<>();
	private List<Player> _blueTeam = new CopyOnWriteArrayList<>();
	private List<Player> _redTeam = new CopyOnWriteArrayList<>();

	private Npc _npcManager;

	private int _tick;

	private TvTEvent()
	{
		if (Config.TVT_ENABLE)
		{
			_state = EventState.AWAITING;
			ThreadPool.scheduleAtFixedRate(this, 1000, 1000);
			LOGGER.info("TvTEvent: Engine is enable.");
		}
		else
		{
			_state = EventState.INACTIVE;
			LOGGER.info("TvTEvent: Engine is disabled.");
		}
	}

	@Override
	public void run()
	{
		if (_state == EventState.AWAITING)
		{
			final Calendar calendar = Calendar.getInstance();
			final int hour = calendar.get(Calendar.HOUR_OF_DAY);
			final int minute = calendar.get(Calendar.MINUTE);

			for (String time : Config.TVT_SCHEDULER_TIMES)
			{
				final String[] splitTime = time.split(":");
				if (Integer.parseInt(splitTime[0]) == hour && Integer.parseInt(splitTime[1]) == minute)
				{
					register();
					break;
				}
			}
		}
		else if (_state == EventState.REGISTRATION)
		{
			switch (_tick)
			{
				case 7200:
				case 3600:
					World.announceToOnlinePlayers("TvTEvent: " + _tick / 3600 + " hour(s) until registration is closed!", true);
					break;

				case 1800:
				case 900:
				case 600:
				case 300:
				case 180:
				case 60:
					World.announceToOnlinePlayers("TvTEvent: " + _tick / 60 + " minute(s) until registration is closed!", true);
					break;

				case 30:
				case 10:
				case 5:
					World.announceToOnlinePlayers("TvTEvent: " + _tick + " second(s) until registration is closed!", true);
					break;
			}

			if (_tick == 0)
				prepareTeams();

			_tick--;
		}
		else if (_state == EventState.PROCESSING)
		{
			switch (_tick)
			{
				case 7200:
				case 3600:
					World.announceToOnlinePlayers(_tick / 3600 + " hour(s) until event is finished!");
					break;

				case 1800:
				case 900:
				case 600:
				case 300:
				case 60:
					World.announceToOnlinePlayers(_tick / 60 + " minute(s) until the event is finished!");
					break;

				case 30:
				case 10:
					World.announceToOnlinePlayers(_tick + " second(s) until the event is finished!");
					break;
			}

			if (_tick == 0)
				eventRemovals();

			_tick--;
		}
	}

	public void register()
	{
		if (Config.TVT_ENABLE)
		{
			_state = EventState.REGISTRATION;

			try
			{
				final NpcTemplate template = NpcData.getInstance().getTemplate(Config.TVT_NPC_ID);
				final L2Spawn spawn = new L2Spawn(template);
				spawn.setLoc(Config.TVT_NPC_LOCATION.getX(), Config.TVT_NPC_LOCATION.getY(), Config.TVT_NPC_LOCATION.getZ(), 0);
				spawn.setRespawnDelay(60000);
				spawn.setRespawnState(false);

				SpawnTable.getInstance().addSpawn(spawn, false);

				_npcManager = spawn.doSpawn(false);
				_npcManager.broadcastPacket(new MagicSkillUse(_npcManager, _npcManager, 1034, 1, 1, 1));
			}
			catch (Exception e){}

			World.announceToOnlinePlayers("TvT Event: Recruiting levels: " + Config.MIN_LEVEL + " to " + Config.MAX_LEVEL + ".", true);
			World.announceToOnlinePlayers("TvT Event: Max players in team: "+ Config.MAX_PARTICIOANTS +".", true);
			World.announceToOnlinePlayers("TvT Event: Commands /register /unregister.", true);

			for (IntIntHolder reward: Config.TVT_REWARDS)
				World.announceToOnlinePlayers("TvT Event: Reward "+ reward.getValue() + "-" + ItemTable.getInstance().getTemplate(reward.getId()).getName() , true);

			_tick = Config.TVT_PARTICIPATION_TIME * 60;
		}
		else
			_state = EventState.AWAITING;
	}

	public void prepareTeams()
	{
		if (Config.TVT_ENABLE)
		{
			_state = EventState.PROCESSING;
			_tick = Config.TVT_RUNNING_TIME * 60;

			while (_registered.size() > 0)
			{
				Player player = _registered.get(Rnd.get(_registered.size()));

				// First create 2 event teams
				if (_blueTeam.size() > _redTeam.size())
				{
					_redTeam.add(player);
					player.setTeam(TeamType.RED);
				}
				else
				{
					_blueTeam.add(player);
					player.setTeam(TeamType.BLUE);
				}

				// Abort casting if player casting
				if (player.isCastingNow())
					player.abortCast();

				player.getAppearance().setVisible();

				if (player.isDead())
					player.doRevive();
				else
				{
					player.setCurrentHpMp(player.getMaxHp(), player.getMaxMp());
					player.setCurrentCp(player.getMaxCp());
				}

				// Remove Buffs
				player.stopAllEffectsExceptThoseThatLastThroughDeath();

				// stop any cubic that has been given by other player.
				player.stopCubicsByOthers();

				// Dismount player, if mounted.
				if (player.isMounted())
					player.dismount();
				else
				{
					final Summon summon = player.getSummon();

					// Unsummon pets directly.
					if (summon instanceof Pet)
						summon.unSummon(player);
					// Remove servitor buffs and cancel animations.
					else if (summon != null)
					{
						summon.stopAllEffectsExceptThoseThatLastThroughDeath();
						summon.abortAttack();
						summon.abortCast();
					}
				}

				// Remove player from his party
				if (player.getParty() != null)
				{
					Party party = player.getParty();
					party.removePartyMember(player, MessageType.EXPELLED);
				}

				// Remove Duel State
				if (player.isInDuel())
					player.setDuelState(DuelState.INTERRUPTED);

				_registered.remove(player);
			}

			// Port teams
			for (Player blue : _blueTeam)
			{
				if (blue == null)
					continue;

				blue.teleToLocation(Config.TVT_BLUE_SPAWN_LOCATION);
			}

			for (Player red : _redTeam)
			{
				if (red == null)
					continue;

				red.teleToLocation(Config.TVT_RED_SPAWN_LOCATION);
			}
		}
		else
		{
			World.announceToOnlinePlayers("TvTEvent: cancelled due to lack of Participation.", true);
			_state = EventState.AWAITING;
		}
	}

	public void eventRemovals()
	{
		// Blue team
		for (Player blue : _blueTeam)
		{
			if (blue == null)
				continue;

			// Give rewards
			if (_state != EventState.AWAITING && (blue.getBlueKills() > blue.getRedKills() || blue.getBlueKills() == blue.getRedKills() && Config.REWARD_DIE))
			{
				for (IntIntHolder reward : Config.TVT_REWARDS)
				{
					if (reward == null)
						continue;

					blue.addItem("TvTReward", reward.getId(), reward.getValue(), null, true);
				}
			}

			if (blue.isDead())
				blue.doRevive();

			removePlayer(blue);
			blue.teleToLocation(Config.TVT_NPC_LOCATION);
		}

		// Red team
		for (Player red : _redTeam)
		{
			if (red == null)
				continue;

			// Give rewards
			if (_state != EventState.AWAITING && (red.getBlueKills() < red.getRedKills() || red.getBlueKills() == red.getRedKills() && Config.REWARD_DIE))
			{
				for (IntIntHolder reward : Config.TVT_REWARDS)
				{
					if (reward == null)
						continue;

					red.addItem("TvTReward", reward.getId(), reward.getValue(), null, true);
				}
			}

			if (red.isDead())
				red.doRevive();

			removePlayer(red);
			red.teleToLocation(Config.TVT_NPC_LOCATION);
		}

		for (Player player : World.getInstance().getPlayers())
		{
			// Event ended in a tie and no rewards will be given
			if (player.getBlueKills() == player.getRedKills() && !Config.REWARD_DIE)
				World.announceToOnlinePlayers("TvT Event: Event ended in a Tie. No rewards will be given!", true);

			// clean teams
			_blueTeam.clear();
			_redTeam.clear();

			// clean kills
			player.getBlueKills();
			player.getRedKills();
		}
		_state = EventState.AWAITING;
	}

	@Override
	public void registerPlayer(Player player)
	{
		if (_state != EventState.REGISTRATION)
		{
			player.sendMessage("TvT Registration is not in progress.");
			return;
		}

		if (player.isFestivalParticipant())
		{
			player.sendMessage("Festival participants cannot register to the event.");
			return;
		}

		if (player.isInJail())
		{
			player.sendMessage("Jailed players cannot register to the event.");
			return;
		}

		if (player.isDead())
		{
			player.sendMessage("Dead players cannot register to the event.");
			return;
		}

		if (OlympiadManager.getInstance().isRegisteredInComp(player))
		{
			player.sendMessage("Grand Olympiad participants cannot register to the event.");
			return;
		}

		if ((player.getLevel() < Config.MIN_LEVEL) || (player.getLevel() > Config.MAX_LEVEL))
		{
			player.sendMessage("You have not reached the appropriate level to join the event.");
			return;
		}

		if (_registered.size() == Config.MAX_PARTICIOANTS)
		{
			player.sendMessage("There is no more room for you to register to the event.");
			return;
		}

		for (Player registered : _registered)
		{
			if (registered == null)
				continue;

			if (registered.getObjectId() == player.getObjectId())
			{
				player.sendMessage("You are already registered in the TvT event.");
				return;
			}

			// Check if dual boxing is not allowed
			if (!Config.DUAL_BOX)
			{
				if ((registered.getClient() == null) || (player.getClient() == null))
					continue;

				String ip1 = player.getClient().getConnection().getInetAddress().getHostAddress();
				String ip2 = registered.getClient().getConnection().getInetAddress().getHostAddress();
				if ((ip1 != null) && (ip2 != null) && ip1.equals(ip2))
				{
					player.sendMessage("Your IP is already registered in the TvT event.");
					return;
				}
			}
		}

		_registered.add(player);

		player.sendMessage("You have registered to participate in the TvT Event.");

		super.registerPlayer(player);
	}

	@Override
	public void removePlayer(Player player)
	{
		if (_registered.contains(player))
		{
			_registered.remove(player);
			player.sendMessage("You have been removed from the TvT Event registration list.");
		}
		else if (player.getTeam() == TeamType.BLUE)
			_blueTeam.remove(player);
		else if (player.getTeam() == TeamType.RED)
			_redTeam.remove(player);

		// If no participants left, abort event
		if ((player.getTeam().getId() > 0) && (_blueTeam.size() == 0) && (_redTeam.size() == 0))
			_state = EventState.AWAITING;

		// Now, remove team status
		player.setTeam(TeamType.NONE);

		super.removePlayer(player);
	}

	@Override
	public boolean isRegistered(Player player)
	{
		return _registered.contains(player);
	}

	public List<Player> getBlueTeam()
	{
		return _blueTeam;
	}

	public List<Player> getRedTeam()
	{
		return _redTeam;
	}

	public List<Player> getRegistered()
	{
		return _registered;
	}

	@Override
	public void onDie(Creature killer)
	{
		if (killer == null)
			return;

		if (killer instanceof Player)
		{
			final Player player = ((Player) killer);

			player.sendMessage("You will be respawned in " + Config.PLAYER_RESPAWN_DELAY + " seconds.");
			ThreadPool.schedule(new Runnable()
			{
				@Override
				public void run()
				{
					if (!player.isDead())
						return;

					player.doRevive();

					if (player.getTeam() == TeamType.BLUE)
						player.teleToLocation(Config.TVT_BLUE_SPAWN_LOCATION);
					else if (player.getTeam() == TeamType.RED)
						player.teleToLocation(Config.TVT_RED_SPAWN_LOCATION);
					// Player has probably left event for some reason
					else
						player.teleportTo(MapRegionData.TeleportType.TOWN);
				}
			}, Config.PLAYER_RESPAWN_DELAY * 1000L);
		}
	}

	@Override
	public void onKill(Player player, Player target)
	{
		if (player == null || target == null)
			return;

		// Increase kills only if victim belonged to enemy team
		if (player.getTeam() == TeamType.BLUE && target.getTeam() == TeamType.RED)
			player.increaseBlueKills();
		else if (player.getTeam() == TeamType.RED && target.getTeam() == TeamType.BLUE)
			player.increaseRedKills();

		player.broadcastTitleInfo();
		player.broadcastUserInfo();
	}

	@Override
	public void onRevive(Creature killer)
	{
		if (killer == null)
			return;

		// Heal Player fully
		killer.setCurrentHpMp(killer.getMaxHp(), killer.getMaxMp());
		killer.setCurrentCp(killer.getMaxCp());
	}

	public static final TvTEvent getInstance()
	{
		return SingletonHolder.INSTANCE;
	}

	private static class SingletonHolder
	{
		protected static final TvTEvent INSTANCE = new TvTEvent();
	}
}