package com.todomvc.client.command;

import static com.google.common.base.Preconditions.checkNotNull;

import java.util.logging.Logger;

import com.google.common.annotations.VisibleForTesting;
import com.google.gwt.appengine.channel.client.Channel;
import com.google.gwt.appengine.channel.client.ChannelError;
import com.google.gwt.appengine.channel.client.ChannelFactory;
import com.google.gwt.appengine.channel.client.SocketListener;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.inject.Inject;
import com.todomvc.client.util.UUID;
import com.todomvc.shared.command.Command;
import com.todomvc.shared.command.CommandSerialization;
import com.todomvc.shared.command.CommandSerialization.CommandDeserializer;
import com.todomvc.shared.service.CommandServiceAsync;

public class CommandController {

    private static Logger logger = Logger.getLogger(CommandController.class.getName());

    private final CommandServiceAsync commandService;
    private final ChannelFactory channelFactory;
    private final ClientCommandExecutor executor;
    private final CommandDeserializer deserializer;
    private final java.util.Random random;
    private final String clientId;
    private SocketListener socketListener;

    @Inject
    public CommandController(CommandServiceAsync commandService, ChannelFactory channelFactory,
            ClientCommandExecutor executor, CommandDeserializer deserializer) {
        this.commandService = checkNotNull(commandService);
        this.channelFactory = checkNotNull(channelFactory);
        this.executor = checkNotNull(executor);
        this.deserializer = checkNotNull(deserializer);
        random = new java.util.Random();
        clientId = createUniqueClientId();
    } 

    public void openCommandChannel(final String objectId) {
        commandService.openChannel(objectId, clientId, new AsyncCallback<String>() {

            @Override
            public void onFailure(Throwable caught) {
                logger.severe("cannot open command channel for object " + objectId);
            }

            @Override
            public void onSuccess(String token) {
                logger.info("opening channel for token: " + token);
                Channel channel = channelFactory.createChannel(token);
                socketListener = new CommandChannelListener();
                channel.open(socketListener);
            }

        });
    }

    @VisibleForTesting
    SocketListener getSocketListener() {
        return socketListener;
    }

    private class CommandChannelListener implements SocketListener {

        @Override
        public void onOpen() {
            logger.info("channel open");
        }

        @Override
        public void onMessage(String message) {
            try {
                Command<?> command = deserializer.read(message);
                logger.fine("received command: " + command);
                executor.execute(command);
            } catch (CommandSerialization.SerializationException e) {
                logger.severe("unable to de-serialize message: " + message);
            }
        }

        @Override
        public void onError(ChannelError error) {
            logger.severe("channel error: " + error.getCode() + " : " + error.getDescription());
        }

        @Override
        public void onClose() {
            logger.severe("channel closed: will not receive further commands from the server");
        }
    }

    public void executeCommand(Command<?> command) {
        if (command.isEager()) {
            executeCommandOnClient(command);
        }
        sendCommandToServer(command);
    }

    private void executeCommandOnClient(Command<?> command) {
        executor.execute(command);
    }

    private void sendCommandToServer(final Command<?> command) {
        commandService.executeCommand(command, clientId, new AsyncCallback<Command<?>>() {

            @Override
            public void onFailure(Throwable caught) {
                logger.severe("error sending command to server: " + caught.getLocalizedMessage());
            }

            @Override
            public void onSuccess(Command<?> updateCommand) {

                if (!command.isEager()) {
                    executor.execute(updateCommand);
                }
            }
        });
    }

    private String createUniqueClientId() {
        return UUID.uuid() + ":" + random.nextInt(Integer.MAX_VALUE) + ":" + System.currentTimeMillis();
    }
}