package l2f.gameserver.model.entity.events.impl;

import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.StringTokenizer;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ScheduledFuture;

import javolution.util.FastMap;
import l2f.commons.annotations.Nullable;
import l2f.commons.collections.MultiValueSet;
import l2f.commons.threading.RunnableImpl;
import l2f.commons.util.Rnd;
import l2f.gameserver.Config;
import l2f.gameserver.ThreadPoolManager;
import l2f.gameserver.data.xml.holder.InstantZoneHolder;
import l2f.gameserver.database.DatabaseFactory;
import l2f.gameserver.instancemanager.ReflectionManager;
import l2f.gameserver.listener.actor.player.OnPlayerExitListener;
import l2f.gameserver.listener.zone.OnZoneEnterLeaveListener;
import l2f.gameserver.model.Creature;
import l2f.gameserver.model.Effect;
import l2f.gameserver.model.GameObject;
import l2f.gameserver.model.GameObjectsStorage;
import l2f.gameserver.model.Party;
import l2f.gameserver.model.Playable;
import l2f.gameserver.model.Player;
import l2f.gameserver.model.SimpleSpawner;
import l2f.gameserver.model.Skill;
import l2f.gameserver.model.World;
import l2f.gameserver.model.Zone;
import l2f.gameserver.model.base.InvisibleType;
import l2f.gameserver.model.base.RestartType;
import l2f.gameserver.model.entity.Reflection;
import l2f.gameserver.model.entity.events.GlobalEvent;
import l2f.gameserver.model.entity.events.fightclubmanager.FightClubEventManager;
import l2f.gameserver.model.entity.events.fightclubmanager.FightClubEventManager.CLASSES;
import l2f.gameserver.model.entity.events.fightclubmanager.FightClubGameRoom;
import l2f.gameserver.model.entity.events.fightclubmanager.FightClubLastStatsManager;
import l2f.gameserver.model.entity.events.fightclubmanager.FightClubLastStatsManager.FightClubStatType;
import l2f.gameserver.model.entity.events.fightclubmanager.FightClubMap;
import l2f.gameserver.model.entity.events.fightclubmanager.FightClubPlayer;
import l2f.gameserver.model.entity.events.fightclubmanager.FightClubTeam;
import l2f.gameserver.model.instances.NpcInstance;
import l2f.gameserver.model.instances.PetInstance;
import l2f.gameserver.model.instances.SchemeBufferInstance;
import l2f.gameserver.model.pledge.Clan;
import l2f.gameserver.network.serverpackets.Earthquake;
import l2f.gameserver.network.serverpackets.ExPVPMatchCCRecord;
import l2f.gameserver.network.serverpackets.ExPVPMatchCCRetire;
import l2f.gameserver.network.serverpackets.ExShowScreenMessage;
import l2f.gameserver.network.serverpackets.RelationChanged;
import l2f.gameserver.network.serverpackets.Say2;
import l2f.gameserver.network.serverpackets.TutorialShowQuestionMark;
import l2f.gameserver.network.serverpackets.components.ChatType;
import l2f.gameserver.network.serverpackets.components.SystemMsg;
import l2f.gameserver.skills.AbnormalEffect;
import l2f.gameserver.tables.SkillTable;
import l2f.gameserver.templates.DoorTemplate;
import l2f.gameserver.templates.InstantZone;
import l2f.gameserver.templates.ZoneTemplate;
import l2f.gameserver.utils.BatchStatement;
import l2f.gameserver.utils.Location;
import l2f.gameserver.utils.Util;

import org.apache.commons.lang3.reflect.MethodUtils;
import org.napile.primitive.maps.IntObjectMap;
import org.napile.primitive.maps.impl.HashIntObjectMap;

public abstract class AbstractFightClub extends GlobalEvent {
    private class ExitListener implements OnPlayerExitListener {
        @Override
        public void onPlayerExit(Player player) {
            loggedOut(player);
        }
    }

    private class ZoneListener implements OnZoneEnterLeaveListener {
        @Override
        public void onZoneEnter(Zone zone, Creature actor) {
            if (actor.isPlayer()) {
                FightClubPlayer fPlayer = getFightClubPlayer(actor);
                if (fPlayer != null) {
                    actor.sendPacket(new Earthquake(actor.getLoc(), 0, 1));
                    _leftZone.remove(getFightClubPlayer(actor));
                }
            }
        }

        @Override
        public void onZoneLeave(Zone zone, Creature actor) {
            if (actor.isPlayer() && _state != EVENT_STATE.NOT_ACTIVE) {
                FightClubPlayer fPlayer = getFightClubPlayer(actor);
                if (fPlayer != null)
                    _leftZone.put(getFightClubPlayer(actor), zone);
            }
        }
    }

    public static enum EVENT_STATE {
        NOT_ACTIVE, COUNT_DOWN, PREPARATION, STARTED, OVER
    }

    public static final String REGISTERED_PLAYERS = "registered_players";
    public static final String LOGGED_OFF_PLAYERS = "logged_off_players";
    public static final String FIGHTING_PLAYERS = "fighting_players";

    public static final int INSTANT_ZONE_ID = 400;
    private static final int CLOSE_LOCATIONS_VALUE = 150;// Used for spawning
                                                            // players
    private static int LAST_OBJECT_ID = 1;// Used for event object id

    private static final int BADGES_FOR_MINUTE_OF_AFK = -1;

    private static final int TIME_FIRST_TELEPORT = 10;// in seconds
    private static final int TIME_PLAYER_TELEPORTING = 15;// in seconds
    private static final int TIME_PREPARATION_BEFORE_FIRST_ROUND = 30;// in
                                                                        // seconds
    private static final int TIME_PREPARATION_BETWEEN_NEXT_ROUNDS = 30;// in
                                                                        // seconds
                                                                        // -
                                                                        // usable
                                                                        // if
                                                                        // there
                                                                        // are
                                                                        // more
                                                                        // than
                                                                        // 1
                                                                        // round
    private static final int TIME_AFTER_ROUND_END_TO_RETURN_SPAWN = 15;// in
                                                                        // seconds
                                                                        // -
                                                                        // usable
                                                                        // if
                                                                        // there
                                                                        // are
                                                                        // more
                                                                        // than
                                                                        // 1
                                                                        // round
    private static final int TIME_TELEPORT_BACK_TOWN = 30;// in seconds
    private static final int TIME_MAX_SECONDS_OUTSIDE_ZONE = 10;
    private static final int TIME_TO_BE_AFK = 120;

    private static final String[] ROUND_NUMBER_IN_STRING = { "", "1st", "2nd", "3rd", "4th", "5th", "6th", "7th", "8th",
            "9th", "10th" };

    // Properties
    private final int _objId;
    private final String _desc;
    private final String _icon;
    private final int _roundRunTime;// in minutes
    private final boolean _isAutoTimed;
    private final int[][] _autoStartTimes;
    private final boolean _teamed;
    private final boolean _buffer;
    private final int[][] _fighterBuffs;
    private final int[][] _mageBuffs;
    private final boolean _rootBetweenRounds;
    private final CLASSES[] _excludedClasses;
    private final int[] _excludedSkills;
    private final boolean _roundEvent;
    private final int _rounds;
    private final int _respawnTime;// in seconds
    private final boolean _ressAllowed;
    private final boolean _instanced;
    private final boolean _showPersonality;
    // Badges
    private final double _badgesKillPlayer;
    // private final double _badgesKillPet;
    // private final double _badgesDie;
    protected final double _badgeWin;
    private final int topKillerReward;

    // Event variables
    protected EVENT_STATE _state = EVENT_STATE.NOT_ACTIVE;
    private ExitListener _exitListener = new ExitListener();
    private ZoneListener _zoneListener = new ZoneListener();
    private FightClubMap _map;
    private Reflection _reflection;
    private final List<FightClubTeam> _teams = new CopyOnWriteArrayList<>();
    private final Map<FightClubPlayer, Zone> _leftZone = new ConcurrentHashMap<>();
    private int _currentRound = 0;
    private boolean _dontLetAnyoneIn = false;
    private FightClubGameRoom _room;

    // For duplicating events:
    private MultiValueSet<String> _set;

    // Scores

    private final Map<Integer, Integer> _rscores = new ConcurrentHashMap<>();
    private final Map<String, Integer> _scores = new ConcurrentHashMap<>();
    private Map<String, Integer> _bestScores = new ConcurrentHashMap<>();
    private boolean _scoredUpdated = true;

    // Before event start
    private ScheduledFuture<?> _timer;

    public AbstractFightClub(MultiValueSet<String> set) {
        super(set);
        _objId = LAST_OBJECT_ID++;
        _desc = set.getString("desc");
        _icon = set.getString("icon");
        _roundRunTime = set.getInteger("roundRunTime", -1);
        _teamed = set.getBool("teamed");
        _buffer = set.getBool("buffer");
        _fighterBuffs = parseBuffs(set.getString("fighterBuffs", null));
        _mageBuffs = parseBuffs(set.getString("mageBuffs", null));
        _rootBetweenRounds = set.getBool("rootBetweenRounds");
        _excludedClasses = parseExcludedClasses(set.getString("excludedClasses", ""));
        _excludedSkills = parseExcludedSkills(set.getString("excludedSkills", null));
        _isAutoTimed = set.getBool("isAutoTimed", false);
        _autoStartTimes = parseAutoStartTimes(set.getString("autoTimes", ""));
        _roundEvent = set.getBool("roundEvent");
        _rounds = set.getInteger("rounds", -1);
        _respawnTime = set.getInteger("respawnTime");
        _ressAllowed = set.getBool("ressAllowed");
        _instanced = set.getBool("instanced", true);
        _showPersonality = set.getBool("showPersonality", true);
        // Badges
        _badgesKillPlayer = set.getDouble("badgesKillPlayer", 0);
        // _badgesKillPet = set.getDouble("badgesKillPet", 0);
        // _badgesDie = set.getDouble("badgesDie", 0);
        _badgeWin = set.getDouble("badgesWin", 0);
        topKillerReward = set.getInteger("topKillerReward", 0);

        _set = set;
    }

    /**
     * - Getting map - Saving room - Saving all players from Room as Registered
     * in Event - Starting Teleport Timer
     *
     * @param room
     *            of the event
     */
    public void prepareEvent(FightClubGameRoom room) {
        _map = room.getMap();
        _room = room;

        for (Player player : room.getAllPlayers()) {
            addObject(REGISTERED_PLAYERS, new FightClubPlayer(player));
            player.addEvent(this);
        }

        startTeleportTimer(room);
    }

    @Override
    public void startEvent() {
        super.startEvent();

        _state = EVENT_STATE.PREPARATION;

        // Getting all zones
        IntObjectMap<DoorTemplate> doors = new HashIntObjectMap<>(0);
        Map<String, ZoneTemplate> zones = new HashMap<>();
        for (Entry<Integer, Map<String, ZoneTemplate>> entry : getMap().getTerritories().entrySet()) {
            for (Entry<String, ZoneTemplate> team : entry.getValue().entrySet()) {
                zones.put(team.getKey(), team.getValue());
            }
        }

        // Creating reflection if needed
        if (isInstanced())
            createReflection(doors, zones);

        List<FightClubPlayer> playersToRemove = new ArrayList<>();
        for (FightClubPlayer iFPlayer : getPlayers(REGISTERED_PLAYERS)) {
            stopInvisibility(iFPlayer.getPlayer());
            if (!checkIfRegisteredPlayerMeetCriteria(iFPlayer)) {
                playersToRemove.add(iFPlayer);
                continue;
            }

            if (isHidePersonality())
                iFPlayer.getPlayer()
                        .setPolyId(FightClubGameRoom.getPlayerClassGroup(iFPlayer.getPlayer()).getTransformId());
        }

        for (FightClubPlayer playerToRemove : playersToRemove)
            unregister(playerToRemove.getPlayer());

        if (isTeamed()) {
            spreadIntoTeamsAndPartys();
        }

        teleportRegisteredPlayers();

        updateEveryScore();

        for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS, REGISTERED_PLAYERS)) {
            iFPlayer.getPlayer().isntAfk();
            iFPlayer.getPlayer().setFightClubGameRoom(null);
            SchemeBufferInstance.showWindow(iFPlayer.getPlayer());
        }

        startNewTimer(true, TIME_PLAYER_TELEPORTING * 1000, "startRoundTimer", TIME_PREPARATION_BEFORE_FIRST_ROUND);

        ThreadPoolManager.getInstance().schedule(new LeftZoneThread(), 5000L);
    }

    public void startRound() {
        _state = EVENT_STATE.STARTED;

        _currentRound++;

        if (isRoundEvent())
            if (_currentRound == _rounds)
                sendMessageToFighting(MESSAGE_TYPES.SCREEN_BIG, "Last Round STARTED!", true);
            else
                sendMessageToFighting(MESSAGE_TYPES.SCREEN_BIG, "Round " + _currentRound + " STARTED!", true);
        else
            sendMessageToFighting(MESSAGE_TYPES.SCREEN_BIG, "Fight!", true);

        unrootPlayers();

        if (getRoundRuntime() > 0) {
            startNewTimer(true, (int) ((double) getRoundRuntime() / 2 * 60000), "endRoundTimer",
                    (int) ((double) getRoundRuntime() / 2 * 60));
        }

        if (_currentRound == 1) {
            ThreadPoolManager.getInstance().schedule(new TimeSpentOnEventThread(), 10 * 1000);
            ThreadPoolManager.getInstance().schedule(new CheckAfkThread(), 1000);
        }

        for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS)) {
            iFPlayer.getPlayer().updateZones();
            hideScores(iFPlayer.getPlayer());
            iFPlayer.getPlayer().broadcastUserInfo(true);
        }
    }

    public void endRound() {
        _state = EVENT_STATE.OVER;

        if (!isLastRound())
            sendMessageToFighting(MESSAGE_TYPES.SCREEN_BIG, "Round " + _currentRound + " is over!", false);
        else {
            sendMessageToFighting(MESSAGE_TYPES.SCREEN_BIG, "Event is now Over!", false);

        }

        ressAndHealPlayers();

        for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS))
            showScores(iFPlayer.getPlayer());

        if (!isLastRound()) {
            // Changing team spawn location
            if (isTeamed()) {
                for (FightClubTeam team : getTeams())
                    team.setSpawnLoc(null);
            }

            ThreadPoolManager.getInstance().schedule(() -> {
                for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS)) {
                    teleportSinglePlayer(iFPlayer, false, true);
                }

                startNewTimer(true, 0, "startRoundTimer", TIME_PREPARATION_BETWEEN_NEXT_ROUNDS);

            }, TIME_AFTER_ROUND_END_TO_RETURN_SPAWN * 1000);
        } else {
            ThreadPoolManager.getInstance().schedule(() -> stopEvent(), 10 * 1000);

            if (isTeamed())
                announceWinnerTeam(true, null);
            else
                announceWinnerPlayer(true, null);
        }

        for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS))
            iFPlayer.getPlayer().broadcastUserInfo(true);
    }

    @Override
    public void stopEvent() {
        _state = EVENT_STATE.NOT_ACTIVE;
        super.stopEvent();
        reCalcNextTime(false);
        _room = null;

        showLastAFkMessage();
        FightClubPlayer[] topKillers = getTopKillers();
        announceTopKillers(topKillers);
        giveRewards(topKillers);
        saveResults();

        for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS)) {
            iFPlayer.getPlayer().broadcastCharInfo();
            if (iFPlayer.getPlayer().getPet() != null)
                iFPlayer.getPlayer().getPet().broadcastCharInfo();
        }
        for (Player player : getAllFightingPlayers()) {
            showScores(player);
        }

        ThreadPoolManager.getInstance().schedule(() -> {
            for (Player player : getAllFightingPlayers()) {
                leaveEvent(player, true);
                player.sendPacket(
                        new ExShowScreenMessage("", 10, ExShowScreenMessage.ScreenMessageAlign.TOP_LEFT, false));
            }
            destroyMe();
        }, 10 * 1000);
    }

    public void destroyMe() {
        if (getReflection() != null) {
            for (Zone zone : getReflection().getZones())
                zone.removeListener(_zoneListener);
            getReflection().collapse();
        }
        if (_timer != null)
            _timer.cancel(false);
        _timer = null;
        _bestScores.clear();
        _scores.clear();
        _rscores.clear();
        _leftZone.clear();
        getObjects().clear();
        _set = null;
        _room = null;
        _zoneListener = null;
        for (Player player : GameObjectsStorage.getAllPlayersForIterate())
            player.removeListener(_exitListener);
        _exitListener = null;
    }

    // ===============================================================================================================
    // Unique event related actions
    // ===============================================================================================================

    /**
     * Remember that actor may be NULL/player/pet/npc. Victim: player/pet/npc
     *
     * @param actor
     * @param victim
     */
    public void onKilled(Creature actor, Creature victim) {
        if (victim.isPlayer() && getRespawnTime() > 0)
            showScores(victim);

        if (actor != null && actor.isPlayer() && getFightClubPlayer(actor) != null)
            FightClubLastStatsManager.getInstance().updateStat(actor.getPlayer(), FightClubStatType.KILL_PLAYER,
                    getFightClubPlayer(actor).getKills(true));

        // Respawn type for non teamed events
        if (victim.isPlayer() && getRespawnTime() > 0 && !_ressAllowed
                && getFightClubPlayer(victim.getPlayer()) != null)
            startNewTimer(false, 0, "ressurectionTimer", getRespawnTime(), getFightClubPlayer(victim));
    }

    /**
     * Alexander Support for keeping track of damage done
     *
     * @param actor
     * @param victim
     * @param damage
     */
    public void onDamage(Creature actor, Creature victim, double damage) {

    }

    public void requestRespawn(Player activeChar, RestartType restartType) {
        if (getRespawnTime() > 0)
            startNewTimer(false, 0, "ressurectionTimer", getRespawnTime(), getFightClubPlayer(activeChar));
    }

    @Override
    public boolean canAttack(Creature target, Creature attacker, Skill skill, boolean force) {
        if (_state != EVENT_STATE.STARTED)
            return false;
        Player player = attacker.getPlayer();
        if (player == null)
            return true;

        if (isTeamed()) {
            FightClubPlayer targetFPlayer = getFightClubPlayer(target);
            FightClubPlayer attackerFPlayer = getFightClubPlayer(attacker);

            if (targetFPlayer == null || attackerFPlayer == null
                    || targetFPlayer.getTeam().equals(attackerFPlayer.getTeam()))
                return false;
        }

        // if (isInvisible(player, player))
        {
            // return false;
        }

        return true;
    }

    @Override
    public boolean canUseSkill(Creature caster, Creature target, Skill skill) {
        if (_excludedSkills != null) {
            for (int id : _excludedSkills)
                if (skill.getId() == id) {
                    return false;
                }
        }

        return true;
    }

    @Override
    public SystemMsg checkForAttack(Creature target, Creature attacker, Skill skill, boolean force) {
        if (!canAttack(target, attacker, skill, force))
            return SystemMsg.INVALID_TARGET;
        return null;
    }

    @Override
    public boolean canRessurect(Player player, Creature creature, boolean force) {
        return _ressAllowed;
    }

    /**
     * @param player
     * @return -1 if it have to be unchanged
     */
    public int getMySpeed(Player player) {
        return -1;
    }

    /**
     * @param player
     * @return -1 if it have to be unchanged
     */
    public int getPAtkSpd(Player player) {
        return -1;
    }

    /**
     * Removing window that appears after death
     */
    @Override
    public void checkRestartLocs(Player player, Map<RestartType, Boolean> r) {
        r.clear();
        if (isTeamed() && getRespawnTime() > 0 && getFightClubPlayer(player) != null && _ressAllowed) {
            r.put(RestartType.TO_FLAG, true);
        }
    }

    public boolean canUseBuffer(Player player, boolean heal) {
        FightClubPlayer fPlayer = getFightClubPlayer(player);
        if (!getBuffer())
            return false;
        if (player.isInCombat())
            return false;
        if (heal) {
            if (player.isDead())
                return false;
            if (_state != EVENT_STATE.STARTED)
                return true;
            if (fPlayer.isInvisible())
                return true;
            return false;
        }
        return true;
    }

    public boolean canUsePositiveMagic(Creature user, Creature target) {
        Player player = user.getPlayer();
        if (player == null)
            return true;

        return isFriend(user, target);
    }

    @Override
    public int getRelation(Player thisPlayer, Player target, int oldRelation) {
        if (_state == EVENT_STATE.STARTED)
            return isFriend(thisPlayer, target) ? getFriendRelation() : getWarRelation();
        else
            return oldRelation;
    }

    public boolean canJoinParty(Player sender, Player receiver) {
        return isFriend(sender, receiver);
    }

    /**
     * Join Clan, Join Ally, Command Channel
     *
     * @param sender
     * @param receiver
     * @return
     */
    public boolean canReceiveInvitations(Player sender, Player receiver) {
        return true;
    }

    public boolean canOpenStore(Player player) {
        return false;
    }

    public boolean canStandUp(Player player) {
        return true;
    }

    public boolean loseBuffsOnDeath(Player player) {
        return false;
    }

    protected boolean inScreenShowBeScoreNotKills() {
        return true;
    }

    protected boolean inScreenShowBeTeamNotInvidual() {
        return isTeamed();
    }

    public boolean isFriend(Creature c1, Creature c2) {
        if (c1.equals(c2))
            return true;

        if (!c1.isPlayable() || !c2.isPlayable()) {
            return true;
        }

        if (c1.isSummon() && c2.isPlayer() && c2.getPlayer().getPet() != null && c2.getPlayer().getPet().equals(c1)) {
            return true;
        }

        if (c2.isSummon() && c1.isPlayer() && c1.getPlayer().getPet() != null && c1.getPlayer().getPet().equals(c2)) {
            return true;
        }

        FightClubPlayer fPlayer1 = getFightClubPlayer(c1.getPlayer());
        FightClubPlayer fPlayer2 = getFightClubPlayer(c2.getPlayer());

        if (isTeamed()) {
            // Different teams
            if (fPlayer1 == null || fPlayer2 == null || !fPlayer1.getTeam().equals(fPlayer2.getTeam())) {
                return false;
            }
            // Same team
            else {
                return true;
            }
        } else {
            return false;
        }
    }

    public boolean isInvisible(Player actor, Player watcher) {
        return actor.getInvisibleType() == InvisibleType.NORMAL;
    }

    public String getVisibleName(Player player, String currentName, boolean toMe) {
        if (isHidePersonality() && !toMe)
            return "Player";
        return currentName;
    }

    public String getVisibleTitle(Player player, String currentTitle, boolean toMe) {
        return currentTitle;
    }

    public int getVisibleTitleColor(Player player, int currentTitleColor, boolean toMe) {
        return currentTitleColor;
    }

    public int getVisibleNameColor(Player player, int currentNameColor, boolean toMe) {
        if (isTeamed()) {
            FightClubPlayer fPlayer = getFightClubPlayer(player);
            return fPlayer.getTeam().getNickColor();
        }
        return currentNameColor;
    }

    /*
     *
     * Badges
     *
     */
    protected int getBadgesEarned(FightClubPlayer fPlayer, int currentValue, boolean topKiller) {
        if (fPlayer == null)
            return 0;
        currentValue += addMultipleBadgeToPlayer(fPlayer.getKills(true), _badgesKillPlayer);

        currentValue += getRewardForWinningTeam(fPlayer, true);

        int minutesAFK = (int) Math.round((double) fPlayer.getTotalAfkSeconds() / 60);
        currentValue += minutesAFK * BADGES_FOR_MINUTE_OF_AFK;

        // double reward
        currentValue = Config.FIGHT_CLUB_REWARD_MULTIPLIER * currentValue;

        if (topKiller) {
            currentValue += topKillerReward;
        }

        return currentValue;
    }

    /**
     * @param score
     * @param badgePerScore
     * @return score*badges
     */
    protected int addMultipleBadgeToPlayer(int score, double badgePerScore) {
        return (int) Math.floor(score * badgePerScore);
    }

    private int getEndEventBadges(FightClubPlayer fPlayer) {
        return 0;
    }

    // ===============================================================================================================
    // Actions same for all events
    // ===============================================================================================================

    public void startTeleportTimer(FightClubGameRoom room) {
        setState(EVENT_STATE.COUNT_DOWN);

        startNewTimer(true, 0, "teleportWholeRoomTimer", TIME_FIRST_TELEPORT);
    }

    /**
     * teleportSinglePlayer for first time, healing and ressing - all
     * REGISTERED_PLAYERS
     */
    protected void teleportRegisteredPlayers() {
        for (FightClubPlayer player : getPlayers(REGISTERED_PLAYERS)) {
            teleportSinglePlayer(player, true, true);
        }
    }

    /**
     * Teleporting player to event random location, rooting if _state is
     * PREPARATION or OVER, cancelling negative effects IF @firstTime - removing
     * from REGISTERED_PLAYERS and adding to FIGHTING_PLAYERS, showing question
     * mark, buffing, sending event menu, sending messages about chat, setting
     * invisibility if needed
     *
     * @param fPlayer
     * @param firstTime
     * @param healAndRess
     */
    protected void teleportSinglePlayer(FightClubPlayer fPlayer, boolean firstTime, boolean healAndRess) {
        Player player = fPlayer.getPlayer();

        if (healAndRess) {
            if (player.isDead())
                player.doRevive(100.);
        }

        Location loc = getSinglePlayerSpawnLocation(fPlayer);

        if (isInstanced())
            player.teleToLocation(loc, getReflection());
        else
            player.teleToLocation(loc);

        if (_state == EVENT_STATE.PREPARATION || _state == EVENT_STATE.OVER)
            rootPlayer(player);

        // Cancelling negative effects
        cancelNegativeEffects(player);
        // Unsummon pets
        if (player.getPet() instanceof PetInstance)
            player.getPet().unSummon();
        if (player.getPet() != null)
            cancelNegativeEffects(player.getPet());

        if (firstTime) {
            removeObject(REGISTERED_PLAYERS, fPlayer);
            addObject(FIGHTING_PLAYERS, fPlayer);

            player.getEffectList().stopAllEffects();
            if (player.getPet() != null)
                player.getPet().getEffectList().stopAllEffects();

            player.store(true);
            player.sendPacket(new TutorialShowQuestionMark(100));

            player.sendPacket(new Say2(player.getObjectId(), ChatType.ALL, getName(),
                    "Normal Chat is visible for every player in event."));
            if (isTeamed()) {
                player.sendPacket(new Say2(player.getObjectId(), ChatType.ALL, getName(),
                        "Battlefield(^) Chat is visible only to your team!"));
                player.sendPacket(new Say2(player.getObjectId(), ChatType.BATTLEFIELD, getName(),
                        "Battlefield(^) Chat is visible only to your team!"));
            }
        }

        if (healAndRess) {
            player.setCurrentHpMp(player.getMaxHp(), player.getMaxMp(), true);
            player.setCurrentCp(player.getMaxCp());
            if (player.getPet() != null && !player.getPet().isDead()) {
                Playable pet = player.getPet();
                pet.setCurrentHpMp(pet.getMaxHp(), player.getMaxMp(), false);
                pet.broadcastCharInfo();
            }
            player.broadcastUserInfo(true);
            player.broadcastStatusUpdate();
            player.broadcastCharInfo();
        }

        if (player.isMounted()) {
            player.setMount(0, 0, 0);
        }

        if (player.getTransformation() > 0) {
            player.setTransformation(0);
            player.setTransformationTemplate(0);
            player.setTransformationName(null);
        }
    }

    protected Location getSinglePlayerSpawnLocation(FightClubPlayer fPlayer) {
        Location[] spawns = null;
        Location loc = null;

        if (!isTeamed())
            spawns = getMap().getPlayerSpawns();
        else
            loc = getTeamSpawn(fPlayer, true);

        if (!isTeamed())
            loc = getSafeLocation(spawns);

        // Make it a bit random
        return Location.findPointToStay(loc, 0, CLOSE_LOCATIONS_VALUE / 2, fPlayer.getPlayer().getGeoIndex());
    }

    public void unregister(Player player) {
        FightClubPlayer fPlayer = getFightClubPlayer(player, REGISTERED_PLAYERS);
        player.removeEvent(this);
        removeObject(REGISTERED_PLAYERS, fPlayer);
        player.sendMessage("You are no longer registered!");
    }

    public boolean leaveEvent(Player player, boolean teleportTown) {
        FightClubPlayer fPlayer = getFightClubPlayer(player);

        if (fPlayer == null)
            return true;

        if (_state == EVENT_STATE.NOT_ACTIVE) {
            if (fPlayer.isInvisible())
                stopInvisibility(player);
            removeObject(FIGHTING_PLAYERS, fPlayer);
            if (isTeamed())
                fPlayer.getTeam().removePlayer(fPlayer);
            player.removeEvent(this);

            if (teleportTown)
                teleportBackToTown(player);
            else
                player.doRevive();
        } else // Leaving during event
        {
            rewardPlayer(fPlayer, false);
            if (teleportTown)
                setInvisible(player, TIME_TELEPORT_BACK_TOWN, false);
            else
                setInvisible(player, -1, false);
            removeObject(FIGHTING_PLAYERS, fPlayer);
            // Killing player - protection for Last Man standing
            player.doDie(null);// Dont change order. Removing from 1.
                                // FIGHTING_PLAYERS 2. Do Die 3. Remove Event
            player.removeEvent(this);

            if (teleportTown)
                startNewTimer(false, 0, "teleportBackSinglePlayerTimer", TIME_TELEPORT_BACK_TOWN, player);
            else
                player.doRevive();
        }

        hideScores(player);
        updateScreenScores();

        if (getPlayers(FIGHTING_PLAYERS, REGISTERED_PLAYERS).isEmpty())
            destroyMe();

        if (player.getParty() != null)
            player.getParty().removePartyMember(player, true);

        return true;
    }

    public void loggedOut(Player player) {
        leaveEvent(player, true);
    }

    protected void teleportBackToTown(Player player) {
        if (player.isDead())
            player.doRevive();
        player.setPolyId(0);
        Location loc = Location.findPointToStay(FightClubEventManager.RETURN_LOC, 0, 100, player.getGeoIndex());
        player.teleToLocation(loc, ReflectionManager.DEFAULT);
    }

    protected void rewardPlayer(FightClubPlayer fPlayer, boolean isTopKiller) {
        int badgesToGive = getBadgesEarned(fPlayer, 0, isTopKiller);

        if (getState() == EVENT_STATE.NOT_ACTIVE)
            badgesToGive += getEndEventBadges(fPlayer);

        badgesToGive = Math.max(0, badgesToGive);

        fPlayer.getPlayer().getInventory().addItem(FightClubEventManager.FIGHT_CLUB_BADGE_ID, badgesToGive,
                getName() + " Event");
        sendMessageToPlayer(fPlayer, MESSAGE_TYPES.SCREEN_BIG, "You have earned " + badgesToGive + " Festival Adena!");
        sendMessageToPlayer(fPlayer, MESSAGE_TYPES.NORMAL_MESSAGE,
                "You have earned " + badgesToGive + " Festival Adena!");
    }

    @Nullable
    private FightClubPlayer[] getTopKillers() {
        if (!_teamed || topKillerReward == 0)
            return null;

        FightClubPlayer[] topKillers = new FightClubPlayer[_teams.size()];
        int[] topKillersKills = new int[_teams.size()];

        int teamIndex = 0;
        for (FightClubTeam team : _teams) {
            for (FightClubPlayer fPlayer : team.getPlayers()) {
                if (fPlayer != null) {
                    if (fPlayer.getKills(true) == topKillersKills[teamIndex]) {
                        topKillers[teamIndex] = null;
                    } else if (fPlayer.getKills(true) > topKillersKills[teamIndex]) {
                        topKillers[teamIndex] = fPlayer;
                        topKillersKills[teamIndex] = fPlayer.getKills(true);
                    }
                }
            }
            teamIndex++;
        }
        return topKillers;
    }

    /**
     * Make isTeamed() check before
     *
     * @param wholeEvent
     * @param winnerOfTheRound
     * @wholeEvent - true - We won Last Man Standing! false - We Won Round!
     * @winnerOfTheRound if wholeEvent == false, set it to null
     */
    protected void announceWinnerTeam(boolean wholeEvent, FightClubTeam winnerOfTheRound) {
        int bestScore = -1;
        FightClubTeam bestTeam = null;
        boolean draw = false;
        if (wholeEvent) {
            for (FightClubTeam team : getTeams())
                if (team.getScore() > bestScore) {
                    draw = false;
                    bestScore = team.getScore();
                    bestTeam = team;
                } else if (team.getScore() == bestScore) {
                    draw = true;
                }
        } else
            bestTeam = winnerOfTheRound;

        if (!draw) {
            Say2 packet = new Say2(0, ChatType.COMMANDCHANNEL_ALL, bestTeam.getName() + " Team",
                    "Won " + (wholeEvent ? getName() : " Round") + "!");
            for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS))
                iFPlayer.getPlayer().sendPacket(packet);
        }

        updateScreenScores();
    }

    /**
     * It is checking all players by their scores. Not for teamed events!
     *
     * @param wholeEvent
     * @param winnerOfTheRound
     * @wholeEvent - true - I won Last Man Standing! false - I Won Round!
     * @winnerOfTheRound if wholeEvent == false, set it to null
     */
    protected void announceWinnerPlayer(boolean wholeEvent, FightClubPlayer winnerOfTheRound) {
        int bestScore = -1;
        FightClubPlayer bestPlayer = null;
        boolean draw = false;
        if (wholeEvent) {
            for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS))
                if (iFPlayer.getPlayer() != null && iFPlayer.getPlayer().isOnline())
                    if (iFPlayer.getScore() > bestScore) {
                        bestScore = iFPlayer.getScore();
                        bestPlayer = iFPlayer;
                    } else if (iFPlayer.getScore() == bestScore) {
                        draw = true;
                    }
        } else
            bestPlayer = winnerOfTheRound;

        if (!draw) {
            Say2 packet = new Say2(0, ChatType.COMMANDCHANNEL_ALL, bestPlayer.getPlayer().getName(),
                    "You Won " + (wholeEvent ? getName() : "Round") + "!");
            for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS))
                iFPlayer.getPlayer().sendPacket(packet);
        }

        updateScreenScores();
    }

    protected void updateScreenScores() {
        String msg = getScreenScores(inScreenShowBeScoreNotKills(), inScreenShowBeTeamNotInvidual());

        for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS))
            sendMessageToPlayer(iFPlayer, MESSAGE_TYPES.SCREEN_SMALL, msg);
    }

    protected void updateScreenScores(Player player) {
        if (getFightClubPlayer(player) != null)
            sendMessageToPlayer(getFightClubPlayer(player), MESSAGE_TYPES.SCREEN_SMALL,
                    getScreenScores(inScreenShowBeScoreNotKills(), inScreenShowBeTeamNotInvidual()));
    }

    protected String getScorePlayerName(FightClubPlayer fPlayer) {
        return fPlayer.getPlayer().getName() + (isTeamed() ? " (" + fPlayer.getTeam().getName() + " Team)" : "");
    }

    /**
     * Player Ranking is being updated
     *
     * @param fPlayer
     */
    protected void updatePlayerScore(FightClubPlayer fPlayer) {
        _scores.put(getScorePlayerName(fPlayer), fPlayer.getKills(true));
        _rscores.put(fPlayer.getPlayer().getObjectId(), fPlayer.getKills(true));
        _scoredUpdated = true;

        /*
         * for(FightClubPlayer iterFPlayer : getPlayers(FIGHTING_PLAYERS)) if
         * (iterFPlayer.isShowRank()) showScores(iterFPlayer.getPlayer());
         */

        if (!isTeamed())
            updateScreenScores();
    }

    protected void showScores(Creature c) {
        Map<String, Integer> scores = getBestScores();

        FightClubPlayer fPlayer = getFightClubPlayer(c);
        fPlayer.setShowRank(true);

        c.sendPacket(new ExPVPMatchCCRecord(scores));
    }

    protected  void saveResults() {

        Connection con = null;
        PreparedStatement statement = null;

        try {
            con = DatabaseFactory.getInstance().getConnection();
            statement = BatchStatement.createPreparedStatement(con,
                    "REPLACE INTO character_event_kills(obj_Id,kills) VALUES(?,?)");
            for (Entry<Integer, Integer> i : _rscores.entrySet()) {
                statement.setInt(1, i.getKey());
                statement.setInt(2, i.getValue());
                statement.addBatch();
            }
            statement.executeBatch();

        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    protected void hideScores(Creature c) {
        c.sendPacket(ExPVPMatchCCRetire.STATIC);
    }

    /**
     * If player is AFK: getting him back from it If player isn't AFK: checking
     * if he is in combat and asking if he really wants it
     *
     * @param fPlayer
     * @param setAsAfk
     */
    protected void handleAfk(FightClubPlayer fPlayer, boolean setAsAfk) {
        Player player = fPlayer.getPlayer();

        if (setAsAfk) {
            fPlayer.setAfk(true);
            fPlayer.setAfkStartTime(player.getLastNotAfkTime());

            sendMessageToPlayer(player, MESSAGE_TYPES.CRITICAL, "You are considered as AFK Player!");
        } else if (fPlayer.isAfk()) {
            int totalAfkTime = (int) ((System.currentTimeMillis() - fPlayer.getAfkStartTime()) / 1000);
            totalAfkTime -= TIME_TO_BE_AFK;
            if (totalAfkTime > 5) {
                fPlayer.setAfk(false);

                fPlayer.addTotalAfkSeconds(totalAfkTime);
                sendMessageToPlayer(player, MESSAGE_TYPES.CRITICAL, "You were afk for " + totalAfkTime + " seconds!");
            }
        }
    }

    /**
     * @param player
     * @param seconds
     * @param sendMessages
     * @seconds - If seconds > 0, starts new timer that stopsInvisiblity when
     *          its over.
     * @SendMessages - Should timer send messages like VISIBLE IN X SECONDS?
     */
    protected void setInvisible(Player player, int seconds, boolean sendMessages) {
        FightClubPlayer fPlayer = getFightClubPlayer(player);
        fPlayer.setInvisible(true);

        player.setInvisibleType(InvisibleType.NORMAL);
        player.startAbnormalEffect(AbnormalEffect.STEALTH);
        player.sendUserInfo(true);
        World.removeObjectFromPlayers(player);

        if (seconds > 0)
            startNewTimer(false, 0, "setInvisible", seconds, fPlayer, sendMessages);
    }

    protected void stopInvisibility(Player player) {
        FightClubPlayer fPlayer = getFightClubPlayer(player);

        if (fPlayer != null)
            fPlayer.setInvisible(false);

        player.setInvisibleType(InvisibleType.NONE);
        player.stopAbnormalEffect(AbnormalEffect.STEALTH);
        player.broadcastCharInfo();
        if (player.getPet() != null)
            player.getPet().broadcastCharInfo();
    }

    protected void rootPlayer(Player player) {
        if (!isRootBetweenRounds())
            return;
        List<Playable> toRoot = new ArrayList<>();
        toRoot.add(player);
        if (player.getPet() != null)
            toRoot.add(player.getPet());

        if (!player.isRooted()) {
            player.startRooted();
        }
        player.stopMove();
        player.startAbnormalEffect(AbnormalEffect.ROOT);
    }

    protected void unrootPlayers() {
        if (!isRootBetweenRounds())
            return;

        for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS)) {
            Player player = iFPlayer.getPlayer();
            if (player.isRooted()) {
                try {
                    player.stopRooted();
                } catch (IllegalStateException e) {

                }
                player.stopAbnormalEffect(AbnormalEffect.ROOT);
            }
        }
    }

    protected void ressAndHealPlayers() {
        for (FightClubPlayer fPlayer : getPlayers(FIGHTING_PLAYERS)) {
            Player player = fPlayer.getPlayer();

            if (player.isDead())
                player.doRevive(100.);

            cancelNegativeEffects(player);
            if (player.getPet() != null)
                cancelNegativeEffects(player.getPet());

            buffPlayer(player);
        }
    }

    protected int getWarRelation() {
        int result = 0;

        result |= RelationChanged.RELATION_CLAN_MEMBER;
        result |= RelationChanged.RELATION_1SIDED_WAR;
        result |= RelationChanged.RELATION_MUTUAL_WAR;

        return result;
    }

    protected int getFriendRelation() {
        int result = 0;

        result |= RelationChanged.RELATION_CLAN_MEMBER;
        result |= RelationChanged.RELATION_CLAN_MATE;

        return result;
    }

    /**
     * Getting one location out of locs and spawning npc in there.
     * Set @respawnInSeconds to 0 if you don't want them to respawn
     *
     * @param id
     * @param locs
     * @param respawnInSeconds
     * @return
     */
    protected NpcInstance chooseLocAndSpawnNpc(int id, Location[] locs, int respawnInSeconds) {
        return spawnNpc(id, getSafeLocation(locs), respawnInSeconds);
    }

    /**
     * Set @respawnInSeconds to 0 if you don't want them to respawn
     *
     * @param id
     * @param loc
     * @param respawnInSeconds
     * @return
     */
    protected NpcInstance spawnNpc(int id, Location loc, int respawnInSeconds) {
        SimpleSpawner spawn = new SimpleSpawner(id);
        spawn.setLoc(loc);
        spawn.setAmount(1);
        spawn.setHeading(loc.h);
        spawn.setRespawnDelay(Math.max(0, respawnInSeconds));
        spawn.setReflection(getReflection());
        List<NpcInstance> npcs = spawn.initAndReturn();

        if (respawnInSeconds <= 0)
            spawn.stopRespawn();

        return npcs.get(0);
    }

    /**
     * @param seconds
     * @return "5 minutes" after pasting 300 seconds
     */
    protected static String getFixedTime(int seconds) {
        int minutes = seconds / 60;
        String result = "";
        if (seconds >= 60) {
            result = minutes + " minute" + (minutes > 1 ? "s" : "");
        } else {
            result = seconds + " second" + (seconds > 1 ? "s" : "");
        }
        return result;
    }

    private void buffPlayer(Player player) {
        if (getBuffer()) {
            int[][] buffs;
            if (player.isMageClass())
                buffs = _mageBuffs;
            else
                buffs = _fighterBuffs;

            giveBuffs(player, buffs);

            if (player.getPet() != null)
                giveBuffs(player.getPet(), _fighterBuffs);
        }
    }

    private static void giveBuffs(final Playable playable, int[][] buffs) {
        Skill buff;
        for (int[] buff1 : buffs) {
            buff = SkillTable.getInstance().getInfo(buff1[0], buff1[1]);
            if (buff == null) {
                continue;
            }
            buff.getEffects(playable, playable, false, false);
        }

        ThreadPoolManager.getInstance().schedule(() -> {
            playable.setCurrentHp(playable.getMaxHp(), true);
            playable.setCurrentMp(playable.getMaxMp());
            playable.setCurrentCp(playable.getMaxCp());
        }, 1000);
    }

    private void announceTopKillers(FightClubPlayer[] topKillers) {
        if (topKillers == null)
            return;

        for (FightClubPlayer fPlayer : topKillers)
            if (fPlayer != null) {
                String message = fPlayer.getPlayer().getName()
                        + " had most kills" /*
                                             * + (_teamed ? " from " +
                                             * fPlayer.getTeam().getName() +
                                             * " Team" : "")
                                             */ + " on " + getName() + " Event!";
                FightClubEventManager.getInstance().sendToAllMsg(this, message);
            }
    }

    public enum MESSAGE_TYPES {
        GM, NORMAL_MESSAGE, SCREEN_BIG, SCREEN_SMALL, CRITICAL
    }

    protected void sendMessageToFightingAndRegistered(MESSAGE_TYPES type, String msg) {
        sendMessageToFighting(type, msg, false);
        sendMessageToRegistered(type, msg);
    }

    protected void sendMessageToTeam(FightClubTeam team, MESSAGE_TYPES type, String msg) {
        // Team Members
        for (FightClubPlayer iFPlayer : team.getPlayers())
            sendMessageToPlayer(iFPlayer, type, msg);
    }

    protected void sendMessageToFighting(MESSAGE_TYPES type, String msg, boolean skipJustTeleported)// TODO
                                                                                                    // ogarnac
                                                                                                    // skipJustTeleported,
                                                                                                    // to
                                                                                                    // juz
                                                                                                    // nie
                                                                                                    // jest
                                                                                                    // potrzebne
    {
        // Fighting
        for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS))
            if (!skipJustTeleported || !iFPlayer.isInvisible())
                sendMessageToPlayer(iFPlayer, type, msg);
    }

    protected void sendMessageToRegistered(MESSAGE_TYPES type, String msg) {
        // Registered
        for (FightClubPlayer iFPlayer : getPlayers(REGISTERED_PLAYERS))
            sendMessageToPlayer(iFPlayer, type, msg);
    }

    public void sendMessageToPlayer(FightClubPlayer fPlayer, MESSAGE_TYPES type, String msg) {
        sendMessageToPlayer(fPlayer.getPlayer(), type, msg);
    }

    protected void sendMessageToPlayer(Player player, MESSAGE_TYPES type, String msg) {
        switch (type) {
        case GM:
            player.sendPacket(new Say2(player.getObjectId(), ChatType.CRITICAL_ANNOUNCE, player.getName(), msg));
            updateScreenScores(player);
            break;
        case NORMAL_MESSAGE:
            player.sendMessage(msg);
            break;
        case SCREEN_BIG:
            player.sendPacket(
                    new ExShowScreenMessage(msg, 3000, ExShowScreenMessage.ScreenMessageAlign.TOP_CENTER, true));
            updateScreenScores(player);
            break;
        case SCREEN_SMALL:
            player.sendPacket(
                    new ExShowScreenMessage(msg, 600000, ExShowScreenMessage.ScreenMessageAlign.TOP_LEFT, false));
            break;
        case CRITICAL:
            player.sendPacket(new Say2(player.getObjectId(), ChatType.COMMANDCHANNEL_ALL, player.getName(), msg));
            updateScreenScores(player);
            break;
        }
    }

    public void setState(EVENT_STATE state) {
        _state = state;
    }

    // ===============================================================================================================
    // Event Getters
    // ===============================================================================================================

    public EVENT_STATE getState() {
        return _state;
    }

    public int getObjectId() {
        return _objId;
    }

    public int getEventId() {
        return getId();
    }

    public String getDescription() {
        return _desc;
    }

    public String getIcon() {
        return _icon;
    }

    public boolean isAutoTimed() {
        return _isAutoTimed;
    }

    public int[][] getAutoStartTimes() {
        return _autoStartTimes;
    }

    public FightClubMap getMap() {
        return _map;
    }

    public boolean isTeamed() {
        return _teamed;
    }

    protected boolean isInstanced() {
        return _instanced;
    }

    @Override
    public Reflection getReflection() {
        return _reflection;
    }

    /**
     * @return -1 in case
     */
    public int getRoundRuntime() {
        return _roundRunTime;
    }

    public int getRespawnTime() {
        return _respawnTime;
    }

    public boolean isRoundEvent() {
        return _roundEvent;
    }

    public int getTotalRounds() {
        return _rounds;
    }

    public int getCurrentRound() {
        return _currentRound;
    }

    public boolean getBuffer() {
        return _buffer;
    }

    protected boolean isRootBetweenRounds() {
        return _rootBetweenRounds;
    }

    public boolean isLastRound() {
        return !isRoundEvent() || getCurrentRound() == getTotalRounds();
    }

    protected List<FightClubTeam> getTeams() {
        return _teams;
    }

    public MultiValueSet<String> getSet() {
        return _set;
    }

    public void clearSet() {
        _set = null;
    }

    public CLASSES[] getExcludedClasses() {
        return _excludedClasses;
    }

    public boolean isHidePersonality() {
        return !_showPersonality;
    }

    protected int getTeamTotalKills(FightClubTeam team) {
        if (!isTeamed())
            return 0;
        int totalKills = 0;
        for (FightClubPlayer iFPlayer : team.getPlayers())
            totalKills += iFPlayer.getKills(true);

        return totalKills;
    }

    /**
     * @param groups
     * @return players count from the groups
     */
    public int getPlayersCount(String... groups) {
        return getPlayers(groups).size();
    }

    public List<FightClubPlayer> getPlayers(String... groups) {
        if (groups.length == 1) {
            List<FightClubPlayer> fPlayers = getObjects(groups[0]);
            return fPlayers;
        } else {
            List<FightClubPlayer> newList = new ArrayList<>();
            for (String group : groups) {
                List<FightClubPlayer> fPlayers = getObjects(group);
                newList.addAll(fPlayers);
            }
            return newList;
        }
    }

    public List<Player> getAllFightingPlayers() {
        List<FightClubPlayer> fPlayers = getPlayers(FIGHTING_PLAYERS);
        List<Player> players = new ArrayList<>(fPlayers.size());
        for (FightClubPlayer fPlayer : fPlayers)
            players.add(fPlayer.getPlayer());
        return players;
    }

    public List<Player> getMyTeamFightingPlayers(Player player) {
        FightClubTeam fTeam = getFightClubPlayer(player).getTeam();
        List<FightClubPlayer> fPlayers = getPlayers(FIGHTING_PLAYERS);
        List<Player> players = new ArrayList<>(fPlayers.size());

        if (!isTeamed()) {
            player.sendPacket(new Say2(player.getObjectId(), ChatType.BATTLEFIELD, getName(),
                    "(There are no teams, only you can see the message)"));
            players.add(player);
        } else {
            for (FightClubPlayer iFPlayer : fPlayers)
                if (iFPlayer.getTeam().equals(fTeam))
                    players.add(iFPlayer.getPlayer());
        }
        return players;
    }

    /**
     * Looking for FightClubPlayer ONLY in FIGHTING_PLAYERS
     *
     * @param creature
     * @return
     */
    public FightClubPlayer getFightClubPlayer(Creature creature) {
        return getFightClubPlayer(creature, FIGHTING_PLAYERS);
    }

    /**
     * Looking for FightClubPlayer in specific groups
     *
     * @param creature
     * @param groups
     * @return
     */
    public FightClubPlayer getFightClubPlayer(Creature creature, String... groups) {
        if (!creature.isPlayable())
            return null;

        int lookedPlayerId = creature.getPlayer().getObjectId();

        for (FightClubPlayer iFPlayer : getPlayers(groups))
            if (iFPlayer.getPlayer().getObjectId() == lookedPlayerId)
                return iFPlayer;
        return null;
    }

    // ===============================================================================================================
    // Private actions
    // ===============================================================================================================

    /**
     * Getting teams and partys from FightClubGameRoom and making them actually
     * exist
     */
    protected void spreadIntoTeamsAndPartys() {
        // Creating teams
        for (int i = 0; i < _room.getTeamsCount(); i++) {
            _teams.add(new FightClubTeam(i + 1));
        }

        // Sort the player list by level
        final List<Player> players = new ArrayList<>(_room.getAllPlayers());

        // Alexander - Sort participants list by level and then by class, trying
        // to make the teams as equal as possible
        Collections.sort(players,
                PlayerComparator.getComparator(PlayerComparator.LEVEL_SORT, PlayerComparator.CLASS_SORT));

        int index = 0;
        for (Player player : players) {
            FightClubPlayer fPlayer = getFightClubPlayer(player, REGISTERED_PLAYERS);
            if (fPlayer == null)
                continue;

            final FightClubTeam team = _teams.get(index % _room.getTeamsCount());
            fPlayer.setTeam(team);
            team.addPlayer(fPlayer);

            index++;
        }

        for (FightClubTeam team : _teams) {
            List<List<Player>> partys = spreadTeamInPartys(team);
            for (List<Player> party : partys) {
                createParty(party);
            }
        }
    }

    /**
     * Spreading Players in team into List of Partys(Party = List<Player> with 9
     * as MAX Count)
     *
     * @param team
     *            team to create Partys
     * @return List<Party(List<Player>)>
     */
    protected List<List<Player>> spreadTeamInPartys(FightClubTeam team) {
        // Creating Map<Class, List of Players>
        Map<CLASSES, List<Player>> classesMap = new FastMap<>();
        for (CLASSES clazz : CLASSES.values()) {
            classesMap.put(clazz, new ArrayList<Player>());
        }

        // Adding players to map
        for (FightClubPlayer iFPlayer : team.getPlayers()) {
            Player player = iFPlayer.getPlayer();
            CLASSES clazz = FightClubGameRoom.getPlayerClassGroup(player);
            classesMap.get(clazz).add(player);
        }

        // Getting Party Count
        int partyCount = (int) Math.ceil(team.getPlayers().size() / (double) Party.MAX_SIZE);

        // Creating "Partys"
        List<List<Player>> partys = new ArrayList<>();
        for (int i = 0; i < partyCount; i++) {
            partys.add(new ArrayList<Player>());
        }

        if (partyCount == 0)
            return partys;

        // Adding players from map to Partys
        int finishedOnIndex = 0;
        for (Entry<CLASSES, List<Player>> clazzEntry : classesMap.entrySet()) {
            for (Player player : clazzEntry.getValue()) {
                partys.get(finishedOnIndex).add(player);
                finishedOnIndex++;
                if (finishedOnIndex == partyCount)
                    finishedOnIndex = 0;
            }
        }

        return partys;
    }

    /**
     * Creating Real Party from List<Player> Checking listOfPlayers count,
     * removing from current party
     *
     * @param listOfPlayers
     *            players to create party
     */
    protected void createParty(List<Player> listOfPlayers) {
        if (listOfPlayers.size() <= 1)
            return;

        Party newParty = null;
        for (Player player : listOfPlayers) {
            if (player.getParty() != null)
                player.getParty().removePartyMember(player, true);

            if (newParty == null) {
                player.setParty(newParty = new Party(player, Party.ITEM_ORDER_SPOIL));
            } else {
                player.joinParty(newParty);
            }
        }
    }

    private synchronized void createReflection(IntObjectMap<DoorTemplate> doors, Map<String, ZoneTemplate> zones) {
        InstantZone iz = InstantZoneHolder.getInstance().getInstantZone(INSTANT_ZONE_ID);

        _reflection = new Reflection();
        _reflection.init(iz);
        _reflection.init(doors, zones);

        for (Zone zone : _reflection.getZones())
            zone.addListener(_zoneListener);
    }

    /**
     * @param locations
     * @return Finding location where nobodyIsClose
     */
    private Location getSafeLocation(Location[] locations) {
        Location safeLoc = null;
        int checkedCount = 0;
        boolean isOk = false;

        while (!isOk) {
            safeLoc = Rnd.get(locations);

            // Checking if nobody is close to spawn, only in single player
            // events
            isOk = nobodyIsClose(safeLoc);
            checkedCount++;

            // If players are close to every spawn, choose something anyway.
            if (checkedCount > locations.length * 2)
                isOk = true;
        }

        return safeLoc;
    }

    /**
     * @param fPlayer
     * @param randomNotClosestToPt
     * @return
     * @randomNotClosestToPt If true - @return random location from team locs
     * @randomNotClosestToPt If false - @return location closest to team members
     */
    protected Location getTeamSpawn(FightClubPlayer fPlayer, boolean randomNotClosestToPt) {
        FightClubTeam team = fPlayer.getTeam();
        Location[] spawnLocs = getMap().getTeamSpawns().get(team.getIndex());

        if (randomNotClosestToPt || _state != EVENT_STATE.STARTED) {
            return Rnd.get(spawnLocs);
            // if (team.getSpawnLoc() == null)
            // {
            // team.setSpawnLoc(Rnd.get(spawnLocs));
            // }
            // return team.getSpawnLoc();
        } else {
            List<Player> playersToCheck = new ArrayList<>();
            if (fPlayer.getParty() != null)
                playersToCheck = fPlayer.getParty().getMembers();
            else
                for (FightClubPlayer iFPlayer : team.getPlayers())
                    playersToCheck.add(iFPlayer.getPlayer());

            Map<Location, Integer> spawnLocations = new FastMap<>(spawnLocs.length);
            for (Location loc : spawnLocs)
                spawnLocations.put(loc, 0);

            for (Player player : playersToCheck)
                if (player != null && player.isOnline() && !player.isDead()) {
                    Location winner = null;
                    double winnerDist = -1;
                    for (Location loc : spawnLocs)
                        if (winnerDist <= 0 || winnerDist < player.getDistance(loc)) {
                            winner = loc;
                            winnerDist = player.getDistance(loc);
                        }

                    if (winner != null)
                        spawnLocations.put(winner, spawnLocations.get(winner) + 1);
                }

            Location winner = null;
            double points = -1;
            for (Entry<Location, Integer> spawn : spawnLocations.entrySet())
                if (points < spawn.getValue()) {
                    winner = spawn.getKey();
                    points = spawn.getValue();
                }

            if (points <= 0)
                return Rnd.get(spawnLocs);
            return winner;
        }
    }

    protected boolean isPlayerActive(Player player) {
        if (player == null)
            return false;
        if (player.isDead())
            return false;
        if (!player.getReflection().equals(getReflection()))
            return false;
        if (System.currentTimeMillis() - player.getLastNotAfkTime() > 120000)// If
                                                                                // inactive
                                                                                // for
                                                                                // at
                                                                                // least
                                                                                // 2
                                                                                // minutes
            return false;

        boolean insideZone = false;
        for (Zone zone : getReflection().getZones())
            if (zone.checkIfInZone(player.getX(), player.getY(), player.getZ(), player.getReflection()))
                insideZone = true;
        if (!insideZone)
            return false;

        return true;
    }

    /**
     * Sending rewardPlayer method to every FIGHTING_PLAYERS
     *
     * @param topKillers
     */
    private void giveRewards(FightClubPlayer[] topKillers) {
        for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS))
            if (iFPlayer != null)
                rewardPlayer(iFPlayer, Util.arrayContains(topKillers, iFPlayer));
    }

    private void showLastAFkMessage() {
        for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS)) {
            int minutesAFK = (int) Math.round((double) iFPlayer.getTotalAfkSeconds() / 60);
            int badgesDecreased = -minutesAFK * BADGES_FOR_MINUTE_OF_AFK;
            sendMessageToPlayer(iFPlayer, MESSAGE_TYPES.NORMAL_MESSAGE,
                    "Reward decreased by " + badgesDecreased + " Coins for AFK time!");
        }
    }

    /**
     * @return 25 <Name, Points> - players with most points
     */
    private Map<String, Integer> getBestScores() {
        if (!_scoredUpdated)
            return _bestScores;

        List<Integer> points = new ArrayList<Integer>(_scores.values());
        Collections.sort(points);
        Collections.reverse(points);

        int cap;
        if (points.size() <= 26)
            cap = points.get(points.size() - 1).intValue();
        else
            cap = points.get(25).intValue();
        Map<String, Integer> finalResult = new LinkedHashMap<>();

        List<Entry<String, Integer>> toAdd = new ArrayList<>();
        for (Entry<String, Integer> i : _scores.entrySet())
            if (i.getValue().intValue() > cap && finalResult.size() < 25)
                toAdd.add(i);

        if (finalResult.size() < 25) {
            for (Entry<String, Integer> i : _scores.entrySet())
                if (i.getValue().intValue() == cap) {
                    toAdd.add(i);
                    if (finalResult.size() == 25)
                        break;
                }
        }

        for (int i = 0; i < toAdd.size(); i++) {
            Entry<String, Integer> biggestEntry = null;
            for (Entry<String, Integer> entry : toAdd) {
                if (!finalResult.containsKey(entry.getKey())
                        && (biggestEntry == null || entry.getValue().intValue() > biggestEntry.getValue().intValue()))
                    biggestEntry = entry;
            }
            if (biggestEntry != null)
                finalResult.put(biggestEntry.getKey(), biggestEntry.getValue());
        }

        _bestScores = finalResult;
        _scoredUpdated = false;

        return finalResult;
    }

    /**
     * Updating score of every FIGHTING_PLAYERS
     */
    private void updateEveryScore() {
        for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS)) {
            _scores.put(getScorePlayerName(iFPlayer), iFPlayer.getKills(true));
            _rscores.put(iFPlayer.getPlayer().getObjectId(), iFPlayer.getKills(true));
            _scoredUpdated = true;
        }
    }

    /**
     * @param showScoreNotKills
     *            - true - Score: - false - "Kills:"
     * @param teamPointsNotInvidual
     *            - true: Team Score/Kills, false: Player Score/Kills
     * @return
     */
    private String getScreenScores(boolean showScoreNotKills, boolean teamPointsNotInvidual) {
        StringBuilder builder = new StringBuilder();
        if (_teamed && teamPointsNotInvidual) {
            List<FightClubTeam> teams = getTeams();
            Collections.sort(teams, new BestTeamComparator(showScoreNotKills));
            for (FightClubTeam team : teams)
                builder.append(team.getName()).append(" Team: ")
                        .append(showScoreNotKills ? team.getScore() : getTeamTotalKills(team)).append(' ')
                        .append(showScoreNotKills ? "Points" : "Kills").append('\n');
        } else {
            List<FightClubPlayer> fPlayers = getPlayers(FIGHTING_PLAYERS);
            List<FightClubPlayer> changedFPlayers = new ArrayList<>(fPlayers.size());
            changedFPlayers.addAll(fPlayers);

            Collections.sort(changedFPlayers, new BestPlayerComparator(showScoreNotKills));
            int max = Math.min(10, changedFPlayers.size());
            for (int i = 0; i < max; i++)
                builder.append(changedFPlayers.get(i).getPlayer().getName()).append(' ')
                        .append(showScoreNotKills ? "Score" : "Kills").append(": ")
                        .append(showScoreNotKills ? changedFPlayers.get(i).getScore()
                                : changedFPlayers.get(i).getKills(true))
                        .append('\n');
        }

        return builder.toString();
    }

    protected int getRewardForWinningTeam(FightClubPlayer fPlayer, boolean atLeast1Kill) {
        if (!_teamed || _state != EVENT_STATE.OVER && _state != EVENT_STATE.NOT_ACTIVE)
            return 0;

        if (atLeast1Kill && fPlayer.getKills(true) <= 0
                && FightClubGameRoom.getPlayerClassGroup(fPlayer.getPlayer()) != CLASSES.HEALERS)
            return 0;

        FightClubTeam winner = null;
        int winnerPoints = -1;
        boolean sameAmount = false;
        for (FightClubTeam team : getTeams()) {
            if (team.getScore() > winnerPoints) {
                winner = team;
                winnerPoints = team.getScore();
                sameAmount = false;
            } else if (team.getScore() == winnerPoints) {
                sameAmount = true;
            }
        }

        if (!sameAmount && fPlayer.getTeam().equals(winner)) {
            return (int) _badgeWin;
        } else {
            return 0;
        }
    }

    /**
     * @param loc
     * @return checking if nobody is near(CLOSE_LOCATIONS_VALUE) loc
     */
    private boolean nobodyIsClose(Location loc) {
        for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS)) {
            Location playerLoc = iFPlayer.getPlayer().getLoc();
            if (Math.abs(playerLoc.getX() - loc.getX()) <= CLOSE_LOCATIONS_VALUE)
                return false;
            if (Math.abs(playerLoc.getY() - loc.getY()) <= CLOSE_LOCATIONS_VALUE)
                return false;
        }
        return true;
    }

    /**
     * Checking every REGISTERED_PLAYERS if he meets criteria
     */
    private void checkIfRegisteredMeetCriteria() {
        for (FightClubPlayer iFPlayer : getPlayers(REGISTERED_PLAYERS)) {
            checkIfRegisteredPlayerMeetCriteria(iFPlayer);
        }
    }

    /**
     * If he doesn't, unregistering player
     *
     * @param fPlayer
     * @return player meets criteria
     */
    private boolean checkIfRegisteredPlayerMeetCriteria(FightClubPlayer fPlayer) {
        if (!FightClubEventManager.getInstance().canPlayerParticipate(fPlayer.getPlayer(), true, true)) {
            return false;
        } else {
            return true;
        }
    }

    /**
     * Removing all debuffs
     *
     * @param playable
     */
    private void cancelNegativeEffects(Playable playable) {
        List<Effect> _buffList = new ArrayList<Effect>();

        for (Effect e : playable.getEffectList().getAllEffects()) {
            if (e.isOffensive() && e.isCancelable())
                _buffList.add(e);
        }

        for (Effect e : _buffList) {
            e.exit();
        }
    }

    /**
     * @param classes
     *            like TANKS;DAMAGE_DEALERS
     * @return array of CLASS_TYPES
     */
    private CLASSES[] parseExcludedClasses(String classes) {
        if (classes.equals(""))
            return new CLASSES[0];

        String[] classType = classes.split(";");
        CLASSES[] realTypes = new CLASSES[classType.length];

        for (int i = 0; i < classType.length; i++)
            realTypes[i] = CLASSES.valueOf(classType[i]);

        return realTypes;
    }

    protected int[] parseExcludedSkills(String ids) {
        if (ids == null || ids.isEmpty())
            return null;
        StringTokenizer st = new StringTokenizer(ids, ";");
        int[] realIds = new int[st.countTokens()];
        int index = 0;
        while (st.hasMoreTokens()) {
            realIds[index] = Integer.parseInt(st.nextToken());
            index++;
        }
        return realIds;
    }

    private int[][] parseAutoStartTimes(String times) {
        if (times == null || times.isEmpty())
            return null;

        StringTokenizer st = new StringTokenizer(times, ",");
        int[][] realTimes = new int[st.countTokens()][2];
        int index = 0;
        while (st.hasMoreTokens()) {
            String[] hourMin = st.nextToken().split(":");
            int[] realHourMin = { Integer.parseInt(hourMin[0]), Integer.parseInt(hourMin[1]) };
            realTimes[index] = realHourMin;
            index++;
        }
        return realTimes;
    }

    private int[][] parseBuffs(String buffs) {
        if (buffs == null || buffs.isEmpty())
            return null;

        StringTokenizer st = new StringTokenizer(buffs, ";");
        int[][] realBuffs = new int[st.countTokens()][2];
        int index = 0;
        while (st.hasMoreTokens()) {
            String[] skillLevel = st.nextToken().split(",");
            int[] realHourMin = { Integer.parseInt(skillLevel[0]), Integer.parseInt(skillLevel[1]) };
            realBuffs[index] = realHourMin;
            index++;
        }
        return realBuffs;
    }

    /**
     * Stops: {5, 15, 30, 60, 300, 600, 900}
     *
     * @param totalLeftTimeInSeconds
     * @return
     */
    private int getTimeToWait(int totalLeftTimeInSeconds) {
        int toWait = 1;

        int[] stops = { 5, 15, 30, 60, 300, 600, 900 };

        for (int stop : stops)
            if (totalLeftTimeInSeconds > stop)
                toWait = stop;

        return toWait;
    }

    /**
     * Thread that adds Seconds spent on event to every fPlayer
     */
    private class TimeSpentOnEventThread extends RunnableImpl {
        @Override
        public void runImpl() {
            if (_state == EVENT_STATE.STARTED) {
                for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS)) {
                    if (iFPlayer.getPlayer() == null || !iFPlayer.getPlayer().isOnline())
                        continue;

                    if (iFPlayer.isAfk())
                        continue;

                    iFPlayer.incSecondsSpentOnEvent(10);
                }
            }

            if (_state != EVENT_STATE.NOT_ACTIVE)
                ThreadPoolManager.getInstance().schedule(new TimeSpentOnEventThread(), 10 * 1000);
        }
    }

    private class LeftZoneThread extends RunnableImpl {
        @Override
        public void runImpl() {
            List<FightClubPlayer> toDelete = new ArrayList<>();
            Say2 packet = new Say2(0, ChatType.COMMANDCHANNEL_ALL, "Error", "Go Back To Event Zone!");

            for (Entry<FightClubPlayer, Zone> entry : _leftZone.entrySet()) {
                Player player = entry.getKey().getPlayer();
                if (player == null || !player.isOnline() || _state == EVENT_STATE.NOT_ACTIVE
                        || entry.getValue().checkIfInZone(player) || player.isDead() || player.isTeleporting()) {
                    toDelete.add(entry.getKey());
                    continue;
                }

                int power = (int) Math.max(400, entry.getValue().findDistanceToZone(player, true) - 4000);

                player.sendPacket(new Earthquake(player.getLoc(), power, 5));
                player.sendPacket(packet);
                entry.getKey().increaseSecondsOutsideZone();

                if (entry.getKey().getSecondsOutsideZone() >= TIME_MAX_SECONDS_OUTSIDE_ZONE) {
                    player.doDie(null);
                    toDelete.add(entry.getKey());
                    entry.getKey().clearSecondsOutsideZone();
                }
            }

            for (FightClubPlayer playerToDelete : toDelete) {
                if (playerToDelete != null) {
                    _leftZone.remove(playerToDelete);
                    playerToDelete.clearSecondsOutsideZone();
                }
            }

            if (_state != EVENT_STATE.NOT_ACTIVE)
                ThreadPoolManager.getInstance().schedule(this, 1000L);
        }
    }

    protected boolean isAfkTimerStopped(Player player) {
        return player.isDead() && !_ressAllowed && _respawnTime <= 0;
    }

    private class CheckAfkThread extends RunnableImpl {
        @Override
        public void runImpl() {
            long currentTime = System.currentTimeMillis();
            for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS)) {
                Player player = iFPlayer.getPlayer();
                boolean isAfk = (player.getLastNotAfkTime() + TIME_TO_BE_AFK * 1000) < currentTime;

                if (isAfkTimerStopped(player))// Cannot do any actions, doesn't
                                                // mean he is afk
                    continue;

                if (iFPlayer.isAfk()) {
                    if (!isAfk) {
                        handleAfk(iFPlayer, false);// Just came back from afk
                    } else if (_state != EVENT_STATE.OVER) {
                        sendMessageToPlayer(player, MESSAGE_TYPES.CRITICAL, "You are in AFK mode!");
                    }
                } else if (_state == EVENT_STATE.NOT_ACTIVE) {
                    handleAfk(iFPlayer, false);
                } else if (isAfk) {
                    handleAfk(iFPlayer, true);// Just started to be afk
                }
            }

            if (getState() != EVENT_STATE.NOT_ACTIVE) {
                ThreadPoolManager.getInstance().schedule(this, 1000);
            } else {
                for (FightClubPlayer iFPlayer : getPlayers(FIGHTING_PLAYERS)) {
                    if (iFPlayer.isAfk())
                        handleAfk(iFPlayer, false);
                }
            }
        }
    }

    private class BestTeamComparator implements Comparator<FightClubTeam>, Serializable {
        private static final long serialVersionUID = -7744947898101934099L;
        private final boolean _scoreNotKills;

        private BestTeamComparator(boolean scoreNotKills) {
            _scoreNotKills = scoreNotKills;
        }

        @Override
        public int compare(FightClubTeam o1, FightClubTeam o2) {
            if (_scoreNotKills)
                return Integer.compare(o2.getScore(), o1.getScore());
            else {
                return Integer.compare(getTeamTotalKills(o2), getTeamTotalKills(o1));
            }
        }
    }

    private static class BestPlayerComparator implements Comparator<FightClubPlayer>, Serializable {
        private static final long serialVersionUID = -7889180585474342293L;
        private final boolean _scoreNotKills;

        private BestPlayerComparator(boolean scoreNotKills) {
            _scoreNotKills = scoreNotKills;
        }

        @Override
        public int compare(FightClubPlayer arg0, FightClubPlayer arg1) {
            if (_scoreNotKills)
                return Integer.compare(arg1.getScore(), arg0.getScore());
            else
                return Integer.compare(arg1.getKills(true), arg0.getKills(true));
        }
    }

    // ===============================================================================================================
    // Event Timers
    // ===============================================================================================================

    /**
     * Big Timer - Waiting for first players, later registered teleporting to
     * event
     *
     * @param eventObjId
     * @param secondsLeft
     * @return
     */
    @Deprecated
    public static boolean teleportWholeRoomTimer(int eventObjId, int secondsLeft) {
        AbstractFightClub event = FightClubEventManager.getInstance().getEventByObjId(eventObjId);
        if (secondsLeft == 0) {
            event._dontLetAnyoneIn = true;
            event.startEvent();
        } else {
            event.checkIfRegisteredMeetCriteria();
            event.sendMessageToRegistered(MESSAGE_TYPES.SCREEN_BIG,
                    "You are going to be teleported in " + getFixedTime(secondsLeft) + "!");
        }
        return true;
    }

    /**
     * Big Timer - Starting round timer
     *
     * @param eventObjId
     * @param secondsLeft
     * @return
     */
    @Deprecated
    public static boolean startRoundTimer(int eventObjId, int secondsLeft) {
        AbstractFightClub event = FightClubEventManager.getInstance().getEventByObjId(eventObjId);

        if (secondsLeft > 0) {
            String firstWord;
            if (event.isRoundEvent())
                firstWord = ((event.getCurrentRound() + 1) == event.getTotalRounds() ? "Last"
                        : ROUND_NUMBER_IN_STRING[event.getCurrentRound() + 1]) + " Round";
            else
                firstWord = "Match";
            String message = firstWord + " is going to start in " + getFixedTime(secondsLeft) + "!";
            event.sendMessageToFighting(MESSAGE_TYPES.SCREEN_BIG, message, true);
        } else
            event.startRound();

        return true;
    }

    /**
     * Big timer - Watching when event ends
     *
     * @param eventObjId
     * @param secondsLeft
     * @return
     */
    @Deprecated
    public static boolean endRoundTimer(int eventObjId, int secondsLeft) {
        AbstractFightClub event = FightClubEventManager.getInstance().getEventByObjId(eventObjId);
        if (secondsLeft > 0)
            event.sendMessageToFighting(MESSAGE_TYPES.SCREEN_BIG, (!event.isLastRound() ? "Round" : "Match")
                    + " is going to be Over in " + getFixedTime(secondsLeft) + "!", false);
        else
            event.endRound();

        return true;
    }

    /**
     * Small timer - shutdown
     *
     * @param eventObjId
     * @param secondsLeft
     * @return
     */
    @Deprecated
    public static boolean shutDownTimer(int eventObjId, int secondsLeft) {
        AbstractFightClub event = FightClubEventManager.getInstance().getEventByObjId(eventObjId);

        if (!FightClubEventManager.getInstance().serverShuttingDown()) {
            event._dontLetAnyoneIn = false;
            return false;
        }

        if (secondsLeft < 180) {
            // Check to make it just once
            if (!event._dontLetAnyoneIn) {
                event.sendMessageToRegistered(MESSAGE_TYPES.CRITICAL,
                        "You are no longer registered because of Shutdown!");
                for (FightClubPlayer player : event.getPlayers(REGISTERED_PLAYERS)) {
                    event.unregister(player.getPlayer());
                }
                event.getObjects(REGISTERED_PLAYERS).clear();
                event._dontLetAnyoneIn = true;
            }
        }

        if (secondsLeft < 60) {
            event._timer.cancel(false);
            event.sendMessageToFighting(MESSAGE_TYPES.CRITICAL, "Event ended because of Shutdown!", false);
            event.setState(EVENT_STATE.OVER);
            event.stopEvent();

            event._dontLetAnyoneIn = false;
            return false;
        }
        return true;
    }

    /**
     * Small Timer - Teleporting player back from the event. Remove him from
     * players list before
     *
     * @param eventObjId
     * @param secondsLeft
     * @param player
     * @return
     */
    @Deprecated
    public static boolean teleportBackSinglePlayerTimer(int eventObjId, int secondsLeft, Player player) {
        AbstractFightClub event = FightClubEventManager.getInstance().getEventByObjId(eventObjId);

        if (player == null || !player.isOnline())
            return false;

        if (secondsLeft > 0)
            event.sendMessageToPlayer(player, MESSAGE_TYPES.SCREEN_BIG,
                    "You are going to be teleported back in " + getFixedTime(secondsLeft) + "!");
        else {
            event.teleportBackToTown(player);
        }

        return true;
    }

    /**
     * Small Timer - Ressurecting player
     *
     * @param eventObjId
     * @param secondsLeft
     * @param fPlayer
     * @return
     */
    @Deprecated
    public static boolean ressurectionTimer(int eventObjId, int secondsLeft, FightClubPlayer fPlayer) {
        AbstractFightClub event = FightClubEventManager.getInstance().getEventByObjId(eventObjId);
        Player player = fPlayer.getPlayer();

        if (player == null || !player.isOnline() || !player.isDead())
            return false;

        if (secondsLeft > 0)
            player.sendMessage("Respawn in " + getFixedTime(secondsLeft) + "!");
        else {
            event.hideScores(player);
            event.teleportSinglePlayer(fPlayer, false, true);
        }
        return true;
    }

    /**
     * Small Timer - Making player visible again
     *
     * @param eventObjId
     * @param secondsLeft
     * @param fPlayer
     * @param sendMessages
     * @return
     */
    @Deprecated
    public static boolean setInvisible(int eventObjId, int secondsLeft, FightClubPlayer fPlayer, boolean sendMessages) {
        AbstractFightClub event = FightClubEventManager.getInstance().getEventByObjId(eventObjId);
        if (fPlayer.getPlayer() == null || !fPlayer.getPlayer().isOnline())
            return false;

        if (secondsLeft > 0) {
            if (sendMessages)
                event.sendMessageToPlayer(fPlayer, MESSAGE_TYPES.SCREEN_BIG,
                        "Visible in " + getFixedTime(secondsLeft) + "!");
        } else {
            if (sendMessages && event.getState() == EVENT_STATE.STARTED)
                event.sendMessageToPlayer(fPlayer, MESSAGE_TYPES.SCREEN_BIG, "Fight!");
            event.stopInvisibility(fPlayer.getPlayer());
        }
        return true;

    }

    /**
     * Starting new Small or Big timer
     *
     * @param saveAsMainTimer
     * @param firstWaitingTimeInMilis
     * @param methodName
     * @param args
     * @saveAsMainTimer - should it be save to _timer?
     * @firstWaitingTimeInMilis - time before sending first msg
     * @methodName - name of the method that will be run, between every sleep
     *             and at the end
     * @args - arguments that method takes(except int eventObjId)
     */
    public void startNewTimer(boolean saveAsMainTimer, int firstWaitingTimeInMilis, String methodName, Object... args) {
        ScheduledFuture<?> timer = ThreadPoolManager.getInstance()
                .schedule(new SmartTimer(methodName, saveAsMainTimer, args), firstWaitingTimeInMilis);

        if (saveAsMainTimer)
            _timer = timer;
    }

    private class SmartTimer extends RunnableImpl {
        private final String _methodName;
        private final Object[] _args;
        private final boolean _saveAsMain;

        private SmartTimer(String methodName, boolean saveAsMainTimer, Object... args) {
            _methodName = methodName;

            Object[] changedArgs = new Object[args.length + 1];
            changedArgs[0] = getObjectId();
            for (int i = 0; i < args.length; i++)
                changedArgs[i + 1] = args[i];
            _args = changedArgs;
            _saveAsMain = saveAsMainTimer;
        }

        @Override
        public void runImpl() {
            // Preparing parameters
            Class<?>[] parameterTypes = new Class<?>[_args.length];
            for (int i = 0; i < _args.length; i++)
                parameterTypes[i] = _args[i] != null ? _args[i].getClass() : null;

            int waitingTime = (int) _args[1];

            try {
                Object ret = MethodUtils.invokeMethod(AbstractFightClub.this, _methodName, _args, parameterTypes);

                if ((boolean) ret == false)
                    return;
            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
                e.printStackTrace();
            }

            if (waitingTime > 0) {
                int toWait = getTimeToWait(waitingTime);

                waitingTime -= toWait;

                _args[1] = waitingTime;

                ScheduledFuture<?> timer = ThreadPoolManager.getInstance().schedule(this, toWait * 1000);

                if (_saveAsMain)
                    _timer = timer;
            } else
                return;
        }
    }

    @Override
    public void reCalcNextTime(boolean onInit) {
        clearActions();

        registerActions();
    }

    @Override
    protected long startTimeMillis() {
        return 0;
    }

    @Override
    public void onAddEvent(GameObject o) {
        if (o.isPlayer()) {
            o.getPlayer().addListener(_exitListener);
        }
    }

    @Override
    public void onRemoveEvent(GameObject o) {
        if (o.isPlayer()) {
            o.getPlayer().removeListener(_exitListener);
        }
    }

    @Override
    public boolean isInProgress() {
        return _state != EVENT_STATE.NOT_ACTIVE;
    }

    // Enum especial que contiene muchos sorts para los pjs y una funcion para
    // hacer sorting encadenado
    public static enum PlayerComparator implements Comparator<Player> {
        LEVEL_SORT {
            @Override
            public int compare(Player left, Player right) {
                if (left == null || right == null)
                    return 0;

                return Integer.valueOf(left.getLevel()).compareTo(right.getLevel());
            }
        },
        CLASS_SORT {
            @Override
            public int compare(Player left, Player right) {
                if (left == null || right == null)
                    return 0;

                return Integer.valueOf(left.getClassId().getType2().ordinal())
                        .compareTo(right.getClassId().getType2().ordinal());
            }
        };

        // Este comparador funciona como un comparador encadenado, donde si es
        // igual se sigue al proximo y asi hasta lograr un resultado
        public static Comparator<Player> getComparator(final PlayerComparator... multipleOptions) {
            return new Comparator<Player>() {
                @Override
                public int compare(Player o1, Player o2) {
                    for (PlayerComparator option : multipleOptions) {
                        int result = option.compare(o1, o2);
                        if (result != 0) {
                            return result;
                        }
                    }
                    return 0;
                }
            };
        }
    }
}