package org.litesoft.GWT.eventbus.client;

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.logging.*;
import org.litesoft.GWT.eventbus.client.eventpackages.*;
import org.litesoft.GWT.eventbus.client.nonpublic.*;
import org.litesoft.GWT.eventbus.client.rpc.*;
import org.litesoft.core.simpletypes.temporal.*;
import org.litesoft.logger.*;
import org.litesoft.loggerconfig.*;

import com.google.gwt.user.client.*;
import com.google.gwt.user.client.rpc.*;
import com.google.gwt.user.client.ui.*;
import com.google.gwt.event.logical.shared.*;

public abstract class AbstractClientEventBusApp extends AbstractClientMainAppEntryPoint
{
    private static String sVersion = "N/A";
    private static ClientEventBus sEventBus = null;
    private static int sClientIdNumber;
    protected static String sEncodedClientId = null;

    private WindowNameClientIdCodec mWindowNameClientIdCodec;
    protected DecendantManager mDecendantManager;

    private EventBusRemoteServiceAsync mRemoteServiceAsync = null;

    public static String getVersion()
    {
        return sVersion;
    }

    public static ClientEventBus getEventBus()
    {
        return sEventBus;
    }

    public static void initializeEventBus( String pEncodedClientId )
    {
        System.out.println( "initializeEventBus: " + pEncodedClientId );
        // todo: ...
    }

    public static void pollEventBus()
    {
        ClientEventBus zBus = getEventBus();
        if ( zBus != null )
        {
            zBus.pollNow();
        }
    }

    public static void streamClosed()
    {
        System.out.println( "streamClosed" );
        Window.alert( "streamClosed" );
        // todo: ...
    }

    public static int getClientIdNumber()
    {
        ClientEventBus zBus = getEventBus();
        return (zBus != null) ? zBus.getClientIdNumber() : 0;
    }

    protected AbstractClientEventBusApp( AppNames pAppNames )
    {
        super( pAppNames );
        mWindowNameClientIdCodec = new WindowNameClientIdCodec( pAppNames );
        mDecendantManager = new DecendantManager( mWindowNameClientIdCodec );
    }

    @Override
    public void onAppLoad()
    {
        super.onAppLoad();

        mRemoteServiceAsync = createRemoteServiceProxy();

        String zEncodedClientId = mWindowNameClientIdCodec.extractEncodedClientId( WindowName.get() );

        initializeEventBusConnection( zEncodedClientId );
    }

    @Override
    public void onClose( CloseEvent<Window> pEvent )
    {
        super.onClose( pEvent );
        sEventBus.dispose( "WindowClosed" );
        if ( (mRemoteServiceAsync != null) && (sEncodedClientId != null) )
        {
            try
            {
                mRemoteServiceAsync.clientDead( sClientIdNumber, new TossingAsyncCallback() );
            }
            catch ( RuntimeException e )
            {
                System.err.println( "ClientEventBusApp.WindowClosed" );
                e.printStackTrace();
            }
        }
    }

    @Override
    public void nativeCodeInjection()
    {
        super.nativeCodeInjection();

        NativeClientEventBusSupport.export();
    }

    @Override
    public void nativeCodeDispose()
    {
        super.nativeCodeDispose();

        NativeClientEventBusSupport.dispose();
    }

    protected void initializeLoggerFactory()
    {
        //noinspection NonJREEmulationClassesInClientCode
        LoggerFactory.init( new ConfigurationLoggerLevel(), BrowserAsLogSyncFactory.INSTANCE );
    }

    protected void initializeEventBusConnection( String pEncodedClientId )
    {
        ((ServiceDefTarget) mRemoteServiceAsync).setServiceEntryPoint( extractEntryName() );

        mRemoteServiceAsync.initialize( pEncodedClientId, new AppInitializationCallback() );
    }

    private static final String ASYNC_NAME_PROXY_TAIL = "_Proxy";

    private String extractEntryName()
    {
        String zTypeName = mRemoteServiceAsync.getClass().getName();

        if ( !zTypeName.endsWith( ASYNC_NAME_PROXY_TAIL ) )
        {
            throw new IllegalStateException( zTypeName + " did not end with '" + ASYNC_NAME_PROXY_TAIL + "'" );
        }
        int lastDot = zTypeName.lastIndexOf( '.' );
        if ( lastDot == -1 )
        {
            throw new IllegalStateException( zTypeName + " may not live in the default package" );
        }
        return zTypeName.substring( lastDot + 1, zTypeName.length() - ASYNC_NAME_PROXY_TAIL.length() );
    }

    protected int getPollSecs()
    {
        return 5;
    }

    abstract protected EventBusRemoteServiceAsync createRemoteServiceProxy();

    /**
     * @noinspection NonJREEmulationClassesInClientCode
     */
    protected Logger createClientEventBusLogger( int pClientIdNumber )
    {
        return null;
    }

    abstract protected void appReady( AuthenticationData pAuthenticationData );

    protected void sessionLost()
    {
        UtilsGwt.closeWindowNoConfirm( getSessionLostWindowAlertText() );
    }

    protected String getSessionLostWindowAlertText()
    {
        return "Your session with the server has been lost.\nYou will need to reconnect.\nThe application window will now attempt to close.";
    }

    protected void addEventListenersForNewClient( EventSubscriptionCollector pCollector )
    {
    }

    private void initialSubscriptions( EventBus pEventBus )
    {
        EventSubscriptionCollector collector = new EventSubscriptionCollector();
        addEventListenersForNewClient( collector );
        collector.subscribe( new OpenNewClientPackageListener() );
        collector.subscribe( new CloseClientPackageListener() );
        collector.subscribe( new NoServerEventBusPackageListener() );
        collector.subscribe( new RelatedClientToFrontPackageListener() );
        mDecendantManager.addEventListenersForNewClient( collector );
        pEventBus.subscribe( collector );
    }

    protected void finalPrep( ChannelEventPackage pInitialChannelEvent, AuthenticationData pAuthenticationData )
    {
        System.err.println( new UtilDateAdaptor() + " | Client AppReady" );
        appReady( pAuthenticationData );
    }

    protected void closeClientRequested()
    {
        UtilsGwt.closeWindowNoConfirm( 1 );
    }

    private class AppInitializationCallback implements AsyncCallback<AppInitializationResult>
    {
        public void onFailure( Throwable pThrowable )
        {
            String message;

            if ( pThrowable instanceof InvocationException )
            {
                // see javadoc for InvocationException
                message = "A connection could not be established with the server";
            }
            else if ( pThrowable instanceof IncompatibleRemoteServiceException )
            {
                /*
                 * This _should_ not happen to users, so long as the .nocache 
                 * file isn't cached by the client. 
                 */
                message =
                        "Client and server versions are incompatible. Try ctrl-clicking " + "or shift-clicking the browser refresh button, or clearing your " +
                        "browser's cache in 'Internet Options' / your browser's preferences. ";
            }
            else
            {
                // probably an application-specific execption on the server
                message = "An application error occured on the server";
            }

            reportFailure( pThrowable, "onFailure()", message );
        }

        public void onSuccess( AppInitializationResult result )
        {
            System.err.println( new UtilDateAdaptor() + " | Client AppInitialization" );

            if ( result == null )
            {
                UtilsGwt.closeWindowNoConfirm( 5 );
                return;
            }

            ClientEventBus ceb = null;
            try
            {
                new ClientConfiguration( result.getClientConfig() ); // This line must preceed the next
                initializeLoggerFactory(); // ......................... This line must follow the previous

                AlertManager.setVersion( sVersion = result.getApplicationVersion() );

                sClientIdNumber = result.getClientIdNumber();

                sEncodedClientId = result.getEncodedClientId();
                WindowName.set( mWindowNameClientIdCodec.createWindowName( sEncodedClientId ) );

                ceb = new ClientEventBus( sClientIdNumber );
                ceb.initialize( mRemoteServiceAsync, getPollSecs(), createClientEventBusLogger( sClientIdNumber ) );

                if ( ceb.getLogger().debug.isEnabled() )
                {
                    UtilsGwt.addWindowNameToWindowTitle();
                }

                ChannelServicePackage zPackage = result.getChannelServicePackage();
                if ( zPackage != null )
                {
                    ceb.propagateFromRemotePeerService( zPackage );
                }
                initialSubscriptions( ceb );
                sEventBus = ceb;
                finalPrep( result.getInitialChannelEvent(), result.getAuthenticationData() );
                ceb.release();
            }
            catch ( RedirectClientException e )
            {
                if ( ceb != null )
                {
                    ceb.dispose( "Redirect" );
                }
                UtilsGwt.redirect( e.getRedirectTo() );
            }
            catch ( RuntimeException e )
            {
                reportFailure( e, "onSuccess()", null );
            }
        }

        private void reportFailure( Throwable pThrowable, String method, String message )
        {
            pThrowable.printStackTrace(); // prints the trace in the GWT hosted shell
            String html = "<h1>Application Initialization Failed</h1>" + "<p>" + message + "</p>" + "<p>at " + getClass().getName() + "." + method + "</p>" +
                          "<p>Exception: </p>" + "<p><pre>" + pThrowable + "</pre></p>";
            DOM.setInnerHTML( RootPanel.getBodyElement(), html );
        }
    }

    private class NoServerEventBusPackageListener implements EventPackageSubscriber
    {
        public String subscribeWith()
        {
            return NoServerEventBusEventPackage.SubscribeWith;
        }

        public void packageReceivedVia( EventPackage pEventPackage, EventBus pEventBus )
        {
            sessionLost();
        }
    }

    private class RelatedClientToFrontPackageListener implements EventPackageSubscriber
    {
        public String subscribeWith()
        {
            return RelatedClientToFrontEventPackage.SubscribeWith;
        }

        public void packageReceivedVia( EventPackage pEventPackage, EventBus pEventBus )
        {
            int id = ((RelatedClientToFrontEventPackage) pEventPackage).getClientId();
            mDecendantManager.decendantToFront( id );
        }
    }

    private class CloseClientPackageListener implements EventPackageSubscriber
    {
        public String subscribeWith()
        {
            return CloseClientEventPackage.SubscribeWith;
        }

        public void packageReceivedVia( EventPackage pEventPackage, EventBus pEventBus )
        {
            closeClientRequested();
        }
    }

    private class OpenNewClientPackageListener implements EventPackageSubscriber
    {
        public String subscribeWith()
        {
            return OpenNewClientEventPackage.SubscribeWith;
        }

        public void packageReceivedVia( EventPackage pEventPackage, EventBus pEventBus )
        {
            OpenNewClientEventPackage onc = (OpenNewClientEventPackage) pEventPackage;
            String url = UtilsGwt.getURL();
            String windowName = mWindowNameClientIdCodec.createWindowName( onc.getNewEncodedClientId() );

            openChildWindow( windowName, url );
        }
    }

    protected void openChildWindow( String pWinName, String pUrl )
    {
        UtilsGwt.windowOpenChromeless( pUrl, pWinName );
        // Other Features:
        //      "hotkeys=0" + // Netscape!, FireFox?, IE?
        //      "screenX=nnnn,screenY=nnnn," + // Netscape!, FireFox?,
        //          IE?
        //      width=100,height=100," +
    }

    private static class TossingAsyncCallback implements AsyncCallback<Object>
    {
        public void onFailure( Throwable caught )
        {
            if ( !sWindowClosing && (caught != null) )
            {
                System.err.println( "ClientEventBusApp.TossingAsyncCallback.onFailure" );
                caught.printStackTrace();
            }
        }

        public void onSuccess( Object result )
        {
        }
    }
}