package Server;

import Model.Messages.Message;
import Model.Network.Token;
import Model.Network.UserSession;

import java.util.*;

import Utils.*;
import Config.*;

/**
 * Class NetworkScheduler will send Messages to the connected clients based on
 * what those messages are (it will pack them into json strings) and based on
 * if enough time has passed since the last dispatched set of messages, simply call
 * send(Message m) and it will be done
 */
public class NetworkScheduler {
    private List<Message> openMessages;
    private Map<Token, Long> lastSentAt;
    private GameServer gameServer;

    public NetworkScheduler() {
        openMessages = new ArrayList<Message>();
        lastSentAt = new HashMap<Token, Long>();
    }

    public void setServer(GameServer server) {
        gameServer = server;
    }

    public void send(final Message message) {
        System.out.println(message.getSubject());
        if(lastSentAt.containsKey(message.getReceptor())) {
            // User has been sent messages some time ago
            final long oldTimer = lastSentAt.get(message.getReceptor());
            final long nowTimer = Utils.calcTime();

            long gap = nowTimer - oldTimer;
            System.out.println("dif: " + gap);
            if(gap > Config.MAX_MESSAGES_TIMER) {
                // It's ok, enough time has passed, send message and possibly old open messages
                UserSession session = gameServer.getConnectedUser(message.getReceptor());

                // Fix for ConcurrentModificationException
                for (Iterator<Message> iterator = openMessages.iterator(); iterator.hasNext();) {
                    Message m = iterator.next();
                    if (m.getReceptor().equals(message.getReceptor())) {
                        // Remove the current element from the iterator and the list.
                        session.getConnection().send(JSONEncoder.create(m));
                        iterator.remove();
                    }
                }

                session.getConnection().send(JSONEncoder.create(message));
                lastSentAt.put(message.getReceptor(), nowTimer);
                Logger.logDebug("Message(s) to User " + message.getReceptor().toString() + " have been sent at");
            }
            else {
                // Not enough time has passed, add message to queue
                openMessages.add(message);
                final long timeToWait = Config.MAX_MESSAGES_TIMER - gap;

                class Sleeper implements Runnable {
                    @Override
                    public void run() {
                        try {
                            // Let the Thread sleep until the batch can be send
                            Thread.sleep(timeToWait);
                            send(message);
                        }
                        catch (InterruptedException e) {
                            Logger.logError("Thread interrupted for User " + message.getReceptor().toString());
                        }
                    }
                }

                new Thread(new Sleeper()).start();

                Logger.logDebug("Message to User " + message.getReceptor().toString() + " needs to wait for " + timeToWait);
            }
        }
        else {
            // It seems this user has never been sent something, sent the Message and add him to the lastSentAt
            lastSentAt.put(message.getReceptor(), Utils.calcTime());
            UserSession session = gameServer.getConnectedUser(message.getReceptor());
            session.getConnection().send(JSONEncoder.create(message));
            Logger.logDebug("Message to User " + message.getReceptor().toString() + " has been sent");
        }
    }

    /**
     * deleteFor(Token) will delete all open Messages to this client Token in case
     * the client dc'ed or has quit the game etc.
     * @param token The token to identify the client
     */
    public void deleteFor(Token token) {
        for(Message m : openMessages) {
            if(m.getReceptor().equals(token)) {
                openMessages.remove(m);
            }
        }
    }
}