package org.litesoft.GWT.forms.server.support.nonpublic;

import java.util.concurrent.atomic.*;

import org.litesoft.GWT.eventbus.client.*;
import org.litesoft.GWT.eventbus.server.*;
import org.litesoft.GWT.forms.client.rpc.*;
import org.litesoft.GWT.forms.server.*;
import org.litesoft.*;
import org.litesoft.core.simpletypes.*;
import org.litesoft.rpcpassable.*;
import org.litesoft.ui.def.nonpublic.support.*;
import org.litesoft.ui.support.*;
import org.litesoft.ui_1_5.*;

public class FormServicePeerPushInterfaceBusAdapter implements FormComponentBusConstants,
                                                               EventPackageSubscriber,
                                                               FormServicePeerEventBusPushInterface,
                                                               ServerEventBusDisposeListener
{
    private final AtomicReference<EventBus> mEventBus = new AtomicReference<EventBus>();
    private final AtomicReference<FormServicePeer> mServicePeer = new AtomicReference<FormServicePeer>();
    private final String mFormID;
    private final String mOurID;

    public FormServicePeerPushInterfaceBusAdapter( EventBus pEventBus, FormServicePeer pServicePeer,
                                                   ISystemUserResolver pSystemUserResolver,
                                                   Long pUniqueFormServicePeerID,
                                                   FormCreationRequestPackage pPackage,
                                                   ExternalizationInterface pExternalization,
                                                   FormAccessControlFactory pFACfactory )
    {
        mEventBus.set( pEventBus );
        mServicePeer.set( pServicePeer );
        mFormID = pPackage.getSourceName();
        mOurID = "FSP" + pEventBus.getNextUniqueID();
        FormUsage usage = pPackage.getFormUsage();
        RPCpassable initializationPayload = pPackage.getInitializationPayload();
        ServicePeerToFormCreationData zFCD;
        try
        {
            ISystemUser zSystemUser = getSystemUserForFormInteractionData( pEventBus );
            zFCD = pServicePeer.initializeAndCreateFormMetaData( this, pSystemUserResolver,
                                                                 pUniqueFormServicePeerID, zSystemUser, usage,
                                                                 initializationPayload, pExternalization,
                                                                 pFACfactory.getBaseFAC( pEventBus ) );
        }
        catch ( RuntimeException e )
        {
            FormServicePeer.LOGGER.error.log( e );
            pEventBus.publishIfNotDisposed( new FormCreationResponsePackage( pPackage.getTargetName(), //
                                                                             mFormID, //
                                                                             e.getMessage() ) );
            return;
        }
        if ( pEventBus instanceof ServerEventBus )
        {
            ((ServerEventBus) pEventBus).addListener( this );
        }
        pEventBus.subscribeAndPublishIfNotDisposed( this, new FormCreationResponsePackage( mOurID, mFormID,
                                                                                           zFCD ) );
    }

    private ISystemUser getSystemUserForFormInteractionData( EventBus pEventBus )
    {
        return (pEventBus instanceof AuthenticatedServerEventBus) ? //
               ((AuthenticatedServerEventBus) pEventBus).getLoggedInUser() : //
               null;
    }

    public EventBus getEventBus()
    {
        return mEventBus.get();
    }

    public String getFormID()
    {
        return mFormID;
    }

    public String getOurID()
    {
        return mOurID;
    }

    private void releaseResources()
    {
        EventBus zEventBus = mEventBus.getAndSet( null );
        if ( zEventBus != null )
        {
            zEventBus.unsubscribe( this );
            if ( zEventBus instanceof ServerEventBus )
            {
                ((ServerEventBus) zEventBus).removeListener( this );
            }
        }
        FormServicePeer zServicePeer = mServicePeer.getAndSet( null );
        if ( zServicePeer != null )
        {
            zServicePeer.dispose();
        }
    }

    protected void finalize()
            throws Throwable
    {
        releaseResources();
        super.finalize();
    }

    private void sendToForm( EventPackage pPackage )
    {
        EventBus zEventBus = mEventBus.get();
        if ( zEventBus != null )
        {
            zEventBus.publishIfNotDisposed( pPackage );
        }
    }

    // EventPackageSubscriber:

    public String subscribeWith()
    {
        return mOurID;
    }

    public void packageReceivedVia( EventPackage pEventPackage, EventBus pEventBus )
    {
        FormServicePeer zServicePeer = mServicePeer.get();
        if ( zServicePeer != null )
        {
            try
            {
                if ( pEventPackage instanceof FormToServicePeerPackage )
                {
                    FormToServicePeerPackage zPackage = (FormToServicePeerPackage) pEventPackage;
                    FormToServicePeerData zData = zPackage.getToServicePeerData();
                    try
                    {
                        sendUnsolicitedData( zServicePeer.formEvent( zData ) );
                    }
                    catch ( RuntimeException e )
                    {
                        sendUnsolicitedData( zData.getAsyncMessageNumber(),
                                             "Error processing 'formEvent': " + e.getMessage() );
                        throw e;
                    }
                }
                else if ( pEventPackage instanceof FormValuesRequestPackage )
                {
                    FormValuesRequestPackage zPackage = (FormValuesRequestPackage) pEventPackage;
                    Integer zAsyncMessageNumber = zPackage.getAsyncMessageNumber();
                    try
                    {
                        sendResponseFromRequestValues( zServicePeer.setRootObjectTo( zAsyncMessageNumber, //
                                                                                     zPackage.getKey() ) );
                    }
                    catch ( RuntimeException e )
                    {
                        sendResponseFromRequestValues( zAsyncMessageNumber,
                                                       "Error processing 'setRootObjectTo': " +
                                                       e.getMessage() );
                        throw e;
                    }
                }
                else if ( pEventPackage instanceof FormResourceRequestPackage )
                {
                    FormResourceRequestPackage zPackage = (FormResourceRequestPackage) pEventPackage;
                    AttributeResourceOptionsRequestData zRequest = zPackage.getRequest();
                    try
                    {
                        AttributeResourceOptionsResponseData zResponse =
                                zServicePeer.getResourceOptions( zRequest );
                        if ( zResponse == null )
                        {
                            zResponse = new AttributeResourceOptionsResponseData(
                                    ResourceOptionsErrorType.ErrorNullReturned );
                        }
                        sendResponseFromResourceRequest( zRequest, zResponse );
                    }
                    catch ( RuntimeException e )
                    {
                        sendResponseFromResourceRequest( zRequest, //
                                                         new AttributeResourceOptionsResponseData(
                                                                 e.getMessage() ) );
                        throw e;
                    }
                }
                else if ( pEventPackage instanceof FormDisposePackage )
                {
                    releaseResources();
                }
            }
            catch ( RuntimeException e )
            {
                FormServicePeer.LOGGER.error.log( e );
            }
        }
    }

    // PushInterface:

    public void releasedBy( FormServicePeer pFormServicePeer )
    {
        releaseResources();
    }

    public void sendUnsolicitedData( ServicePeerToFormData pServicePeerToFormData )
    {
        if ( pServicePeerToFormData != null )
        {
            sendToForm( ServicePeerToFormPackage.unsolicitedData( mOurID, mFormID, pServicePeerToFormData ) );
        }
    }

    private void sendResponseFromResourceRequest( AttributeResourceOptionsRequestData pRequest,
                                                  AttributeResourceOptionsResponseData pResource )
    {
        sendToForm( new FormResourceResponsePackage( mOurID, mFormID, pRequest, pResource ) );
    }

    private void sendResponseFromRequestValues( ServicePeerToFormData pServicePeerToFormData )
    {
        if ( pServicePeerToFormData != null )
        {
            sendToForm( ServicePeerToFormPackage.responseFromRequestValues( mOurID, mFormID,
                                                                            pServicePeerToFormData ) );
        }
    }

    private void sendResponseFromRequestValues( Integer pAsyncMessageNumber, String pErrorText )
    {
        sendResponseFromRequestValues( createErrorResponse( pAsyncMessageNumber, pErrorText ) );
    }

    private void sendUnsolicitedData( Integer pAsyncMessageNumber, String pErrorText )
    {
        sendUnsolicitedData( createErrorResponse( pAsyncMessageNumber, pErrorText ) );
    }

    private ServicePeerToFormData createErrorResponse( Integer pAsyncMessageNumber, String pErrorText )
    {
        ServicePeerToFormDataCollector collector = new ServicePeerToFormDataCollector();
        collector.setAsyncMessageNumber( pAsyncMessageNumber );
        collector.addError( pErrorText );
        return new ServicePeerToFormData( collector );
    }

    public void init( IServerEventBus pServerEventBus )
    {
    }

    public void disposing( IServerEventBus pServerEventBus )
    {
        releaseResources();
    }
}