// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.GWT.forms.client.nonpublic;

import java.io.*;

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.eventbus.client.*;
import org.litesoft.GWT.forms.client.*;
import org.litesoft.GWT.forms.client.components.nonpublic.*;
import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.core.simpletypes.*;
import org.litesoft.ui.def.nonpublic.support.*;

public class RenderedFormHandlerImpl implements RenderedFormHandler,
                                                UberFormInstanceComponentHandler,
                                                AsyncFormServicePeerChannel.OperationalListener
{
    private UiFormHandler mUiFormHandler;
    private UiFormListener mListener;
    private String mRootType, mRootObjectKey = null;
    private AsyncFormServicePeerChannel mFormServicePeerChannel;
    private boolean mAnyAttributesChanged = false;
    private boolean mAnyAttributesInError = false;
    private boolean mMassUpdateChanged = true;
    private boolean mMassUpdateInError = true;
    private boolean mMassUpdateStaleChanged = true;
    private boolean mMassUpdateStaleInError = true;
    private AbstractFormContainer mFormContainer = null;
    private RFHMessageManager mManager;
    private BaseFormComponentHandlerImpl mBaseComponentHandler = null;

    public RenderedFormHandlerImpl( UiFormHandler pUiFormHandler, UiFormListener pListener, String pRootType,
                                    AsyncFormServicePeerChannel pFormServicePeerChannel )
    {
        mUiFormHandler = pUiFormHandler;
        mListener = pListener;
        mRootType = pRootType;
        mFormServicePeerChannel = pFormServicePeerChannel;
        mManager = new RFHMessageManager( mFormServicePeerChannel, LOGGER );
    }

    public void formRendered( AbstractFormContainer pFormContainer, Serializable pServicePeerXtra )
    {
        chkMethodOK( "formRendered", pServicePeerXtra );
        mFormContainer = pFormContainer;
        massUpdateComplete();
        mListener.formRendered( mUiFormHandler, pServicePeerXtra );
    }

    private boolean isDisposed()
    {
        return (mFormServicePeerChannel == null);
    }

    private void chkMethodOK( String pMethod, String pLogData, boolean pDisabled )
    {
        LOGGER.debug.log( pMethod, ":", pLogData, "-", pDisabled ? "Disabled" : "Enabled" );
        LLchkMethodOK( pMethod );
    }

    private void chkMethodOK( String pMethod, Object pLogData1, Object pLogData2 )
    {
        LOGGER.debug.log( pMethod, ":", pLogData1, "=", pLogData2 );
        LLchkMethodOK( pMethod );
    }

    private void chkMethodOK( String pMethod, Object pPlusLogData )
    {
        LOGGER.debug.log( pMethod, ":", pPlusLogData );
        LLchkMethodOK( pMethod );
    }

    private void chkMethodOK( String pMethod )
    {
        LOGGER.debug.log( pMethod );
        LLchkMethodOK( pMethod );
    }

    private void LLchkMethodOK( String pMethod )
    {
        if ( isDisposed() )
        {
            throw new IllegalStateException( pMethod + " unavailable.  This form has been disposed" );
        }
    }

    private void clearContainerErrorsAndWarnings()
    {
        LOGGER.debug.log( "clearContainerErrorsAndWarnings" );
        if ( mFormContainer != null )
        {
            mFormContainer.clearErrorOrWarning();
        }
    }

    // RenderedFormHandler:

    public void requestValues( String pRootTypeKeyOrNullForNew )
    {
        Integer zAsyncMessageNumber = mManager.getNextAsyncMessageNumber();
        chkMethodOK( "requestValues", zAsyncMessageNumber, pRootTypeKeyOrNullForNew );
        mRootObjectKey = pRootTypeKeyOrNullForNew;
        mManager.indicateSendForRequestValues( zAsyncMessageNumber );
        mFormServicePeerChannel.requestValues( zAsyncMessageNumber, pRootTypeKeyOrNullForNew );
    }

    public String getCurrentRootType()
    {
        return mRootType;
    }

    public String getCurrentRootTypeKey()
    {
        return mRootObjectKey;
    }

    public void dispose()
    {
        LOGGER.debug.log( "dispose" );
        if ( mFormServicePeerChannel != null )
        {
            mFormServicePeerChannel.dispose();
            mFormServicePeerChannel = null;
            mUiFormHandler = null;
            mListener = null;
            mFormContainer = null;
        }
        if ( mManager != null )
        {
            mManager.dispose();
            mManager = null;
        }
        if ( mBaseComponentHandler != null )
        {
            mBaseComponentHandler.dispose( this );
            mBaseComponentHandler = null;
        }
    }

    public boolean setFocus()
    {
        chkMethodOK( "setFocus" );
        return mBaseComponentHandler.setFocus();
    }

    public void setInputDisabled( FormDataRowKey pFormDataRowKey, String pAttributeName, boolean pDisabled )
    {
        chkMethodOK( "setInputDisabled", pAttributeName, pDisabled );
        mBaseComponentHandler.setInputDisabled( pFormDataRowKey, pAttributeName, pDisabled );
    }

    public void setActionDisabled( FormDataRowKey pFormDataRowKey, String pActionID, boolean pDisabled )
    {
        chkMethodOK( "setActionDisabled", pActionID, pDisabled );
        mBaseComponentHandler.setActionDisabled( pFormDataRowKey, pActionID, pDisabled );
    }

    public void clearErrorsAndWarnings()
    {
        chkMethodOK( "clearErrorsAndWarnings" );
        clearContainerErrorsAndWarnings();
    }

    public void sendAttibuteValue( FormDataRowKey pFormDataRowKey, Integer pAttributeUniqueID,
                                   String pAttributeReference, Serializable pCurrentValue )
    {
        chkMethodOK( "sendAttibuteValue", pAttributeReference, pCurrentValue );
        LLsendAttibuteValue( new ValueUpdatedFormData( pFormDataRowKey, //
                                                       pAttributeUniqueID, pAttributeReference, //
                                                       pCurrentValue ) );
    }

    public void sendActionRequest( FormDataRowKey pFormDataRowKey, String pActionID )
    {
        chkMethodOK( "sendActionRequest", pActionID );
        LLsendActionRequest( new ActionRequestFormData( pFormDataRowKey, pActionID, false, null ) );
    }

    public void captureUserState( ParamMap pParamMap )
    {
        chkMethodOK( "captureUserState" );
        mBaseComponentHandler.captureUserState( mRootType, pParamMap );
    }

    public void restoreUserState( ParamMap pParamMap )
    {
        chkMethodOK( "restoreUserState" );
        mBaseComponentHandler.restoreUserState( mRootType, pParamMap );
    }

    // UberFormInstanceComponentHandler

    // Component Handler Management

    public void setBaseComponentHandler( BaseFormComponentHandlerImpl pComponentHandler )
    {
        mBaseComponentHandler = pComponentHandler;
    }

    // Bridge to Rendered Form Button State Management
    public void componentErrorState( boolean pErrorState )
    {
        LOGGER.trace.log( "componentErrorState:", pErrorState );
        if ( !isDisposed() && (mAnyAttributesInError != pErrorState) )
        {
            if ( mMassUpdateInError )
            {
                mMassUpdateStaleInError = true;
            }
            else
            {
                updateAnyAttributesInError();
            }
        }
    }

    public void componentChangedState( boolean pChangedState )
    {
        LOGGER.trace.log( "componentChangedState:", pChangedState );
        if ( !isDisposed() && (mAnyAttributesChanged != pChangedState) )
        {
            if ( mMassUpdateChanged )
            {
                mMassUpdateStaleChanged = true;
            }
            else
            {
                updateAnyAttributesChanged();
            }
        }
    }

    // Bridge to FormServicePeer
    public void componentUpdatedValue( FormDataRowKey pFormDataRowKey, FormAttributeAdapter pAttributeAdapter,
                                       Serializable pCurrentValue )
    {
        LOGGER.debug.log( "componentUpdatedValue[", pFormDataRowKey, "]:", pAttributeAdapter, "=",
                          pCurrentValue );
        if ( !isDisposed() )
        {
            LLsendAttibuteValue( new ValueUpdatedFormData( pFormDataRowKey, //
                                                           pAttributeAdapter.getUniqueID(),
                                                           pAttributeAdapter.getAttributeReference(),
                                                           pCurrentValue ) );
        }
    }

    public void requestResourceKeyNameURLs( FormDataRowKey pFormDataRowKey,
                                            FormAttributeAdapter pAttributeAdapter,
                                            ResourceKeyNameURLsAvailableCallback pCallback )
    {
        LOGGER.debug.log( "requestResourceKeyNameURLs[", pFormDataRowKey, "]:", pAttributeAdapter );
        if ( !isDisposed() )
        {
            mFormServicePeerChannel.requestResources( pCallback, //
                                                      new AttributeResourceOptionsRequestData( pFormDataRowKey, //
                                                                                               pAttributeAdapter.getUniqueID(), //
                                                                                               pAttributeAdapter.getAttributeReference() ) );
        }
    }

    public void actionRequested( FormDataRowKey pFormDataRowKey, FormActionAdapter pActionAdapter,
                                 boolean pInputAction, FormDataRowKey pParentFormDataRow )
    {
        LOGGER.debug.log( "actionRequested[", pFormDataRowKey, "]:", pActionAdapter,
                          pInputAction ? ",Input" : "" );
        if ( !isDisposed() && pActionAdapter.isEnabled() )
        {
            getCollector();
            String actionID = pActionAdapter.getActionID();
            if ( mListener.formActionRequested( mUiFormHandler, actionID ) )
            {
                sendCollector( "actionRequested" );
            }
            else
            {
                clearContainerErrorsAndWarnings();
                LLsendActionRequest( new ActionRequestFormData( pFormDataRowKey, actionID, pInputAction,
                                                                pParentFormDataRow ) );
            }
        }
    }

    // OperationalListener:

    public void responseFromRequestValues( ServicePeerToFormData pFormData )
    {
        LOGGER.debug.log( "responseFromRequestValues:", pFormData );
        if ( !isDisposed() )
        {
            process( pFormData );
            mListener.formValuesApplied( mUiFormHandler, pFormData.getServicePeerXtra() );
            // an action may have been triggered programmatically on the server
            if ( pFormData.getSuccessfulTriggeringActionID() != null )
            {
                mListener.formActionSucceeded( mUiFormHandler, pFormData.getSuccessfulTriggeringActionID(),
                                               pFormData.getServicePeerXtra() );
            }
        }
    }

    public void unsolicitedData( ServicePeerToFormData pFormData )
    {
        LOGGER.debug.log( "unsolicitedData:", pFormData );
        if ( !isDisposed() )
        {
            process( pFormData );
            if ( pFormData.getSuccessfulTriggeringActionID() != null )
            {
                mListener.formActionSucceeded( mUiFormHandler, pFormData.getSuccessfulTriggeringActionID(),
                                               pFormData.getServicePeerXtra() );
            }
            if ( pFormData.isCloseRequested() )
            {
                mListener.formCloseRequested( mUiFormHandler, pFormData.getServicePeerXtra() );
            }
        }
    }

    // Impl:

    private void LLsendAttibuteValue( ValueUpdatedFormData pValueUpdatedFormData )
    {
        LOGGER.debug.log( "LLsendAttibuteValue:", pValueUpdatedFormData );
        boolean collecting = isCollecting();
        getCollector().add( pValueUpdatedFormData );
        if ( !collecting )
        {
            sendCollector( "LLsendAttibuteValue" );
        }
    }

    private void LLsendActionRequest( ActionRequestFormData pActionRequest )
    {
        LOGGER.debug.log( "LLsendActionRequest:", pActionRequest );
        getCollector().setActionRequest( pActionRequest );

        mBaseComponentHandler.publishAnyPendingAttributeChanges();

        sendCollector( "LLsendActionRequest" );
    }

    private void process( ServicePeerToFormData pFormData )
    {
        if ( pFormData == null )
        {
            System.out.println( "process null ServicePeerToFormData" );
            return;
        }
        receivedAsyncMessageNumber( pFormData.getAsyncMessageNumber() );
        if ( pFormData.getRootType() != null )
        {
            mRootType = pFormData.getRootType();
        }
        if ( pFormData.getRootObjectKey() != null )
        {
            mRootObjectKey = pFormData.getRootObjectKey();
        }
        setContainerErrorsAndWarnings( pFormData.getFormErrors(), pFormData.getFormWarnings() );
        if ( mBaseComponentHandler != null )
        {
            mBaseComponentHandler.apply( pFormData.getActionUpdates() );

            RelSubFormRowKeys[] zRelSubFormRowKeysList = pFormData.getRelSubFormRowKeysList();
            AttributeUpdateFormData[] zAttributeUpdates = pFormData.getAttributeUpdates();

            if ( Objects.isNotNullOrEmpty( zRelSubFormRowKeysList ) ||
                 Objects.isNotNullOrEmpty( zAttributeUpdates ) )
            {
                mMassUpdateChanged = mMassUpdateInError = true;
                boolean zUserInitiatedAddOrRemoveRow = //
                        "AddRow".equals( pFormData.getSuccessfulTriggeringActionID() ) || //
                        "RemoveRow".equals( pFormData.getSuccessfulTriggeringActionID() );
                mBaseComponentHandler.apply( zRelSubFormRowKeysList, pFormData.isFullUpdate(),
                                             zUserInitiatedAddOrRemoveRow );
                mBaseComponentHandler.apply( zAttributeUpdates );
                massUpdateComplete();
            }
        }

        FormPopupMessage[] popups = pFormData.getPopups();
        if( popups != null ) {
            for( int i = 0; i < popups.length; i ++ ) {
                // the title and message are used together as the key that the popup manager
                // will use to filter duplicate messages
                String combined = popups[i].getTitle() + popups[i].getMessage();
                if( popups[i].isAlert() ) {
                    AlertManager.alert( combined, popups[i].getTitle(), popups[i].getMessage() );
                } else {
                    InfoManager.info( combined, popups[i].getTitle(), popups[i].getMessage() );
                }
            }
        }
    }

    private void updateAnyAttributesChanged()
    {
        if ( mBaseComponentHandler != null )
        {
            boolean zAnyChanged = mBaseComponentHandler.anyUserInitiatedRowChange() ||
                                  mBaseComponentHandler.recalcAnyAttributes( FormAttributeAdapter.CHANGED );
            if ( zAnyChanged != mAnyAttributesChanged )
            {
                mBaseComponentHandler.updateInputState( mAnyAttributesChanged = zAnyChanged,
                                                        mAnyAttributesInError );
                mListener.formChangeState( mUiFormHandler, mAnyAttributesChanged );
            }
        }
    }

    private void updateAnyAttributesInError()
    {
        if ( mBaseComponentHandler != null )
        {
            boolean zAnyInError = mBaseComponentHandler.recalcAnyAttributes( FormAttributeAdapter.ERRORED );
            if ( zAnyInError != mAnyAttributesInError )
            {
                mBaseComponentHandler.updateInputState( mAnyAttributesChanged,
                                                        mAnyAttributesInError = zAnyInError );
                mListener.formErrorState( mUiFormHandler, mAnyAttributesInError );
            }
        }
    }

    private void massUpdateComplete()
    {
        mMassUpdateChanged = false;
        if ( mMassUpdateStaleChanged )
        {
            mMassUpdateStaleChanged = false;
            updateAnyAttributesChanged();
        }
        mMassUpdateInError = false;
        if ( mMassUpdateStaleInError )
        {
            mMassUpdateStaleInError = false;
            updateAnyAttributesInError();
        }
    }

    private void setContainerErrorsAndWarnings( String[] pFormErrors, String[] pFormWarnings )
    {
        if ( mFormContainer != null )
        {
            String formErrors = Strings.noEmpty( Strings.linesToString( pFormErrors ) );
            if ( formErrors != null )
            {
                mFormContainer.setError( formErrors );
            }
            else
            {
                String formWarnings = Strings.noEmpty( Strings.linesToString( pFormWarnings ) );
                if ( formWarnings != null )
                {
                    mFormContainer.setWarning( formWarnings );
                }
                else
                {
                    mFormContainer.clearErrorOrWarning();
                }
            }
        }
    }

    private FormToServicePeerDataCollector mCollector = null;

    private boolean isCollecting()
    {
        return (mCollector != null);
    }

    private FormToServicePeerDataCollector getCollector()
    {
        if ( mCollector == null )
        {
            mCollector = new FormToServicePeerDataCollector( mManager.getNextAsyncMessageNumber() );
        }
        return mCollector;
    }

    private void sendCollector( String pWho )
    {
        FormToServicePeerDataCollector zCollector = mCollector;
        mCollector = null;
        mManager.sendCollector( pWho, zCollector );
    }

    private void receivedAsyncMessageNumber( Integer pAsyncMessageNumber )
    {
        mManager.receivedAsyncMessageNumber( pAsyncMessageNumber );
    }
}