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 int[] itemids = {4000110, 4000109, 4000108};
    //   private final static ArrayList<MapleMap> maps = new ArrayList<MapleMap>();
    private int count = 0;
    private boolean on = false;
    private boolean open = false;
    private ChannelServer c = ChannelServer.getInstance(1);
    private WorldChannelInterface wci = c.getWorldInterface();

    public ChaseyEvent() {
        // schedule();
        open();
        //timer = new timer((sf0f, 30, -1, -1, -1));
    }

   /* private void schedule() {
        on = false;
        open = false;
        sendClock(2 * 60 * 60);
        TimerManager.getInstance().schedule(new Runnable() {

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

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

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

    private void time() {
        int time = 30 * 60;
        sendClock(time);
        TimerManager.getInstance().schedule(new Runnable() {

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

    private void start() {
        on = true;
        open = false;
        if (players.size() < 2) {
            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();
            }
            assignChaser();
            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 @joinchasey to get in!").getBytes());
        } catch (RemoteException ex) {
            c.reconnectWorld();
        }
        rest();
    }

    public boolean addPlayer(String name) {
        if (on && open) {
            MapleCharacter player = c.getPlayerStorage().getCharacterByName(name);
            if (players.contains(player)) {
                return false;
            }
            if (player != null) {
                warpIn(player);
                return true;
            }
            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 across channels. This might take a few seconds");
                        ChangeChannelHandler.changeChannel(1, world_victim.getClient());
                    } else {
                        return false;
                    }
                } else {
                    return false;
                }
            } catch (RemoteException e) {
                c.reconnectWorld();
            }
            final String name1 = name;
            TimerManager.getInstance().schedule(new Runnable() {

                @Override
                public void run() {
                    MapleCharacter player = c.getPlayerStorage().getCharacterByName(name1);
                    warpIn(player);
                }
            }, 3 * 1000);
            return true;
        } else {
            return false;
        }
    }

    public boolean hasChaser() { // make a npc to check this.
        boolean b = false;
        for (MapleCharacter player : players) {
            if (c.getPlayerStorage().getCharacterById(player.getId()) == 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(109010100);
        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 boolean removePlayer(MapleCharacter player) {
        if (on) {
            players.remove(player);
            player.changeMap(109050001);
            sendMessage(player.getName() + " has left the chasey event");
            return true;
        }
        return false;
    }

    private void assignChaser() {
        Random rand = new Random();
        MapleCharacter chaser = players.get(rand.nextInt(players.size()));
        if (count == players.size()) {
            end();
            return;
        }
        if (chaser == null) {
            assignChaser();
            count++;
            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);
        sendMessage(player.getName() + " has just won the event!");
        end();
    }

    public String getPlayers() {
        String str = "";
        for (MapleCharacter chars : players) {
            str += chars.getName() + " ";
        }
        return str;
    }

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

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

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

    private void sendClock(int time) {
        for (MapleCharacter player : players) {
            if (c.getPlayerStorage().getCharacterById(player.getId()) == null) {
                players.remove(player);
            } else {
                player.getClient().getSession().write(MaplePacketCreator.getClock(time));
            }
        }
    }

    private void endShort() {
        if (on && !open) {
            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.");
        sendClock(30);
        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);

    }
}