package net.sf.odinms.tools;

import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Random;
import net.sf.odinms.client.IItem;
import net.sf.odinms.client.MapleCharacter;
import net.sf.odinms.net.channel.ChannelServer;
import net.sf.odinms.net.channel.handler.ChangeChannelHandler;
import net.sf.odinms.net.world.remote.WorldChannelInterface;
import net.sf.odinms.server.MapleInventoryManipulator;
import net.sf.odinms.server.MapleItemInformationProvider;
import net.sf.odinms.server.MaplePortal;
import net.sf.odinms.server.TimerManager;
import net.sf.odinms.server.maps.MapleMap;

/**
 *
 * @author Hugo
 */
public class ChaseyEvent {

    private LinkedList<MapleCharacter> players = new LinkedList<MapleCharacter>();
    private static final int[] itemids = {1, 2, 3};
    //   private final static ArrayList<MapleMap> maps = new ArrayList<MapleMap>();
    private boolean on = false;
    private boolean open = false;
    private ChannelServer c = ChannelServer.getInstance(1);
    private WorldChannelInterface wci = c.getWorldInterface();

    public ChaseyEvent() {
        schedule();
    }

    /* static {
    loadMaps();
    }
    public static void loadMaps() {
    maps.add(null);
    }*/
    public ChaseyEvent getThis() {
        return this;
    }

    private void schedule() {
        on = false;
        TimerManager.getInstance().schedule(new Runnable() {

            @Override
            public void run() {
                open();
            }
        }, 2 * 60 * 60 * 1000);
    }

    private void rest() {
        TimerManager.getInstance().schedule(new Runnable() {

            @Override
            public void run() {
                start();
            }
        }, 1 * 60 * 1000);
    }

    private void time() {
        TimerManager.getInstance().schedule(new Runnable() {

            @Override
            public void run() {
                endShort();
            }
        }, 20 * 60 * 1000);


    }

    private void start() {
        on = true;
        open = false;
        if (players.size() < 4) {
            try {
                wci.broadcastMessage(null, MaplePacketCreator.serverNotice(5, "[Chasey Event] The event was cancelled. Not enough players joined. Better luck next time.").getBytes());
            } catch (RemoteException ex) {
                c.reconnectWorld();
            }
            end();
        } else {
            try {
                wci.broadcastMessage(null, MaplePacketCreator.serverNotice(5, "[Chasey Event] The event has started! You will no longer be allowed to join").getBytes());
            } catch (RemoteException ex) {
                c.reconnectWorld();
            }
            time();
        }
    }

    private void open() {
        on = true;
        open = true;
        try {
            wci.broadcastMessage(null, MaplePacketCreator.serverNotice(5, "[Chasey Event] The event is going to start in one minute! Use @chasey to get in!").getBytes());
        } catch (RemoteException ex) {
            c.reconnectWorld();
        }
        rest();
    }

    public boolean addPlayer(String name) {
        if (on && open) {
            MapleCharacter player = c.getPlayerStorage().getCharacterByName(name);
            boolean xChannel = false;
            if (player == null) {
                try {
                    int channel = wci.find(name);
                    if (channel > -1) {
                        ChannelServer pserv = ChannelServer.getInstance(channel);
                        final MapleCharacter world_victim = pserv.getPlayerStorage().getCharacterByName(name);
                        if (world_victim != null) {
                            world_victim.dropMessage("[Chasey Event] You are being warped cross channels. This might take a few seconds");
                            ChangeChannelHandler.changeChannel(1, world_victim.getClient());
                        }
                        xChannel = true;
                    } else {
                        return false;
                    }
                } catch (RemoteException e) {
                    c.reconnectWorld();
                }
            }
            if (xChannel) {
                final MapleCharacter victim = c.getPlayerStorage().getCharacterByName(name);
                TimerManager.getInstance().schedule(new Runnable() {

                    public void run() {
                        warpIn(victim);

                    }
                }, 1 * 1000);
            } else {
                warpIn(player);
            }
            return true;
        } else {
            return false;
        }
    }

    public boolean hasChaser() {
        boolean b = false;
        for (MapleCharacter player : players) {
            if (player == null) {
                players.remove(player);
            } else {
                if (player.isChaser()) {
                    b = true;
                }
            }
        }
        if (b) {
            return false;
        } else {
            assignChaser();
            return true;
        }
    }

    private void warpIn(MapleCharacter player) {
        MapleMap target = c.getMapFactory().getMap(109050001);
        Random rand = new Random();
        MaplePortal portal = target.getPortal(rand.nextInt(target.getPortals().size()));
        player.changeMap(target, portal);
        players.add(player);
        sendMessage(player.getName() + " has joined the chasey event");
    }

    public void removePlayer(MapleCharacter player) {
        players.remove(player);
        player.changeMap(109050001);
        sendMessage(player.getName() + " has left the chasey event");
    }

    private void assignChaser() {
        Random rand = new Random();
        MapleCharacter chaser = players.get(rand.nextInt(players.size()));
        if (chaser == null) {
            assignChaser();
            return;
        } else {
            chaser.setChaser();
            sendMessage(chaser.getName() + " has just been randomly assigned as the first chaser");
        }
    }

    private void givePrize(MapleCharacter player) {
        MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
        Random rand = new Random();
        int itemid = itemids[rand.nextInt(itemids.length)];
        IItem item = ii.getEquipById(itemid);
        MapleInventoryManipulator.addFromDrop(player.getClient(), item, true);
        end();
    }

    public void setChaser(MapleCharacter player, MapleCharacter victim) {
        int count = 0;
        if (player == null) {
            players.remove(player);
        } else if (victim == null) {
            players.remove(victim);
        } else {
            for (MapleCharacter chars : players) {
                if (!chars.isChaser()) {
                    count++;
                }
            }
            if (!victim.isChaser()) {
                victim.setChaser();
                sendMessage(player.getName() + " has just caught " + victim.getName());
            }
            if (count < 2) {
                for (MapleCharacter chars : players) {
                    if (!chars.isChaser()) {
                        givePrize(player);
                    }
                }
            }
        }
    }

    public boolean isChaser(MapleCharacter player) {
        if (player == null) {
            players.remove(player);
            return false;
        } else {
            return player.isChaser();
        }
    }

    public boolean isOn() {
        return on == true;
    }

    public boolean isOpen() {
        return open == true;
    }

    private void sendMessage(String txt) {
        for (MapleCharacter player : players) {
            if (player == null) {
                players.remove(player);
            } else {
                player.dropMessage("[Chasey Event] " + txt);
            }
        }
    }

    private void endShort() {
        ArrayList<MapleCharacter> winners = new ArrayList<MapleCharacter>();
        for (MapleCharacter chars : players) {
            if (!chars.isChaser()) {
                winners.add(chars);
            }
        }
        Random rand = new Random();
        MapleCharacter winner = winners.get(rand.nextInt(winners.size()));
        MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
        int itemid = itemids[rand.nextInt(itemids.length)];
        IItem item = ii.getEquipById(itemid);
        MapleInventoryManipulator.addFromDrop(winner.getClient(), item, true);
        try {
            wci.broadcastMessage(null, MaplePacketCreator.serverNotice(5, "[Chasey Event] Time is over. " + winner.getName() + " was randomly selected as the winner!").getBytes());
        } catch (RemoteException ex) {
            c.reconnectWorld();
        }
        end();
    }

    public void end() {
        sendMessage("Event is over. You will be warped out shortly.");
        TimerManager.getInstance().schedule(new Runnable() {

            @Override
            public void run() {
                for (MapleCharacter player : players) {
                    player.unSetChaser();
                    if (player != null) {
                        player.changeMap(109050001);
                    }
                }
                players.clear();
                on = false;
                open = false;
                schedule();
            }
        }, 30 * 1000);

    }
}