2v2 korean event

/*
 * This program is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program. If not, see <http://www.gnu.org/licenses/>.
 */
package mods.eventmodKorea;

/**************************************************************************************************************
 *                                                                                                            *
 *                                      @author horato                                                        *
 *                                       Made for L2world.org                                                 *
 *                                                                                                            *
 **************************************************************************************************************/
import java.util.List;
import java.util.Random;
import java.util.concurrent.ScheduledFuture;

import javolution.util.FastList;

import com.l2jserver.Config;
import com.l2jserver.gameserver.Announcements;
import com.l2jserver.gameserver.ThreadPoolManager;
import com.l2jserver.gameserver.datatables.SkillTable;
import com.l2jserver.gameserver.instancemanager.QuestManager;
import com.l2jserver.gameserver.model.L2Party;
import com.l2jserver.gameserver.model.actor.L2Character;
import com.l2jserver.gameserver.model.actor.L2Npc;
import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
import com.l2jserver.gameserver.model.quest.Event;
import com.l2jserver.gameserver.model.quest.Quest;
import com.l2jserver.gameserver.model.quest.QuestState;
import com.l2jserver.gameserver.skills.AbnormalEffect;

public class eventmodKorea extends Event
{
    // Event state
    enum EventState
    {
        INACTIVE, ACTIVE, FIGHT, WAIT
    }

    public static EventState _state = EventState.INACTIVE;
    // Start npc ID
    private static final int _npc_id = 900105;
    // Initialize team list
    private List<L2Party> _teams = new FastList<L2Party>();
    private List<L2Party> _allteams = new FastList<L2Party>();
    // Event Task
    ScheduledFuture<?> _eventTask = null;
    // Npc
    private L2Npc _npc;
    // 2 Currently fighting party
    private L2Party _team1;
    private L2Party _team2;
    // Random for chosing teams
    Random rnd = new Random();
    // Winners and losers from matches
    private List<L2Party> _winners = new FastList<L2Party>();
    private List<L2Party> _losers = new FastList<L2Party>();

    public static void main(String[] args)
    {
        new eventmodKorea(-1, "eventmodKorea", "mods");
    }

    public eventmodKorea(int questId, String name, String descr)
    {
        super(questId, name, descr);

        addStartNpc(_npc_id);
        addFirstTalkId(_npc_id);
        addTalkId(_npc_id);
    }

    @Override
    public boolean eventStart()
    {
        // Don't start event if its active
        if (_state == EventState.ACTIVE)
            return false;
        if (!Config.CUSTOM_NPC_TABLE)
            return false;
        // Set active
        _state = EventState.ACTIVE;
        //Clear player list, npc lists and score
        _npc = null;
        if (!_teams.isEmpty())
            _teams.clear();

        // Spawn event manager
        _npc = addSpawn(_npc_id, 82798, 148650, -3464, 0, false, 0);

        Announcements.getInstance().announceToAll("Korean 2v2 event started");

        _eventTask = ThreadPoolManager.getInstance().scheduleGeneral(new Runnable()
        {
            public void run()
            {
                Announcements.getInstance().announceToAll("Korean 2v2 Event: 10 minutes left");
                try
                {
                    Thread.sleep(/*5*/1 * 60 * 1000); //1 min
                    /*Announcements.getInstance().announceToAll("Korean 2v2 Event: 5 minutes left");
                    Thread.sleep(2 * 60 * 1000); //1 min
                    Announcements.getInstance().announceToAll("Korean 2v2 Event: 3 minutes left");
                    Thread.sleep(2 * 60 * 1000); //1 min
                    Announcements.getInstance().announceToAll("Korean 2v2 Event: 1 minutes left");
                    Thread.sleep(1 * 60 * 1000); //1 min*/
                    StartEvent();
                }
                catch (InterruptedException e)
                {
                    Announcements.getInstance().announceToAll("Event error");
                    eventStop();
                }
            }
        }, 1);

        return true;
    }

    @Override
    public boolean eventStop()
    {
        // Don't stop inactive event
        if (_state == EventState.INACTIVE)
            return false;
        // Thread stop
        if (!_eventTask.isDone())
            _eventTask.cancel(true);
        // Set inactive
        _state = EventState.INACTIVE;
        //TODO: event end

        for (L2Party party : _allteams)
        {
            for (L2PcInstance player : party.getPartyMembers())
            {
                player.removeNotifyQuestOfDeath(player.getQuestState(getName()));
                player.stopAbnormalEffect(AbnormalEffect.HOLD_2);
                player.setIsParalyzed(false);
                player.stopParalyze(false);
                player.teleToLocation(83478, 148628, -3405);
            }
        }

        for (L2Party party : _teams)
        {
            for (L2PcInstance player : party.getPartyMembers())
            {
                player.addItem("eventmodSubclassTvT", 4037, 10, _npc, true);
            }
        }

        // Remove NPC
        if (_npc != null)
            _npc.deleteMe();
        // Clear teams
        if (!_teams.isEmpty())
            _teams.clear();
        if (!_losers.isEmpty())
            _losers.clear();
        if (!_winners.isEmpty())
            _winners.clear();

        Announcements.getInstance().announceToAll("Korean 2v2 event finished");

        return true;
    }

    @Override
    public boolean eventBypass(L2PcInstance activeChar, String bypass)
    {
        return false;
    }

    @Override
    public String onFirstTalk(L2Npc npc, L2PcInstance player)
    {
        QuestState st = player.getQuestState(getName());
        if (st == null)
        {
            Quest q = QuestManager.getInstance().getQuest(getName());
            st = q.newQuestState(player);
        }
        if (npc.getNpcId() == _npc_id)
        {
            return "korean.htm";
        }
        return npc.getNpcId() + ".htm";
    }

    @Override
    public String onAdvEvent(String event, L2Npc npc, L2PcInstance player)
    {
        // Registering
        if (event.startsWith("signup"))
        {
            if (!player.isInParty())
                return "korean-fail.htm";
            if (_teams.contains(player.getParty()))
                return "korean-onlist.htm";
            if (player.getParty().getMemberCount() != 2)
                return "korean-fail.htm";
            if (player.getParty().getLeader() != player)
                return "korean-notleader.htm";

            _teams.add(player.getParty());
            return "korean-signed.htm";
        }

        // Unregistering
        if (event.startsWith("signdown"))
        {
            if (!_teams.contains(player.getParty()))
                return "korean-notreg.htm";
            if (player.getParty().getLeader() != player)
                return "korean-notleader.htm";
            if (player.getParty().getLeader() == player)
            {
                _teams.remove(player.getParty());
                return "korean-unsigned.htm";
            }
        }

        return "";
    }

    private void StartEvent()
    {
        // Remove registration NPC
        if (_npc != null)
            _npc.deleteMe();

        for (L2Party party : _teams)
        {
            if (party.getMemberCount() < 2)
            {
                _teams.remove(party);
            }
        }
        if(_teams.size() < 2)
        {
            Announcements.getInstance().announceToAll("Not enough players to start event");
            eventStop();

        }
        // Teleport players to wait location.
        for (L2Party party : _teams)
        {
             _allteams.add(party);
            for (L2PcInstance player : party.getPartyMembers())
            {
                player.addNotifyQuestOfDeath(player.getQuestState(getName()));
                player.stopAllEffectsExceptThoseThatLastThroughDeath();
                player.setCurrentCp(player.getMaxCp());
                player.setCurrentMp(player.getMaxMp());
                player.setCurrentHp(player.getMaxHp());
                player.startAbnormalEffect(AbnormalEffect.HOLD_2);
                player.setIsParalyzed(true);
                player.startParalyze();
                player.teleToLocation(149375, 47544, -3413);
            }
        }

        // Chose 2 teams and start fight
        while (_teams.size() > 1)
        {
            while (_teams.size() > 1)
            {
                choseTeamsAndStartFight();

                if (_teams.size() == 1)
                {
                    _winners.add(_teams.get(0));
                }
            }

            _teams.removeAll(_teams);
            for (L2Party _party : _winners)
                _teams.add(_party);
            _winners.clear();
        }
        Announcements.getInstance().announceToAll("Winner is " + _teams.get(0).getLeader().getName() + "'s party");

        eventStop();
    }

    private void choseTeamsAndStartFight()
    {

        while (_team1 == null || _team2 == null)
        {
            _team1 = _teams.get(rnd.nextInt(_teams.size()));
            _team2 = _teams.get(rnd.nextInt(_teams.size()));
            if (_team2 == _team1)
                _team2 = null;
            if (_winners.contains(_team1) || _losers.contains(_team1))
                _team1 = null;
            if (_winners.contains(_team2) || _losers.contains(_team2))
                _team2 = null;
        }

        for (L2PcInstance player : _team1.getPartyMembers())
        {
            player.stopAllEffectsExceptThoseThatLastThroughDeath();
            player.teleToLocation(148839 + rnd.nextInt(5), 46741 + rnd.nextInt(5), -3413);

        }
        for (L2PcInstance player : _team2.getPartyMembers())
        {
            player.stopAllEffectsExceptThoseThatLastThroughDeath();
            player.teleToLocation(149847 + rnd.nextInt(5), 46684 + rnd.nextInt(5), -3413);

        }
        _team1.getPartyMembers().get(0).stopAbnormalEffect(AbnormalEffect.HOLD_2);
        _team2.getPartyMembers().get(0).stopAbnormalEffect(AbnormalEffect.HOLD_2);

        _state = EventState.FIGHT;

        while (_state == EventState.FIGHT)
        {

        }

    }

    @Override
    public String onDeath(L2Character killer, L2Character victim, QuestState qs)
    {
        whoWon(killer, victim);

        _state = EventState.WAIT;
        return super.onDeath(killer, victim, qs);
    }

    private String whoWon(L2Character killer, L2Character victim)
    {
        // Team 1 win
        if (_team1.getPartyMembers().contains(killer))
        {
            for (final L2Character _char : _team2.getPartyMembers())
            {
                if (!_char.isDead())
                {
                    _team2.getPartyMembers().get(1).stopAbnormalEffect(AbnormalEffect.HOLD_2);
                    return "";
                }
            }

            ThreadPoolManager.getInstance().scheduleGeneral(new Runnable()
            {
                public void run()
                {
                    for (final L2Character _char : _team1.getPartyMembers())
                    {

                        if (_char.isDead())
                            _char.doRevive();

                        _char.startAbnormalEffect(AbnormalEffect.HOLD_2);
                        _char.setIsParalyzed(true);
                        _char.startParalyze();
                        _char.teleToLocation(149375, 47544, -3413);
                        SkillTable.getInstance().getInfo(1323, 1).getEffects(null, _char);

                    }
                    _teams.remove(_team2);
                    _teams.remove(_team1);
                    _losers.add(_team2);
                    _winners.add(_team1);
                }
            }, 2 * 1000);

        }

        // Team 2 win
        if (_team2.getPartyMembers().contains(killer))
        {
            for (final L2Character _char : _team1.getPartyMembers())
            {
                if (!_char.isDead())
                {
                    _team1.getPartyMembers().get(1).stopAbnormalEffect(AbnormalEffect.HOLD_2);
                    return "";
                }
            }

            ThreadPoolManager.getInstance().scheduleGeneral(new Runnable()
            {
                public void run()
                {
                    for (final L2Character _char : _team2.getPartyMembers())
                    {

                        if (_char.isDead())
                            _char.doRevive();

                        _char.startAbnormalEffect(AbnormalEffect.HOLD_2);
                        _char.setIsParalyzed(true);
                        _char.startParalyze();
                        _char.teleToLocation(149375, 47544, -3413);
                        SkillTable.getInstance().getInfo(1323, 1).getEffects(null, _char);

                    }
                    _teams.remove(_team1);
                    _teams.remove(_team2);
                    _losers.add(_team1);
                    _winners.add(_team2);
                }
            }, 2 * 1000);

        }

        return "";
    }

}