package org.litesoft.GWT.client.rpc;

import org.litesoft.GWT.client.view.*;
import org.litesoft.bo.views.*;
import org.litesoft.bo.views.caching.*;
import org.litesoft.bo.views.communication.*;
import org.litesoft.core.util.*;

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

public class GwtCScomm extends CScomm
{
    private final VoServiceAsync mAsyncService = GWT.create( VoService.class );

    private CacheManager mCacheManager;
    private SecurityIssueable mSecurityIssueable;

    public GwtCScomm( CacheManager pCacheManager, SecurityIssueable pSecurityIssueable, AsyncCallback<AppInitializationResult> pCallback )
    {
        mCacheManager = (pCacheManager != null) ? pCacheManager : CacheManager.NULL;
        mSecurityIssueable = pSecurityIssueable;

        ((ServiceDefTarget) mAsyncService).setServiceEntryPoint( extractEntryName( mAsyncService ) );

        mAsyncService.initialize( pCallback );
    }

    public void requestTemporalTriggerPoll()
    {
        processRequest( "requestTemporalTriggerPoll", null, null );
    }

    public void requestFunctionSimple( VOCSrequestFunctionSimple pFunctionSimple, SimpleDataProviderCallBack pCallBack )
    {
        processRequest( "requestFunctionSimple", pFunctionSimple, pCallBack );
    }

    public void requestFunctionFetchRow( CacheInvalidCallBack pCacheInvalidCallBack, CacheID pCacheID, VOCSrequestFunctionFetchRow pFunctionFetchRow, FetchRowDataProviderCallBack<? extends IViewObject> pCallBack )
    {
        processRequest( "requestFunctionFetchRow", pCacheInvalidCallBack, pCacheID, pFunctionFetchRow, pCallBack );
    }

    public void requestFunctionFetchRows( CacheInvalidCallBack pCacheInvalidCallBack, CacheID pCacheID, VOCSrequestFunctionFetchRows pFunctionFetchRows, FetchRowsDataProviderCallBack<? extends IViewObject> pCallBack )
    {
        processRequest( "requestFunctionFetchRows", pCacheInvalidCallBack, pCacheID, pFunctionFetchRows, pCallBack );
    }

    public void requestRowByObjectURL( CacheInvalidCallBack pCacheInvalidCallBack, CacheID pCacheID, VOCSrequestRowByObjectURL pRowByObjectURL, FetchRowDataProviderCallBack<? extends IViewObject> pCallBack )
    {
        processRequest( "requestRowByObjectURL", pCacheInvalidCallBack, pCacheID, pRowByObjectURL, pCallBack );
    }

    public void requestRowsByObjectURLs( CacheInvalidCallBack pCacheInvalidCallBack, CacheID pCacheID, VOCSrequestRowsByObjectURLs pRowsByObjectURLs, FetchRowsDataProviderCallBack<? extends IViewObject> pCallBack )
    {
        processRequest( "requestRowsByObjectURLs", pCacheInvalidCallBack, pCacheID, pRowsByObjectURLs, pCallBack );
    }

    public void requestRowsByFilters( CacheInvalidCallBack pCacheInvalidCallBack, CacheID pCacheID, VOCSrequestRowsByFilters pRowsByFilters, FetchRowsDataProviderCallBack<? extends IViewObject> pCallBack )
    {
        processRequest( "requestRowsByFilters", pCacheInvalidCallBack, pCacheID, pRowsByFilters, pCallBack );
    }

    @SuppressWarnings({"unchecked"})
    public void requestCommit( CacheInvalidCallBack pCacheInvalidCallBack, CacheID pCacheID, VOCSrequestCommit pVOCSrequestCommit, CommitCallBack<? extends IViewObject> pCallBack )
    {
        mAsyncService.process( handle( pCacheID, pCacheInvalidCallBack, pVOCSrequestCommit ), //
                               new AsyncCommitCallBack( "requestCommit", (pCallBack != null) ? pCallBack : CommitCallBack.NULL ) );
    }

    @SuppressWarnings({"unchecked"})
    private void processRequest( final String pWho, VOCSrequestFunctionSimple pFunctionSimple, SimpleDataProviderCallBack pCallBack )
    {
        mAsyncService.process( new CSpayload( pFunctionSimple, null ), //
                               new AsyncSimpleDataProviderCallBack( pWho, (pCallBack != null) ? pCallBack : SimpleDataProviderCallBack.NULL ) );
    }

    @SuppressWarnings({"unchecked"})
    private void processRequest( final String pWho, CacheInvalidCallBack pCacheInvalidCallBack, CacheID pCacheID, CSrequest pCSrequest, FetchRowDataProviderCallBack<? extends IViewObject> pCallBack )
    {
        mAsyncService.process( handle( pCacheID, pCacheInvalidCallBack, pCSrequest ), //
                               new AsyncFetchRowDataProviderCallBack( pWho, (pCallBack != null) ? pCallBack : FetchRowDataProviderCallBack.NULL ) );
    }

    @SuppressWarnings({"unchecked"})
    private void processRequest( final String pWho, CacheInvalidCallBack pCacheInvalidCallBack, CacheID pCacheID, CSrequest pCSrequest, FetchRowsDataProviderCallBack<? extends IViewObject> pCallBack )
    {
        mAsyncService.process( handle( pCacheID, pCacheInvalidCallBack, pCSrequest ), //
                               new AsyncFetchRowsDataProviderCallBack( pWho, (pCallBack != null) ? pCallBack : FetchRowsDataProviderCallBack.NULL ) );
    }

    private CSpayload handle( CacheID pCacheID, CacheInvalidCallBack pCacheInvalidCallBack, CSrequest pCSrequest )
    {
        return new CSpayload( pCSrequest, mCacheManager.add( pCacheID, pCacheInvalidCallBack ) ? pCacheID : null );
    }

    private static final String ASYNC_NAME_PROXY_TAIL = "_Proxy";

    protected String extractEntryName( Object pAsyncInstance )
    {
        String zTypeName = pAsyncInstance.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() );
    }

    private String makeMessage( Throwable pThrowable )
    {
        return UtilsCommon.justClassNameOf( pThrowable ) + " " + UtilsCommon.deNull( pThrowable.getMessage() ).trim();
    }

    private abstract class OurAsyncCallback implements AsyncCallback<SCpayload>
    {
        private String mWho;
        private ErrorCallBack mErrorCallBack;

        protected OurAsyncCallback( String pWho, ErrorCallBack pErrorCallBack )
        {
            mWho = pWho;
            mErrorCallBack = pErrorCallBack;
        }

        public void onFailure( Throwable caught )
        {
            TemporalTriggerManager.get().response();
            mErrorCallBack.error( mWho + ": " + makeMessage( caught ) );
        }

        public void onSuccess( SCpayload result )
        {
            mCacheManager.invalidate( result.getInvalidCacheIDs() );
            TemporalTriggerManager zManager = TemporalTriggerManager.get();
            zManager.response();
            TemporalTrigger[] zTriggers = result.getTemporalTriggers();
            if ( (zTriggers != null) && (zTriggers.length != 0) )
            {
                for ( TemporalTrigger zTrigger : zTriggers )
                {
                    zManager.dispatch( zTrigger );
                }
            }
            SCresponse zSCresponse = result.getSCresponse();
            if ( zSCresponse instanceof SecuritySCresponse )
            {
                mSecurityIssueable.handleSecurityIssue( ((SecuritySCresponse) zSCresponse).isSessionExpired() ? "Session Expired" : "General Security Problem" );
                return;
            }
            //noinspection ConstantConditions
            call( (VOSCresponse) zSCresponse );
        }

        abstract protected void call( VOSCresponse pResponse );
    }

    private class AsyncSimpleDataProviderCallBack extends OurAsyncCallback
    {
        private SimpleDataProviderCallBack mCallBack;

        private AsyncSimpleDataProviderCallBack( String pWho, SimpleDataProviderCallBack pCallBack )
        {
            super( pWho, pCallBack );
            mCallBack = pCallBack;
        }

        protected void call( VOSCresponse pResponse )
        {
            pResponse.call( mCallBack );
        }
    }

    private class AsyncCommitCallBack extends OurAsyncCallback
    {
        private CommitCallBack<? extends IViewObject> mCallBack;

        private AsyncCommitCallBack( String pWho, CommitCallBack<? extends IViewObject> pCallBack )
        {
            super( pWho, pCallBack );
            mCallBack = pCallBack;
        }

        protected void call( VOSCresponse pResponse )
        {
            pResponse.call( mCallBack );
        }
    }

    private class AsyncFetchRowDataProviderCallBack extends OurAsyncCallback
    {
        private FetchRowDataProviderCallBack<? extends IViewObject> mCallBack;

        private AsyncFetchRowDataProviderCallBack( String pWho, FetchRowDataProviderCallBack<? extends IViewObject> pCallBack )
        {
            super( pWho, pCallBack );
            mCallBack = pCallBack;
        }

        protected void call( VOSCresponse pResponse )
        {
            pResponse.call( mCallBack );
        }
    }

    private class AsyncFetchRowsDataProviderCallBack extends OurAsyncCallback
    {
        private FetchRowsDataProviderCallBack<? extends IViewObject> mCallBack;

        private AsyncFetchRowsDataProviderCallBack( String pWho, FetchRowsDataProviderCallBack<? extends IViewObject> pCallBack )
        {
            super( pWho, pCallBack );
            mCallBack = pCallBack;
        }

        protected void call( VOSCresponse pResponse )
        {
            pResponse.call( mCallBack );
        }
    }
}