// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.GWT.forms.server.support.nonpublic;

import org.litesoft.GWT.forms.server.*;
import org.litesoft.GWT.forms.server.support.*;
import org.litesoft.*;
import org.litesoft.changemanagement.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.exceptions.*;
import org.litesoft.core.delayed.*;
import org.litesoft.core.simpletypes.*;
import org.litesoft.delayed.*;
import org.litesoft.ui.def.*;
import org.litesoft.ui.def.nonpublic.support.*;
import org.litesoft.ui.support.*;
import org.litesoft.ui_1_5.*;

import java.io.*;
import java.util.*;

public abstract class AbstractFormServicePeer implements FormServicePeer,
                                                         ServerStateChangedListener,
                                                         FSPTypeHelperBackDoor {
    public static final String ERR_COMMIT_FAILED = "CommitFailed";
    public static final String ERR_COMMIT_OUT_OF_DATE_DATA = "OutOfDateDataCausedCommitFailure";

    private final MillisecTimeSource mMillisecTimeSource = MillisecTimeSource.INSTANCE;

    protected volatile PushInterface mPushInterface = null;
    protected ISystemUserResolver mSystemUserResolver = ISystemUserResolver.NULL;
    protected Serializable mInitializationPayload;
    protected volatile boolean mIsNewRootObject;

    private volatile boolean mDisposed = false;
    private final TypeHelperManager mTypeHelperManager = new TypeHelperManager();
    private final InstanceHelperManager mInstanceHelperManager = new InstanceHelperManager();

    private final FormInteractionHelper mInteractionHelper = new FormInteractionHelper();

    private ServicePeerToFormDataProxy mCollectorProxy = new ServicePeerToFormDataProxy();

    public ServicePeerToFormDataProxy getCollectorProxy() {
        return mCollectorProxy;
    }

    protected void rootObjectCommited() {
        FormInteractionStructure zFIS = mInteractionHelper.rootObjectCommited();
        if ( zFIS != null ) {
            publish( zFIS, ServerStateChange.Action.UPDATED );
        }
    }

    private void handle( FormInteractionChange pChange ) {
        if ( pChange != null ) {
            FormInteractionStructure zOldData = pChange.getOldData();
            FormInteractionStructure zNewData = pChange.getNewData();

            if ( zOldData.isPublishable() ) {
                // todo: Need Instance of: ChangeListenerManager.removeListener( this );
                publish( zOldData, ServerStateChange.Action.DELETED );
            }
            if ( zNewData.isPublishable() ) {
                // todo: Need Instance of: ChangeListenerManager.addListener( this, "FSP:" + zNewData.getRootType(), (Serializable) zNewData.getRootObjectKey() );
                publish( zNewData, ServerStateChange.Action.CREATED );
            }

            getCollectorProxy().update( zOldData, zNewData );
        }
    }

    protected void setOurData( FormInteractionStructure pNewData ) {
        handle( mInteractionHelper.setOurData( pNewData ) );
    }

    private void publish( FormInteractionStructure pData, ServerStateChange.Action pAction ) {
        ServerStateChange zChange = new ServerStateChange( pAction, "FSP:" + pData.getRootType(), pData.getRootObjectKey(), null, pData );
        Long zSourceUniqueID = pData.getUniqueFormServicePeerID();
        ServerStateChangeSet zChangeSet = new ServerStateChangeSet( zSourceUniqueID, null, zChange );
        // todo: Need Instance of: ChangeListenerManager.notifyAllListeners( zChangeSet );
    }

    public void serverStateChanged( ServerStateChangeSet pServerStateChangeSet ) {
        // event order?
        FormInteractionIntersection zFII = mInteractionHelper.createFormInteractionIntersection( pServerStateChangeSet );
        if ( zFII.getData().isPublishable() ) {
            if ( zFII.isNewOthers() ) {
                // New Others may not know about us, so we publish (again)
                publish( zFII.getData(), ServerStateChange.Action.CREATED );
            }
            if ( zFII.isUpdateOthers() || zFII.isNewOthers() || zFII.isDelOthers() ) {
                getCollectorProxy().forceReturn();
                mRunnable.runOnOrAfter( 2000 ); // 2 secs
            }
        }
    }

    private MyTimedRunnable mRunnable = new MyTimedRunnable();

    private class MyTimedRunnable implements TimedRunnable {
        private Long mSendWhen = null;

        public synchronized void runOnOrAfter( int pSendIn ) {
            boolean zNotLaunched = (mSendWhen == null);

            long zSendWhen = mMillisecTimeSource.now() + pSendIn;

            mSendWhen = zSendWhen;

            if ( zNotLaunched ) {
                TimedRunnableManager.INSTANCE.runOnOrAfter( this, zSendWhen );
            }
        }

        public Again runOnce() {
            synchronized ( this ) {
                if ( mSendWhen == null ) {
                    return null;
                }
                if ( mMillisecTimeSource.now() < mSendWhen ) {
                    return new RunAgainOnOrAfter( mSendWhen );
                }
                mSendWhen = null;
            }
            sendUnsolicitedData();
            return null;
        }
    }

    protected Long getUniqueFormID() {
        return mInteractionHelper.getOurUniqueFormServicePeerID();
    }

    public SerializableSystemUserRef getSystemUserRef() {
        return mInteractionHelper.getOurSystemUserRef();
    }

    protected String getRootType() {
        return mInteractionHelper.getOurRootType();
    }

    protected String getRootObjectKey() {
        return mInteractionHelper.getOurRootObjectKey();
    }

    protected void setRootObjectKey( String pRootObjectKey ) {
        handle( mInteractionHelper.setRootObjectKey( pRootObjectKey ) );
    }

    public TypeHelper getRootTypeHelper() {
        return mTypeHelperManager.getRootTypeHelper();
    }

    public InstanceHelper getRootInstanceHelper() {
        return mInstanceHelperManager.getRootInstanceHelper();
    }

    protected void setFullUpdate() {
        getCollectorProxy().setFullUpdate();
    }

    protected void setCloseRequested() {
        getCollectorProxy().setCloseRequested();
    }

    protected void addWarning( String pWarningID, Object... pParameters ) {
        getCollectorProxy().addWarning( rootTypeResolveError( pWarningID, pParameters ) );
    }

    protected void addError( String pErrorID, Object... pParameters ) {
        getCollectorProxy().addError( rootTypeResolveError( pErrorID, pParameters ) );
    }

    protected boolean hasErrors() {
        return getCollectorProxy().hasErrors();
    }

    protected void setSuccessfulTriggeringActionIDIfNotSet( String pSuccessfulTriggeringActionID ) {
        getCollectorProxy().setSuccessfulTriggeringActionIDIfNotSet( pSuccessfulTriggeringActionID );
    }

    private String rootTypeResolveError( String pErrorID, Object... pParameters ) {
        TypeHelper zTypeHelper = getRootTypeHelper();
        String resolved = (zTypeHelper != null) ? zTypeHelper.resolveError( pErrorID ) : pErrorID;
        return ExternalizationInterface.Helper.injectParameters( resolved, pParameters );
    }

    private ExternalizationInterface getRootTypeExternalizationInterface() {
        TypeHelper zTypeHelper = getRootTypeHelper();
        return (zTypeHelper != null) ? zTypeHelper.getExternalization() : null;
    }

    protected void sendUnsolicitedData() {
        PushInterface zPushInterface = mPushInterface;
        if ( zPushInterface != null ) {
            ServicePeerToFormData zData =
                    getCollectorProxy().createReturnValueFromCollectorIfMatches( null, mInteractionHelper, getRootTypeExternalizationInterface() );
            if ( zData != null ) {
                zPushInterface.sendUnsolicitedData( zData );
            }
        }
    }

    // protects serializes FormServicePeer interface
    public synchronized final ServicePeerToFormCreationData initializeAndCreateFormMetaData( PushInterface pPushInterface,
                                                                                             ISystemUserResolver pSystemUserResolver,
                                                                                             Long pUniqueFormServicePeerID, ISystemUser pSystemUser,
                                                                                             FormUsage pUsage, Serializable pInitializationPayload,
                                                                                             ExternalizationInterface pExternalization,
                                                                                             FormAccessControl pAccessControl ) {
        mPushInterface = pPushInterface;

        initializationPayloadAvailable( mInitializationPayload = pInitializationPayload );

        String zRT = getRootTypeFromUsage( pUsage );

        mSystemUserResolver = (pSystemUserResolver != null) ? pSystemUserResolver : ISystemUserResolver.NULL;

        handle( mInteractionHelper.setOurData( new FormInteractionStructure( pUniqueFormServicePeerID, pSystemUser, zRT ) ) );

        LOGGER.trace.log( zRT, "-initializeAndCreateFormMetaData:", getUniqueFormID(), " for ", pSystemUser );

        TypeHelper zRootTypeHelper = createTypeHelper( this, augment( pExternalization ), pAccessControl, null, zRT, pUsage );

        mTypeHelperManager.setRootTypeHelper( zRootTypeHelper );
        mInstanceHelperManager.setRootInstanceHelper( createRootInstanceHelper( zRootTypeHelper ) );

        FormMetaData zMetaData = zRootTypeHelper.initializeAndCreateFormMetaData( pUsage );

        return new ServicePeerToFormCreationData( zMetaData, getFormRenderedServicePeerXtra() );
    }

    protected String getRootTypeFromUsage( FormUsage pUsage ) {
        return pUsage.getRootType();
    }

    public void add( TypeHelper pTypeHelper ) {
        mTypeHelperManager.add( pTypeHelper );
    }

    public void add( InstanceHelper pInstanceHelper ) {
        mInstanceHelperManager.add( pInstanceHelper );
    }

    public void removeInstanceHelper( FormDataRowKey pFormDataRowKey ) {
        mInstanceHelperManager.remove( pFormDataRowKey );
    }

    public final boolean isDisposed() {
        return mDisposed;
    }

    // protects serializes FormServicePeer interface
    public synchronized final void dispose() {
        if ( !mDisposed ) {
            mDisposed = true;
            try {
                LLdispose();
            }
            catch ( RuntimeException e ) {
                LOGGER.error.log( e );
            }

            mInstanceHelperManager.dispose();
            mTypeHelperManager.dispose();
            handle( mInteractionHelper.setOurData( null ) );
            mPushInterface = null;
            mInitializationPayload = null;
        }
    }

    // protects serializes FormServicePeer interface
    public synchronized final ServicePeerToFormData setRootObjectTo( Integer pAsyncMessageNumber, String pKey ) {
        LOGGER.trace.log( getRootType(), "-setRootObjectTo, key:", pKey );

        getCollectorProxy().setCallFromClientForm( pAsyncMessageNumber );

        mInstanceHelperManager.resetAllInstanceHelpers();

        LLsetRootObjectTo( pKey );

        mInstanceHelperManager.loadAllAttributeValues();

        return getCollectorProxy().createReturnValueFromCollectorIfMatches( pAsyncMessageNumber, mInteractionHelper, getRootTypeExternalizationInterface() );
    }

    // protects serializes FormServicePeer interface
    public synchronized final AttributeResourceOptionsResponseData getResourceOptions( AttributeResourceOptionsRequestData pRequest ) {
        return getResourceOptions( pRequest.getFormDataRowKey(), pRequest.getUniqueID(), pRequest.getAttributeReference() );
    }

    // protects serializes FormServicePeer interface
    public synchronized final ServicePeerToFormData formEvent( FormToServicePeerData pToServicePeerData ) {
        Confirm.isNotNull( "ToServicePeerData", pToServicePeerData );

        Integer zAsyncMessageNumber = pToServicePeerData.getAsyncMessageNumber();

        getCollectorProxy().setCallFromClientForm( zAsyncMessageNumber );

        ValueUpdatedFormData[] zValueUpdates = pToServicePeerData.getAttributeUpdates();
        if ( zValueUpdates != null ) {
            for ( ValueUpdatedFormData update : zValueUpdates ) {
                processValueUpdated( update.getFormDataRowKey(), //
                                     update.getUniqueID(), update.getAttributeReference(), update.getCurrentValue() );
            }
        }

        ActionRequestFormData action = pToServicePeerData.getActionRequest();
        if ( action != null ) {
            processActionRequest( action.getFormDataRowKey(), action.getActionID(), action.isInputAction(), action.getParentFormDataRowKey() );
        }

        return getCollectorProxy().createReturnValueFromCollectorIfMatches( zAsyncMessageNumber, mInteractionHelper, getRootTypeExternalizationInterface() );
    }

    protected AttributeResourceOptionsResponseData getResourceOptions( FormDataRowKey pFormDataRowKey, Integer pUniqueID, String pAttributeReference ) {
        InstanceHelper zInstanceHelper = getInstanceHelper( pFormDataRowKey );
        if ( (zInstanceHelper != null) ) {
            AMDconverterPair changingPair = zInstanceHelper.findAttribute( pUniqueID );
            if ( changingPair != null ) {
                return zInstanceHelper.getTypeHelper().getResourceOptions( pAttributeReference, changingPair.getDataConverter() );
            }
        }
        return new AttributeResourceOptionsResponseData( ResourceOptionsErrorType.ErrorReferenceNotFound );
    }

    private void processValueUpdated( FormDataRowKey pFormDataRowKey, //
                                      Integer pUniqueID, String pAttributeReference, //
                                      Serializable pNewValue ) {
        //System.out.println( getRootType() + "-valueUpdated on (" + pFormDataRowKey + ") '" +
        //                    pAttributeReference + "' to '" + pNewValue + "' type:" +
        //                    ((pNewValue != null) ? pNewValue.getClass() : null) );
        //
        LOGGER.trace.log( getRootType(), "-valueUpdated on (", pFormDataRowKey, ") '", pAttributeReference, "' to '", pNewValue, "' type:",
                          ((pNewValue != null) ? pNewValue.getClass() : null) );

        String zResolvedError = null;
        AMDconverterPair changingPair = null;
        boolean handled = false;

        try {
            handled = LLrawValueUpdated( pFormDataRowKey, pAttributeReference, pNewValue );
        }
        catch ( IllegalArgumentException e ) {
            addError( ERR_ILLEGAL_VALUE, "LLrawValueUpdated", e.getMessage() );
        }
        catch ( RuntimeException e ) {
            addError( ERR_UNEXPECTED, "LLrawValueUpdated", e.getMessage() );
        }

        if ( !handled && !hasErrors() ) {
            InstanceHelper zInstanceHelper = getInstanceHelper( pFormDataRowKey );
            if ( zInstanceHelper == null ) {
                addError( ERR_ATTR_NOT_FOUND );
            } else if ( (null == (changingPair = zInstanceHelper.findAttribute( pUniqueID ))) ) {
                addError( ERR_ATTR_NOT_FOUND );
            } else {
                Object zValueForAttribute = null;
                try {
                    zValueForAttribute = changingPair.getDataConverter().convertFromPassable( pNewValue );
                }
                catch ( IllegalArgumentException e ) {
                    zResolvedError = rootTypeResolveError( ERR_ILLEGAL_VALUE, "Converted", e.getMessage() );
                }
                catch ( RuntimeException e ) {
                    zResolvedError = rootTypeResolveError( ERR_UNEXPECTED, "Converted", e.getMessage() );
                }
                if ( zResolvedError == null ) {
                    try {
                        if ( !(handled = LLvalueUpdated( zInstanceHelper, pAttributeReference, zValueForAttribute )) ) {
                            zResolvedError = rootTypeResolveError( ERR_VALUE_UPDATE_NOT_HANDLED );
                        }
                    }
                    catch ( IllegalArgumentException e ) {
                        zResolvedError = rootTypeResolveError( ERR_ILLEGAL_VALUE, "Update", e.getMessage() );
                    }
                    catch ( NoSuchElementException e ) {
                        zResolvedError = rootTypeResolveError( ERR_ATTR_NOT_FOUND, "Update", e.getMessage() );
                    }
                    catch ( RuntimeException e ) {
                        zResolvedError = rootTypeResolveError( ERR_UNEXPECTED, "Update", e.getMessage() );
                    }
                }
            }
        }
        if ( handled || (zResolvedError != null) ) {
            checkForChanges( changingPair, pNewValue, zResolvedError );
        }
    }

    protected boolean LLvalueUpdated( InstanceHelper pInstanceHelper, String pAttributeReference, Object pValueForAttribute ) {
        return pInstanceHelper.valueUpdated( pAttributeReference, pValueForAttribute );
    }

    private void processActionRequest( FormDataRowKey pFormDataRowKey, String pActionID, boolean pInputAction, FormDataRowKey pParentFormDataRowKey ) {
        LOGGER.trace.log( getRootType(), "-actionRequest, ", (pInputAction ? "Input" : "Reg"), " action:", pActionID );

        if ( actionRequest( pFormDataRowKey, pActionID, pInputAction, pParentFormDataRowKey ) ) {
            checkForChanges( null, null, null );
        } else if ( !pInputAction ) {
            addError( ERR_UNKNOWN_ACTION );
        }
        if ( !hasErrors() ) {
            setSuccessfulTriggeringActionIDIfNotSet( pActionID );
        }
    }

    protected void checkForChanges( AMDconverterPair pChangingPair, Serializable pNewValue, String pResolvedError ) {
        // Snag a list to avoid Concurrent Changes
        InstanceHelpersSnapShot zSnapShot = mInstanceHelperManager.getInstanceHelpers();
        InstanceHelper zRootHelper = zSnapShot.getRootInstanceHelper();
        zRootHelper.checkForChanges( pChangingPair, pNewValue, pResolvedError );
        for ( InstanceHelper helper : zSnapShot.getAllInstanceHelpers() ) {
            if ( helper != zRootHelper ) {
                helper.checkForChanges( pChangingPair, pNewValue, pResolvedError );
            }
        }
    }

    public boolean actionRequest( FormDataRowKey pFormDataRowKey, String pActionID, boolean pInputAction, FormDataRowKey pParentFormDataRowKey ) {
        if ( UiFormDef.ACTION_CLOSE.equals( pActionID ) ) {
            return actionClose( pActionID );
        }
        if ( UiFormDef.ACTION_DONE.equals( pActionID ) ) {
            return actionDone( pActionID );
        }
        if ( UiFormDef.ACTION_COMMIT.equals( pActionID ) ) {
            return actionCommit( pActionID );
        }
        if ( UiFormDef.ACTION_RELOAD.equals( pActionID ) ) {
            return actionReload( pActionID );
        }
        if ( UiFormDef.ACTION_NEW.equals( pActionID ) ) {
            return actionNew( pActionID );
        }
        InstanceHelper zInstanceHelper = getInstanceHelper( pFormDataRowKey );
        if ( zInstanceHelper != null ) {
            return zInstanceHelper.actionRequest( pActionID, pInputAction );
        }
        TypeHelper zTypeHelper = getTypeHelper( pFormDataRowKey );
        return (zTypeHelper != null) && //
               zTypeHelper.actionRequest( pActionID, pInputAction, getInstanceHelper( pParentFormDataRowKey ) );
    }

    public ArrayList<FormDataRowKey> getAllCurrentFormDataRowKeys() {
        return mInstanceHelperManager.getAllCurrentFormDataRowKeys();
    }

    public InstanceHelper getInstanceHelper( FormDataRowKey pFormDataRowKey ) {
        return mInstanceHelperManager.getInstanceHelper( pFormDataRowKey ); // null == Root
    }

    private TypeHelper getTypeHelper( FormDataRowKey pFormDataRowKey ) {
        return mTypeHelperManager.getTypeHelper( pFormDataRowKey ); // null == root
    }

    /**
     * @return true to indicate processing satisfied
     */
    protected boolean actionClose( String pSuccessfulTriggeringActionID ) {
        setCloseRequested();
        return true;
    }

    /**
     * Abandon any existing Root Object and create a new one
     *
     * @return true to indicate processing satisfied
     */
    protected boolean actionNew( String pSuccessfulTriggeringActionID ) {
        createNewRootObject();
        return initializeUpdates( pSuccessfulTriggeringActionID );
    }

    /**
     * Save current (mutated?) state of our backing Root Object and if successful
     * prepare the Root Object for future editing.
     *
     * @return true to indicate processing satisfied
     */
    protected boolean actionCommit( String pSuccessfulTriggeringActionID ) {
        commit();
        return hasErrors() || initializeUpdates( pSuccessfulTriggeringActionID );
    }

    /**
     * Save current (mutated?) state of our backing Root Object and if successful
     * request Close, and just in case Form is not closed then
     * prepare the Root Object for future editing.
     *
     * @return true to indicate processing satisfied
     */
    protected boolean actionDone( String pSuccessfulTriggeringActionID ) {
        commit();
        if ( hasErrors() ) {
            return true;
        }
        setCloseRequested();
        return initializeUpdates( pSuccessfulTriggeringActionID );
    }

    /**
     * Refresh the current Root Object with the latest version from its source (eg database)
     * (or a fresh new one if it was new and never committed)
     *
     * @return true to indicate processing satisfied
     */
    public boolean actionReload( String pSuccessfulTriggeringActionID ) {
        if ( !hasRootObject() ) {
            return true;
        }
        if ( mIsNewRootObject ) {
            createNewRootObject();
        } else {
            reloadExistingRootObject();
        }
        return initializeUpdates( pSuccessfulTriggeringActionID );
    }

    protected boolean initializeUpdates( String pSuccessfulTriggeringActionID ) {
        if ( hasRootObject() ) {
            setFullUpdate();
            setSuccessfulTriggeringActionIDIfNotSet( pSuccessfulTriggeringActionID );
            mInstanceHelperManager.resetAllInstanceHelpers();
            mInstanceHelperManager.loadAllAttributeValues();
        }
        return true;
    }

    protected void commit() {
        if ( hasRootObject() ) {
            try {
                LLcommit(); // commit what we've got
            }
            catch ( ConcurrentModificationException e ) {
                addError( ERR_COMMIT_OUT_OF_DATE_DATA );
                return;
            }
            catch ( RuntimeException e ) {
                LOGGER.warn.log( e, "Attempt to commit backing Root Object failed" );
                if ( e instanceof DisplayableException ) {
                    DisplayableException zDE = (DisplayableException) e;
                    String zParam = rootTypeResolveError( zDE.getToResolveIdentifier(), //
                                                          (Object[]) zDE.getParams() );
                    addError( ERR_COMMIT_FAILED, zParam );
                } else {
                    addError( ERR_COMMIT_FAILED );
                }
                return;
            }
            rootObjectCommited();
        }
    }

    protected void createNewRootObject() {
        mIsNewRootObject = true;
        String zRootObjectKey = LLnewRootObject();
        setRootObjectKey( zRootObjectKey );
    }

    protected void reloadExistingRootObject() {
        mIsNewRootObject = false;
        LLreloadExistingRootObject();
        mInteractionHelper.clearUpdatedData();
    }

    protected void loadExistingRootObject( String pNewRootObjectKey ) {
        mIsNewRootObject = false;
        if ( LLloadExistingRootObject( pNewRootObjectKey ) ) {
            setRootObjectKey( pNewRootObjectKey );
        }
    }

    /**
     * Either load the appropriate Root Object based on pKey, or create one if pKey was null
     */
    protected void LLsetRootObjectTo( String pKey ) {
        if ( pKey == null ) {
            createNewRootObject();
        } else {
            loadExistingRootObject( pKey );
        }
    }

    protected void LLdispose() {
    }

    /**
     * @return true to indicate processing satisfied
     */
    protected boolean LLrawValueUpdated( FormDataRowKey pFormDataRowKey, String pAttributeReference, Serializable pNewValue ) {
        return false;
    }

    protected void initializationPayloadAvailable( Serializable pInitializationPayload ) {
    }

    protected ExternalizationInterface augment( ExternalizationInterface pExternalizationInterface ) {
        return pExternalizationInterface;
    }

    protected InterceptingProxyExternalization proxy( ExternalizationInterface pExternalizationInterface ) {
        return new InterceptingProxyExternalization( pExternalizationInterface );
    }

    protected Serializable getFormRenderedServicePeerXtra() {
        return null;
    }

    abstract protected void LLcommit();

    abstract protected boolean hasRootObject();

    /**
     * @return new Root Objects Key
     */
    abstract protected String LLnewRootObject();

    /**
     * @return true if succeeded
     */
    abstract protected boolean LLreloadExistingRootObject();

    /**
     * @return true if succeeded
     */
    abstract protected boolean LLloadExistingRootObject( String pNewRootObjectKey );
}