/*
	This file is part of the OdinMS Maple Story Server
    Copyright (C) 2008 Patrick Huy <patrick.huy@frz.cc>
		       Matthias Butz <matze@odinms.de>
		       Jan Christian Meyer <vimes@odinms.de>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as
    published by the Free Software Foundation version 3 as published by
    the Free Software Foundation. You may not use, modify or distribute
    this program under any other version of the GNU Affero General Public
    License.

    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 Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
package scripting.event;

import client.Character;
import config.YamlConfig;
import constants.game.GameConstants;
import net.server.Server;
import net.server.audit.LockCollector;
import net.server.audit.locks.MonitoredLockType;
import net.server.audit.locks.MonitoredReentrantLock;
import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
import net.server.channel.Channel;
import net.server.guild.Guild;
import net.server.world.Party;
import net.server.world.PartyCharacter;
import net.server.world.World;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import scripting.event.scheduler.EventScriptScheduler;
import server.Marriage;
import server.ThreadManager;
import server.expeditions.Expedition;
import server.life.LifeFactory;
import server.life.Monster;
import server.maps.MapleMap;
import server.quest.Quest;
import tools.exceptions.EventInstanceInProgressException;

import javax.script.Invocable;
import javax.script.ScriptException;
import java.util.*;
import java.util.concurrent.Semaphore;

import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;
//import jdk.nashorn.api.scripting.ScriptUtils;

/**
 * @author Matze
 * @author Ronan
 */
public class EventManager {
    private static final Logger log = LoggerFactory.getLogger(EventManager.class);
    private Invocable iv;
    private Channel cserv;
    private World wserv;
    private Server server;
    private final EventScriptScheduler ess = new EventScriptScheduler();
    private final Map<String, EventInstanceManager> instances = new HashMap<>();
    private final Map<String, Integer> instanceLocks = new HashMap<>();
    private final Queue<Integer> queuedGuilds = new LinkedList<>();
    private final Map<Integer, Integer> queuedGuildLeaders = new HashMap<>();
    private final List<Boolean> openedLobbys;
    private final List<EventInstanceManager> readyInstances = new LinkedList<>();
    private Integer readyId = 0, onLoadInstances = 0;
    private final Properties props = new Properties();
    private final String name;
    private MonitoredReentrantLock lobbyLock = MonitoredReentrantLockFactory.createLock(MonitoredLockType.EM_LOBBY);
    private MonitoredReentrantLock queueLock = MonitoredReentrantLockFactory.createLock(MonitoredLockType.EM_QUEUE);
    private MonitoredReentrantLock startLock = MonitoredReentrantLockFactory.createLock(MonitoredLockType.EM_START);

    private final Set<Integer> playerPermit = new HashSet<>();
    private final Semaphore startSemaphore = new Semaphore(7);

    private static final int maxLobbys = 8;     // an event manager holds up to this amount of concurrent lobbys

    public EventManager(Channel cserv, Invocable iv, String name) {
        this.server = Server.getInstance();
        this.iv = iv;
        this.cserv = cserv;
        this.wserv = server.getWorld(cserv.getWorld());
        this.name = name;

        this.openedLobbys = new ArrayList<>();
        for (int i = 0; i < maxLobbys; i++) {
            this.openedLobbys.add(false);
        }
    }

    private boolean isDisposed() {
        return onLoadInstances <= -1000;
    }

    public void cancel() {  // make sure to only call this when there are NO PLAYERS ONLINE to mess around with the event manager!
        ess.dispose();

        try {
            iv.invokeFunction("cancelSchedule", (Object) null);
        } catch (ScriptException | NoSuchMethodException ex) {
            ex.printStackTrace();
        }

        Collection<EventInstanceManager> eimList;
        synchronized (instances) {
            eimList = getInstances();
            instances.clear();
        }

        for (EventInstanceManager eim : eimList) {
            eim.dispose(true);
        }

        List<EventInstanceManager> readyEims;
        queueLock.lock();
        try {
            readyEims = new ArrayList<>(readyInstances);
            readyInstances.clear();
            onLoadInstances = Integer.MIN_VALUE / 2;
        } finally {
            queueLock.unlock();
        }

        for (EventInstanceManager eim : readyEims) {
            eim.dispose(true);
        }

        props.clear();
        cserv = null;
        wserv = null;
        server = null;
        iv = null;

        disposeLocks();
    }

    private void disposeLocks() {
        LockCollector.getInstance().registerDisposeAction(() -> emptyLocks());
    }

    private void emptyLocks() {
        lobbyLock = lobbyLock.dispose();
        queueLock = queueLock.dispose();
        startLock = startLock.dispose();
    }

    private List<Integer> convertToIntegerList(List<Object> objects) {
        List<Integer> intList = new ArrayList<>();

        for (Object object : objects) {
            intList.add((Integer) object);
        }

        return intList;
    }

    public long getLobbyDelay() {
        return YamlConfig.config.server.EVENT_LOBBY_DELAY;
    }

    private int getMaxLobbies() {
        try {
            return (int) iv.invokeFunction("getMaxLobbies");
        } catch (ScriptException | NoSuchMethodException ex) { // they didn't define a lobby range
            return maxLobbys;
        }
    }

    public EventScheduledFuture schedule(String methodName, long delay) {
        return schedule(methodName, null, delay);
    }

    public EventScheduledFuture schedule(final String methodName, final EventInstanceManager eim, long delay) {
        Runnable r = () -> {
            try {
                iv.invokeFunction(methodName, eim);
            } catch (ScriptException | NoSuchMethodException ex) {
                log.error("Event script schedule", ex);
            }
        };

        ess.registerEntry(r, delay);

        // hate to do that, but those schedules can still be cancelled, so well... Let GC do it's job
        return new EventScheduledFuture(r, ess);
    }

    public EventScheduledFuture scheduleAtTimestamp(final String methodName, long timestamp) {
        Runnable r = () -> {
            try {
                iv.invokeFunction(methodName, (Object) null);
            } catch (ScriptException | NoSuchMethodException ex) {
                log.error("Event script scheduleAtTimestamp", ex);
            }
        };

        ess.registerEntry(r, timestamp - server.getCurrentTime());
        return new EventScheduledFuture(r, ess);
    }

    public World getWorldServer() {
        return wserv;
    }

    public Channel getChannelServer() {
        return cserv;
    }

    public Invocable getIv() {
        return iv;
    }

    public EventInstanceManager getInstance(String name) {
        return instances.get(name);
    }

    public Collection<EventInstanceManager> getInstances() {
        synchronized (instances) {
            return new LinkedList<>(instances.values());
        }
    }

    public EventInstanceManager newInstance(String name) throws EventInstanceInProgressException {
        EventInstanceManager ret = getReadyInstance();

        if (ret == null) {
            ret = new EventInstanceManager(this, name);
        } else {
            ret.setName(name);
        }

        synchronized (instances) {
            if (instances.containsKey(name)) {
                throw new EventInstanceInProgressException(name, this.getName());
            }

            instances.put(name, ret);
        }
        return ret;
    }

    public Marriage newMarriage(String name) throws EventInstanceInProgressException {
        Marriage ret = new Marriage(this, name);

        synchronized (instances) {
            if (instances.containsKey(name)) {
                throw new EventInstanceInProgressException(name, this.getName());
            }

            instances.put(name, ret);
        }
        return ret;
    }

    public void disposeInstance(final String name) {
        ess.registerEntry(() -> {
            freeLobbyInstance(name);

            synchronized (instances) {
                instances.remove(name);
            }
        }, SECONDS.toMillis(YamlConfig.config.server.EVENT_LOBBY_DELAY));
    }

    public void setProperty(String key, String value) {
        props.setProperty(key, value);
    }

    public void setIntProperty(String key, int value) {
        setProperty(key, value);
    }

    public void setProperty(String key, int value) {
        props.setProperty(key, value + "");
    }

    public String getProperty(String key) {
        return props.getProperty(key);
    }

    public int getIntProperty(String key) {
        return Integer.parseInt(props.getProperty(key));
    }

    private void setLockLobby(int lobbyId, boolean lock) {
        lobbyLock.lock();
        try {
            openedLobbys.set(lobbyId, lock);
        } finally {
            lobbyLock.unlock();
        }
    }

    private boolean startLobbyInstance(int lobbyId) {
        lobbyLock.lock();
        try {
            if (lobbyId < 0) {
                lobbyId = 0;
            } else if (lobbyId >= maxLobbys) {
                lobbyId = maxLobbys - 1;
            }

            if (!openedLobbys.get(lobbyId)) {
                openedLobbys.set(lobbyId, true);
                return true;
            }

            return false;
        } finally {
            lobbyLock.unlock();
        }
    }

    private void freeLobbyInstance(String lobbyName) {
        Integer i = instanceLocks.get(lobbyName);
        if (i == null) {
            return;
        }

        instanceLocks.remove(lobbyName);
        if (i > -1) {
            setLockLobby(i, false);
        }
    }

    public String getName() {
        return name;
    }

    private int availableLobbyInstance() {
        int maxLobbies = getMaxLobbies();

        if (maxLobbies > 0) {
            for (int i = 0; i < maxLobbies; i++) {
                if (startLobbyInstance(i)) {
                    return i;
                }
            }
        }

        return -1;
    }

    private String getInternalScriptExceptionMessage(Throwable a) {
        if (!(a instanceof ScriptException)) {
            return null;
        }

        while (true) {
            Throwable t = a;
            a = a.getCause();

            if (a == null) {
                return t.getMessage();
            }
        }
    }

    private EventInstanceManager createInstance(String name, Object... args) throws ScriptException, NoSuchMethodException {
        return (EventInstanceManager) iv.invokeFunction(name, args);
    }

    private void registerEventInstance(String eventName, int lobbyId) {
        Integer oldLobby = instanceLocks.get(eventName);
        if (oldLobby != null) {
            setLockLobby(oldLobby, false);
        }

        instanceLocks.put(eventName, lobbyId);
    }

    public boolean startInstance(Expedition exped) {
        return startInstance(-1, exped);
    }

    public boolean startInstance(int lobbyId, Expedition exped) {
        return startInstance(lobbyId, exped, exped.getLeader());
    }

    //Expedition method: starts an expedition
    public boolean startInstance(int lobbyId, Expedition exped, Character leader) {
        if (this.isDisposed()) {
            return false;
        }

        try {
            if (!playerPermit.contains(leader.getId()) && startSemaphore.tryAcquire(7777, MILLISECONDS)) {
                playerPermit.add(leader.getId());

                startLock.lock();
                try {
                    try {
                        if (lobbyId == -1) {
                            lobbyId = availableLobbyInstance();
                            if (lobbyId == -1) {
                                return false;
                            }
                        } else {
                            if (!startLobbyInstance(lobbyId)) {
                                return false;
                            }
                        }

                        EventInstanceManager eim;
                        try {
                            eim = createInstance("setup", leader.getClient().getChannel());
                            registerEventInstance(eim.getName(), lobbyId);
                        } catch (ScriptException | NullPointerException e) {
                            String message = getInternalScriptExceptionMessage(e);
                            if (message != null && !message.startsWith(EventInstanceInProgressException.EIIP_KEY)) {
                                throw e;
                            }

                            if (lobbyId > -1) {
                                setLockLobby(lobbyId, false);
                            }
                            return false;
                        }

                        eim.setLeader(leader);

                        exped.start();
                        eim.registerExpedition(exped);

                        eim.startEvent();
                    } catch (ScriptException | NoSuchMethodException ex) {
                        log.error("Event script startInstance", ex);
                    }

                    return true;
                } finally {
                    startLock.unlock();
                    playerPermit.remove(leader.getId());
                    startSemaphore.release();
                }
            }
        } catch (InterruptedException ie) {
            playerPermit.remove(leader.getId());
        }

        return false;
    }

    //Regular method: player 
    public boolean startInstance(Character chr) {
        return startInstance(-1, chr);
    }

    public boolean startInstance(int lobbyId, Character leader) {
        return startInstance(lobbyId, leader, leader, 1);
    }

    public boolean startInstance(int lobbyId, Character chr, Character leader, int difficulty) {
        if (this.isDisposed()) {
            return false;
        }

        try {
            if (!playerPermit.contains(leader.getId()) && startSemaphore.tryAcquire(7777, MILLISECONDS)) {
                playerPermit.add(leader.getId());

                startLock.lock();
                try {
                    try {
                        if (lobbyId == -1) {
                            lobbyId = availableLobbyInstance();
                            if (lobbyId == -1) {
                                return false;
                            }
                        } else {
                            if (!startLobbyInstance(lobbyId)) {
                                return false;
                            }
                        }

                        EventInstanceManager eim;
                        try {
                            eim = createInstance("setup", difficulty, (lobbyId > -1) ? lobbyId : leader.getId());
                            registerEventInstance(eim.getName(), lobbyId);
                        } catch (ScriptException | NullPointerException e) {
                            String message = getInternalScriptExceptionMessage(e);
                            if (message != null && !message.startsWith(EventInstanceInProgressException.EIIP_KEY)) {
                                throw e;
                            }

                            if (lobbyId > -1) {
                                setLockLobby(lobbyId, false);
                            }
                            return false;
                        }
                        eim.setLeader(leader);

                        if (chr != null) {
                            eim.registerPlayer(chr);
                        }

                        eim.startEvent();
                    } catch (ScriptException | NoSuchMethodException ex) {
                        log.error("Event script startInstance", ex);
                    }

                    return true;
                } finally {
                    startLock.unlock();
                    playerPermit.remove(leader.getId());
                    startSemaphore.release();
                }
            }
        } catch (InterruptedException ie) {
            playerPermit.remove(leader.getId());
        }

        return false;
    }

    //PQ method: starts a PQ
    public boolean startInstance(Party party, MapleMap map) {
        return startInstance(-1, party, map);
    }

    public boolean startInstance(int lobbyId, Party party, MapleMap map) {
        return startInstance(lobbyId, party, map, party.getLeader().getPlayer());
    }

    public boolean startInstance(int lobbyId, Party party, MapleMap map, Character leader) {
        if (this.isDisposed()) {
            return false;
        }

        try {
            if (!playerPermit.contains(leader.getId()) && startSemaphore.tryAcquire(7777, MILLISECONDS)) {
                playerPermit.add(leader.getId());

                startLock.lock();
                try {
                    try {
                        if (lobbyId == -1) {
                            lobbyId = availableLobbyInstance();
                            if (lobbyId == -1) {
                                return false;
                            }
                        } else {
                            if (!startLobbyInstance(lobbyId)) {
                                return false;
                            }
                        }

                        EventInstanceManager eim;
                        try {
                            eim = createInstance("setup", (Object) null);
                            registerEventInstance(eim.getName(), lobbyId);
                        } catch (ScriptException | NullPointerException e) {
                            String message = getInternalScriptExceptionMessage(e);
                            if (message != null && !message.startsWith(EventInstanceInProgressException.EIIP_KEY)) {
                                throw e;
                            }

                            if (lobbyId > -1) {
                                setLockLobby(lobbyId, false);
                            }
                            return false;
                        }

                        eim.setLeader(leader);

                        eim.registerParty(party, map);
                        party.setEligibleMembers(null);

                        eim.startEvent();
                    } catch (ScriptException | NoSuchMethodException ex) {
                        log.error("Event script startInstance", ex);
                    }

                    return true;
                } finally {
                    startLock.unlock();
                    playerPermit.remove(leader.getId());
                    startSemaphore.release();
                }
            }
        } catch (InterruptedException ie) {
            playerPermit.remove(leader.getId());
        }

        return false;
    }

    //PQ method: starts a PQ with a difficulty level, requires function setup(difficulty, leaderid) instead of setup()
    public boolean startInstance(Party party, MapleMap map, int difficulty) {
        return startInstance(-1, party, map, difficulty);
    }

    public boolean startInstance(int lobbyId, Party party, MapleMap map, int difficulty) {
        return startInstance(lobbyId, party, map, difficulty, party.getLeader().getPlayer());
    }

    public boolean startInstance(int lobbyId, Party party, MapleMap map, int difficulty, Character leader) {
        if (this.isDisposed()) {
            return false;
        }

        try {
            if (!playerPermit.contains(leader.getId()) && startSemaphore.tryAcquire(7777, MILLISECONDS)) {
                playerPermit.add(leader.getId());

                startLock.lock();
                try {
                    try {
                        if (lobbyId == -1) {
                            lobbyId = availableLobbyInstance();
                            if (lobbyId == -1) {
                                return false;
                            }
                        } else {
                            if (!startLobbyInstance(lobbyId)) {
                                return false;
                            }
                        }

                        EventInstanceManager eim;
                        try {
                            eim = createInstance("setup", difficulty, (lobbyId > -1) ? lobbyId : party.getLeaderId());
                            registerEventInstance(eim.getName(), lobbyId);
                        } catch (ScriptException | NullPointerException e) {
                            String message = getInternalScriptExceptionMessage(e);
                            if (message != null && !message.startsWith(EventInstanceInProgressException.EIIP_KEY)) {
                                throw e;
                            }

                            if (lobbyId > -1) {
                                setLockLobby(lobbyId, false);
                            }
                            return false;
                        }

                        eim.setLeader(leader);

                        eim.registerParty(party, map);
                        party.setEligibleMembers(null);

                        eim.startEvent();
                    } catch (ScriptException | NoSuchMethodException ex) {
                        log.error("Event script startInstance", ex);
                    }

                    return true;
                } finally {
                    startLock.unlock();
                    playerPermit.remove(leader.getId());
                    startSemaphore.release();
                }
            }
        } catch (InterruptedException ie) {
            playerPermit.remove(leader.getId());
        }

        return false;
    }

    //non-PQ method for starting instance
    public boolean startInstance(EventInstanceManager eim, String ldr) {
        return startInstance(-1, eim, ldr);
    }

    public boolean startInstance(EventInstanceManager eim, Character ldr) {
        return startInstance(-1, eim, ldr.getName(), ldr);
    }

    public boolean startInstance(int lobbyId, EventInstanceManager eim, String ldr) {
        return startInstance(-1, eim, ldr, eim.getEm().getChannelServer().getPlayerStorage().getCharacterByName(ldr));  // things they make me do...
    }

    public boolean startInstance(int lobbyId, EventInstanceManager eim, String ldr, Character leader) {
        if (this.isDisposed()) {
            return false;
        }

        try {
            if (!playerPermit.contains(leader.getId()) && startSemaphore.tryAcquire(7777, MILLISECONDS)) {
                playerPermit.add(leader.getId());

                startLock.lock();
                try {
                    try {
                        if (lobbyId == -1) {
                            lobbyId = availableLobbyInstance();
                            if (lobbyId == -1) {
                                return false;
                            }
                        } else {
                            if (!startLobbyInstance(lobbyId)) {
                                return false;
                            }
                        }

                        if (eim == null) {
                            if (lobbyId > -1) {
                                setLockLobby(lobbyId, false);
                            }
                            return false;
                        }
                        registerEventInstance(eim.getName(), lobbyId);
                        eim.setLeader(leader);

                        iv.invokeFunction("setup", eim);
                        eim.setProperty("leader", ldr);

                        eim.startEvent();
                    } catch (ScriptException | NoSuchMethodException ex) {
                        log.error("Event script startInstance", ex);
                    }

                    return true;
                } finally {
                    startLock.unlock();
                    playerPermit.remove(leader.getId());
                    startSemaphore.release();
                }
            }
        } catch (InterruptedException ie) {
            playerPermit.remove(leader.getId());
        }

        return false;
    }

    public List<PartyCharacter> getEligibleParty(Party party) {
        if (party == null) {
            return new ArrayList<>();
        }
        try {
            Object o = iv.invokeFunction("getEligibleParty", party.getPartyMembersOnline());

            if (o instanceof PartyCharacter[] partyChrs) {
                final List<PartyCharacter> eligibleParty = new ArrayList<>(Arrays.asList(partyChrs));
                party.setEligibleMembers(eligibleParty);
                return eligibleParty;
            }
        } catch (ScriptException | NoSuchMethodException ex) {
            ex.printStackTrace();
        }

        return new ArrayList<>();
    }

    public void clearPQ(EventInstanceManager eim) {
        try {
            iv.invokeFunction("clearPQ", eim);
        } catch (ScriptException | NoSuchMethodException ex) {
            log.error("Event script clearPQ", ex);
        }
    }

    public void clearPQ(EventInstanceManager eim, MapleMap toMap) {
        try {
            iv.invokeFunction("clearPQ", eim, toMap);
        } catch (ScriptException | NoSuchMethodException ex) {
            log.error("Event script clearPQ", ex);
        }
    }

    public Monster getMonster(int mid) {
        return (LifeFactory.getMonster(mid));
    }

    private void exportReadyGuild(Integer guildId) {
        Guild mg = server.getGuild(guildId);
        String callout = "[Guild Quest] Your guild has been registered to attend to the Sharenian Guild Quest at channel " + this.getChannelServer().getId()
                + " and HAS JUST STARTED THE STRATEGY PHASE. After 3 minutes, no more guild members will be allowed to join the effort."
                + " Check out Shuang at the excavation site in Perion for more info.";

        mg.dropMessage(6, callout);
    }

    private void exportMovedQueueToGuild(Integer guildId, int place) {
        Guild mg = server.getGuild(guildId);
        String callout = "[Guild Quest] Your guild has been registered to attend to the Sharenian Guild Quest at channel " + this.getChannelServer().getId()
                + " and is currently on the " + GameConstants.ordinal(place) + " place on the waiting queue.";

        mg.dropMessage(6, callout);
    }

    private List<Integer> getNextGuildQueue() {
        synchronized (queuedGuilds) {
            Integer guildId = queuedGuilds.poll();
            if (guildId == null) {
                return null;
            }

            wserv.removeGuildQueued(guildId);
            Integer leaderId = queuedGuildLeaders.remove(guildId);

            int place = 1;
            for (Integer i : queuedGuilds) {
                exportMovedQueueToGuild(i, place);
                place++;
            }

            List<Integer> list = new ArrayList<>(2);
            list.add(guildId);
            list.add(leaderId);
            return list;
        }
    }

    public boolean isQueueFull() {
        synchronized (queuedGuilds) {
            return queuedGuilds.size() >= YamlConfig.config.server.EVENT_MAX_GUILD_QUEUE;
        }
    }

    public int getQueueSize() {
        synchronized (queuedGuilds) {
            return queuedGuilds.size();
        }
    }

    public byte addGuildToQueue(Integer guildId, Integer leaderId) {
        if (wserv.isGuildQueued(guildId)) {
            return -1;
        }

        if (!isQueueFull()) {
            boolean canStartAhead;
            synchronized (queuedGuilds) {
                canStartAhead = queuedGuilds.isEmpty();

                queuedGuilds.add(guildId);
                wserv.putGuildQueued(guildId);
                queuedGuildLeaders.put(guildId, leaderId);

                int place = queuedGuilds.size();
                exportMovedQueueToGuild(guildId, place);
            }

            if (canStartAhead) {
                if (!attemptStartGuildInstance()) {
                    synchronized (queuedGuilds) {
                        queuedGuilds.add(guildId);
                        wserv.putGuildQueued(guildId);
                        queuedGuildLeaders.put(guildId, leaderId);
                    }
                } else {
                    return 2;
                }
            }

            return 1;
        } else {
            return 0;
        }
    }

    public boolean attemptStartGuildInstance() {
        Character chr = null;
        List<Integer> guildInstance = null;
        while (chr == null) {
            guildInstance = getNextGuildQueue();
            if (guildInstance == null) {
                return false;
            }

            chr = cserv.getPlayerStorage().getCharacterById(guildInstance.get(1));
        }

        if (startInstance(chr)) {
            exportReadyGuild(guildInstance.get(0));
            return true;
        } else {
            return false;
        }
    }

    public void startQuest(Character chr, int id, int npcid) {
        try {
            Quest.getInstance(id).forceStart(chr, npcid);
        } catch (NullPointerException ex) {
            ex.printStackTrace();
        }
    }

    public void completeQuest(Character chr, int id, int npcid) {
        try {
            Quest.getInstance(id).forceComplete(chr, npcid);
        } catch (NullPointerException ex) {
            ex.printStackTrace();
        }
    }

    public int getTransportationTime(int travelTime) {
        return this.getWorldServer().getTransportationTime(travelTime);
    }

    private void fillEimQueue() {
        ThreadManager.getInstance().newTask(new EventManagerTask());  //call new thread to fill up readied instances queue
    }

    private EventInstanceManager getReadyInstance() {
        queueLock.lock();
        try {
            if (readyInstances.isEmpty()) {
                fillEimQueue();
                return null;
            }

            EventInstanceManager eim = readyInstances.remove(0);
            fillEimQueue();

            return eim;
        } finally {
            queueLock.unlock();
        }
    }

    private void instantiateQueuedInstance() {
        int nextEventId;
        queueLock.lock();
        try {
            if (this.isDisposed() || readyInstances.size() + onLoadInstances >= Math.ceil((double) maxLobbys / 3.0)) {
                return;
            }

            onLoadInstances++;
            nextEventId = readyId;
            readyId++;
        } finally {
            queueLock.unlock();
        }

        EventInstanceManager eim = new EventInstanceManager(this, "sampleName" + nextEventId);
        queueLock.lock();
        try {
            if (this.isDisposed()) {  // EM already disposed
                return;
            }

            readyInstances.add(eim);
            onLoadInstances--;
        } finally {
            queueLock.unlock();
        }

        instantiateQueuedInstance();    // keep filling the queue until reach threshold.
    }

    private class EventManagerTask implements Runnable {

        @Override
        public void run() {
            instantiateQueuedInstance();
        }
    }
}