package org.soulsplit.server.game.minigames.impl.fightpits;

import java.util.ArrayList;

import org.soulsplit.server.constants.ItemIdentifiers;
import org.soulsplit.server.constants.NpcIdentifiers;
import org.soulsplit.server.game.Item;
import org.soulsplit.server.game.minigames.MinigameBoundry;
import org.soulsplit.server.game.minigames.MinigamePlayer;
import org.soulsplit.server.game.minigames.MinigamePlayerActions;
import org.soulsplit.server.game.minigames.MinigamePlayerExecutable;
import org.soulsplit.server.game.minigames.impl.LobbyMinigame;
import org.soulsplit.server.model.players.Player;
import org.soulsplit.server.model.players.content.ContentControl;
import org.soulsplit.server.util.Misc;
import org.soulsplit.server.world.Position;
import org.soulsplit.server.world.entity.RSObject;
import org.soulsplit.server.world.entity.mobile.Mobile;

public class FightPits extends LobbyMinigame {
	public static final int MINIGAME_START_TIMER = 200;
	private static final Position ENTER_WAITING_ROOM = Position.create(2399, 5175);
	private static final Position EXIT_WAITING_ROOM = Position.create(2399, 5177);
	private static final Position EXIT_GAME_TO_WAITING = Position.create(2399, 5169);
	private static final Position MINIGAME_START = Position.create(2392, 5139);

	private int internalAttackTimer;
	private String champion;
	private final ArrayList<MinigameBoundry> MINIGAME_BOUNDRYS = new ArrayList<MinigameBoundry>();
	private final ArrayList<Disabilities> DISABILITIES = new ArrayList<Disabilities>();

	public FightPits() {
		super(MINIGAME_START_TIMER, MinigameRisk.SAFE);
		MINIGAME_BOUNDRYS.add(new MinigameBoundry(Position.create(2375, 5129), Position.create(2418, 5168)));
		MINIGAME_BOUNDRYS.add(new MinigameBoundry( Position.create(2394, 5169), Position.create(2404, 5175)));
		DISABILITIES.add(Disabilities.TELEPORT);
		DISABILITIES.add(Disabilities.TRADE);
		champion = "none";
		internalAttackTimer = 30;
	}

	@Override
	public ArrayList<MinigameBoundry> getMinigameBoundrys() {
		return MINIGAME_BOUNDRYS;
	}


	@Override
	public ArrayList<Disabilities> getDisabilities() {
		return DISABILITIES;
	}

	@Override
	public int getMinimumPlayerSize() {
		return 2;
	}

	@Override
	public void changedState(MinigamePlayer minigamePlayer, PlayerState newState) {
		//Not used here?
	}

	@Override
	public void removePlayer(Player player) {
		super.removePlayer(player);
	}

	@Override
	public void startGame() {
		//Nothing
	}

	@Override
	public void invokeAction(MinigamePlayer player, PlayerActions action, MinigameState minigameState, PlayerState playerState) {
		switch(action) {
		case ENTER_GAME:
			if(ContentControl.FIGHT_PITS.isDisabled()) {
				player.getPlayer().sendMessage("This action is currently disabled temporarily");
				return;
			}
			player.getPlayer().getPA().movePlayer(MINIGAME_START);
			player.setState(PlayerState.IN_GAME);
			break;
		case ENTER_LOBBY:
			player.getPlayer().getPA().movePlayer(ENTER_WAITING_ROOM);
			player.setState(PlayerState.IN_WAITING_ROOM);
			break;
		case PLAYER_DEATH:
			player.getPlayer().getPA().movePlayer(EXIT_GAME_TO_WAITING);
			player.setState(PlayerState.IN_WAITING_ROOM);
			break;
		case REMOVE_PLAYER:
			player.getPlayer().setPosition(EXIT_WAITING_ROOM);
			player.getPlayer().getPA().movePlayer(EXIT_WAITING_ROOM);
			break;
		case PLAYER_KILLED:
			player.getPlayer().sendMessage("You gain a fight pits point for killing a player.");
			player.getPlayer().fightPitsPoints += 1;
			break;
		}
		super.invokeAction(player, action, minigameState, playerState);
	}

	@Override
	public void addPlayer(Player player) {
		super.addPlayer(player);
	}

	@Override
	public void updateInterface(MinigameState state) {
		for(MinigamePlayer player : getPlayerList()) {
			if(state == MinigameState.GAME_STARTED) {
				if(player.getState() == PlayerState.IN_GAME) {
					player.getPlayer().getActionSender().sendFrame126("Foes Remaining: "+(getPlayerList().size()-1), 2805);
				}
				if(player.getState() == PlayerState.IN_WAITING_ROOM) {
					player.getPlayer().getActionSender().sendFrame126("Game has been started.", 2805);
				}
			}

			if(state == MinigameState.WAITING_STATE) {
				if(player.getState() == PlayerState.IN_WAITING_ROOM) {
					player.getPlayer().getActionSender().sendFrame126("Next game begins in "+getMinigameTimer(), 2805);
				}
			}
			player.getPlayer().getActionSender().sendFrame126("Champion: JalYt-Ket-" + champion, 2806);
			player.getPlayer().getPA().walkableInterface(2804);
		}
	}

	@Override
	public boolean endGame() {
		int count = MinigamePlayerActions.getCount(this, PlayerState.IN_GAME);
		if(count <= 1) {
			MinigamePlayer winner = null;
			for(MinigamePlayer mp : getPlayerList()) {
				if(mp.getState() == PlayerState.IN_GAME) {
					winner = mp;
					break;
				}
			}
			if(winner == null) return true;
			winner.getPlayer().getInventory().add(ItemIdentifiers.TOKKUL, Misc.random(1200, 4000));
			winner.getPlayer().fightPitsPoints += 3;
			winner.getPlayer().sendMessage("You get 3 fight pits points for winning.");
			champion = winner.getPlayer().getName();
			return true;
		}
		return false;
	}


	@Override
	public void process() {
		if(getMinigameState() == MinigameState.GAME_STARTED) {
			if(internalAttackTimer > 0) {
				internalAttackTimer--;
			} else if(internalAttackTimer == 0) {
				internalAttackTimer = -1;
				MinigamePlayerActions.invokePlayerFilteredAction(getPlayerList(), new MinigamePlayerExecutable() {
					@Override
					public void run(MinigamePlayer player) {
						player.getPlayer().lastClickedNpc = NpcIdentifiers.TZHAAR_MEJ;
						player.getPlayer().getDialogue().sendNpcChat("Fight!!!");
						player.getPlayer().nextChat = 0;
					}
				}, PlayerState.IN_GAME);
			}
		}
		super.process();
	}

	@Override
	public void resetMinigame() {
		internalAttackTimer = 30;
	}

	@Override
	public MinigameRisk getMinigameRisk() {
		return MinigameRisk.SAFE;
	}

	@Override
	public RightClickOptions getRightClickOption() {
		return RightClickOptions.ATTACK;
	}

	@Override
	public boolean getAttackingRequirements(Player player, final Mobile attackable) {
		if(!attackable.isPlayer()) {
			return false;
		}

		if(this.internalAttackTimer >= 0) {
			player.sendMessage("Please wait for the signal to attack.");
			return false;
		}

		return super.getAttackingRequirements(player, attackable);
	}

	@Override
	public boolean clickObject(Player player, RSObject o, int clickType) {
		return false;
	}

	@Override
	public boolean itemOnObject(Player player, RSObject o, Item item) {
		return false;
	}

	@Override
	public Position getForceOutPosition() {
		return EXIT_WAITING_ROOM;
	}

	@Override
	public void killEntity(Mobile mobile) {
		// TODO Auto-generated method stub

	}
}