package org.litesoft.GWT.eventbus.client.rpc;

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.eventbus.client.nonpublic.*;
import org.litesoft.core.simpletypes.temporal.*;
import org.litesoft.core.util.*;
import org.litesoft.logger.nonpublic.*;

import com.google.gwt.user.client.*;
import com.google.gwt.user.client.rpc.*;

public class ClientSideRemotePeerService implements RemotePeerService
{
    private static final String COMMUNICATION_FAILURE = "TheServerCommunication";

    private static PeerSupportingEventBus sClientEventBus;
    private static int sClientIdNumber;
    private static ChannelServiceAsync sChannelServiceAsync;
    private static int sPollMillisecs;
    private static PollTimer sPollTimer;

    public ClientSideRemotePeerService( PeerSupportingEventBus pClientEventBus, //
                                        ChannelServiceAsync pChannelServiceAsync, //
                                        int pPollSecs )
    {
        sClientEventBus = pClientEventBus;
        sClientIdNumber = pClientEventBus.getClientIdNumber();
        sChannelServiceAsync = pChannelServiceAsync;
        sPollMillisecs = (pPollSecs < 1) ? 0 : pPollSecs * 1000;
        sPollTimer = (sPollMillisecs <= 0) ? NoPollTimer.INSTANCE : new RealPollTimer();
    }

    public String toString()
    {
        return "ClientSideRemotePeerService";
    }

    public boolean forwardTo( ChannelServicePackage pFromPeer )
    {
        return (pFromPeer == null) || pFromPeer.isEmpty() || //
               sendEm( ForwardToAsyncCallback.INSTANCE, pFromPeer );
    }

    public void stopUnrequestedMessages()
    {
        sPollTimer.cancel();
    }

    public RemotePeerService dispose()
    {
        return RemotePeerService.Null.INSTANCE;
    }

    private static int sMessageSequenceNumber = 0;

    private static boolean sendEm( AsyncCallback pAsyncCallback,
                                   ChannelServicePackage pChannelServicePackage )
    {
        boolean sent = false;
        sPollTimer.cancel();
        sMessageSequenceNumber++;
        try
        {
            trace( ">", pAsyncCallback, sMessageSequenceNumber );
            sChannelServiceAsync.propagate( sClientIdNumber, sMessageSequenceNumber, //
                                            sPollMillisecs, pChannelServicePackage, //
                                            pAsyncCallback );
            sent = true;
        }
        catch ( RuntimeException e )
        {
            sClientEventBus.handleUnexpectedProblem( COMMUNICATION_FAILURE, //
                                                     new Problem( e, "SendingToServer" ) );
        }
        sPollTimer.schedule();
        return sent;
    }

    private interface PollTimer
    {
        public void cancel();

        public void schedule();
    }

    private static class RealPollTimer extends Timer implements PollTimer
    {
        public void run()
        {
            if ( !AbstractClientMainAppEntryPoint.sWindowClosing )
            {
                sendEm( PollAsyncCallback.INSTANCE, null );
            }
        }

        public void schedule()
        {
            schedule( sPollMillisecs );
        }
    }

    private static class NoPollTimer implements PollTimer
    {
        public static final PollTimer INSTANCE = new NoPollTimer();

        public void cancel()
        {
        }

        public void schedule()
        {
        }
    }

    private static class AbstractAsyncCallback implements AsyncCallback
    {
        private String mTypeString;

        protected AbstractAsyncCallback( String pTypeString )
        {
            mTypeString = pTypeString;
        }

        public void onSuccess( Object pObject )
        {
            if ( !AbstractClientMainAppEntryPoint.sWindowClosing )
            {
                ChannelServiceResult result = (ChannelServiceResult) pObject;
                trace( "<", this, result.getMessageSequenceNumber() );
                if ( result.isForceClose() || result.isServerLost() )
                {
                    sPollTimer.cancel();
                    sPollTimer = NoPollTimer.INSTANCE;
                    if ( result.isForceClose() )
                    {
                        UtilsGwt.closeWindowNoConfirm( 5 );
                    }
                    else
                    {
                        sClientEventBus.problemFromRemotePeerService(
                                new NoServerEventBusEventPackage( "ChannelClient" ) );
                    }
                    return;
                }
                DeferredCommand.addCommand( new DeferredServerMessageHandler( this, result ) );
            }
        }

        private static class DeferredServerMessageHandler implements Command
        {
            private AsyncCallback mAsyncCallback;
            private ChannelServiceResult mResult;

            public DeferredServerMessageHandler( AsyncCallback pAsyncCallback, ChannelServiceResult pResult )
            {
                mAsyncCallback = pAsyncCallback;
                mResult = pResult;
            }

            public void execute()
            {
                trace( "#", mAsyncCallback, mResult.getMessageSequenceNumber() );
                ChannelServicePackage zPackage = mResult.getPackage();
                if ( !sClientEventBus.propagateFromRemotePeerService( zPackage ) )
                {
                    sClientEventBus = PeerSupportingEventBus.Null.INSTANCE;
                }
                trace( "$", mAsyncCallback, mResult.getMessageSequenceNumber() );
            }
        }

        public void onFailure( Throwable pThrowable )
        {
            if ( !AbstractClientMainAppEntryPoint.sWindowClosing )
            {
                sClientEventBus.handleUnexpectedProblem( COMMUNICATION_FAILURE, new Problem( pThrowable,
                                                                                             "Failed to contact the server",
                                                                                             toString() ) );
            }
        }

        public String toString()
        {
            return mTypeString;
        }
    }

    private static class PollAsyncCallback extends AbstractAsyncCallback
    {
        public static final AsyncCallback INSTANCE = new PollAsyncCallback();

        private PollAsyncCallback()
        {
            super( "POLL" );
        }
    }

    private static class ForwardToAsyncCallback extends AbstractAsyncCallback
    {
        public static final AsyncCallback INSTANCE = new ForwardToAsyncCallback();

        private ForwardToAsyncCallback()
        {
            super( "FRWD" );
        }
    }

    /**
     * @noinspection UnusedDeclaration
     */
    private static void trace( String pDirection, AsyncCallback pAsyncCallback, int pMessageSequenceNumber )
    {
        AbstractLogger zLogger = sClientEventBus.getLogger().trace();
        if ( zLogger.isEnabled() )
        {
            zLogger.log( "CC-" + pAsyncCallback + " " + +sClientIdNumber + "|" + pMessageSequenceNumber +
                         " " + pDirection + " " + new SimpleTimestamp( UtilsCommon.now() ) );
        }
    }
}