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

import org.litesoft.commonfoundation.typeutils.Objects;
import java.util.*;
import java.util.concurrent.atomic.*;

import org.litesoft.GWT.forms.server.*;
import java.io.*;

import org.litesoft.ui.def.nonpublic.support.*;

public abstract class InstanceHelper
{
    private AtomicBoolean mDisposed = new AtomicBoolean( false );
    protected TypeHelper mTypeHelper;
    private String mRowObjectKey;
    private FormDataRowKey mFormDataRowKey = null;

    private Set<AttributeUpdateFormData> mUpdates = new HashSet<AttributeUpdateFormData>();
    private Map<TypeHelper, List<String>> mRelSubFormRefToRowObjectKeys =
            new HashMap<TypeHelper, List<String>>();

    public InstanceHelper( TypeHelper pTypeHelper, String pRowObjectKey )
    {
        mTypeHelper = pTypeHelper;
        if ( null != (mRowObjectKey = pRowObjectKey) )
        {
            mFormDataRowKey = new FormDataRowKey( mTypeHelper.getFormUniqueID(), mRowObjectKey );
        }
    }

    public FormDataRowKey getFormDataRowKey()
    {
        return mFormDataRowKey;
    }

    public final boolean isDisposed()
    {
        return mDisposed.get();
    }

    public final void dispose()
    {
        if ( !mDisposed.getAndSet( true ) ) // set true and test for false
        {
            try
            {
                LLdispose();
            }
            catch ( RuntimeException e )
            {
                FormServicePeer.LOGGER.error.log( e );
            }
            synchronized ( this )
            {
                mRowObjectKey = null;
                mUpdates.clear();
                mRelSubFormRefToRowObjectKeys.clear();
            }
        }
    }

    protected void LLdispose()
    {
    }

    public AMDconverterPair findAttribute( Integer pUniqueID )
    {
        return mTypeHelper.findAttribute( pUniqueID );
    }

    public synchronized void resetSavedAttibuteValues()
    {
        mUpdates.clear();
        mRelSubFormRefToRowObjectKeys.clear();
    }

    public synchronized void loadAllAttributeValues()
    {
        for ( AMDconverterPair pair : mTypeHelper.getAMDconvertPairs() )
        {
            AttributeMetaData meta = pair.getAttributeMetaData();
            AttributeUpdateFormData data = new AttributeUpdateFormData( mFormDataRowKey, meta );
            String attributeRef = meta.getAttributeReference();
            Object value = getRawAttributeValue( attributeRef );
            data.value( pair.getDataConverter().convertToPassable( value ) );
            mTypeHelper.getCollectorProxy().add( data );
            mUpdates.add( data );
        }
        checkForChangesInSubForms();
    }

    public List<AttributeUpdateFormData> findAttributeUpdateFormData( String pFieldName )
    {

        List<AttributeUpdateFormData> zData = new ArrayList<AttributeUpdateFormData>();
        for ( AMDconverterPair pair : mTypeHelper.getAMDconvertPairs() )
        {
            AttributeMetaData meta = pair.getAttributeMetaData();
            if ( pFieldName.equals( meta.getAttributeReference() ) )
            {
                zData.add( new AttributeUpdateFormData( mFormDataRowKey, meta ) );
            }
        }
        return zData;
    }

    public abstract boolean valueUpdated( String pAttributeReference, Object pValueForAttribute );

    abstract protected Object getRawAttributeValue( String pAttributeRef );

    abstract protected void setRawAttributeValue( String pAttributeRef, Object pValueForAttribute );

    public boolean actionRequest( String pActionID, boolean pInputAction )
    {
        return (!mTypeHelper.isBaseForm() && "RemoveRow".equals( pActionID )) ? removeRow() :
               mTypeHelper.actionRequest( pActionID, pInputAction, this );
    }

    /**
     * Only called for Non-BaseForms
     *
     * @return true if successful
     */
    protected boolean removeRow()
    {
        return false;
    }

    public synchronized void checkForChanges( AMDconverterPair pChangingPair, Serializable pNewValue,
                                              String pResolvedError )
    {
        if ( mTypeHelper != null )
        {
            for ( AttributeUpdateFormData update : mUpdates )
            {
                AMDconverterPair pair = mTypeHelper.findAttribute( update.getUniqueID() );
                // use of == okay, findAttribute will return the same obj for the same ref
                if ( pair != pChangingPair )
                {
                    checkForSideEffect( pair, update );
                }
                else if ( pResolvedError == null )
                {
                    // as this is the value we changed, change its update record now so we'll
                    // only report it as a change if it has FURTHER mutated from what we did to it.
                    update.value( pNewValue );
                    checkForSideEffect( pair, update );
                }
                else
                {
                    mTypeHelper.getCollectorProxy().add( update.copyForError( pResolvedError ) );
                }
            }
            checkForChangesInSubForms();
        }
    }

    private void checkForSideEffect( AMDconverterPair pConverterPair, AttributeUpdateFormData pUpdate )
    {
        Object raw = getRawAttributeValue( pUpdate.getAttributeReference() );
        Serializable current = pConverterPair.getDataConverter().convertToPassable( raw );
        Serializable last = pUpdate.getValue();

        if ( !Objects.areNonArraysEqual( current, last ) )
        {
            pUpdate.value( current );
            mTypeHelper.getCollectorProxy().add( pUpdate );
        }
    }

    private void checkForChangesInSubForms()
    {
        Map<String, TypeHelper[]> zRelRefsToTypes = mTypeHelper.getRelSubFormRefToTypes();
        if ( !zRelRefsToTypes.isEmpty() )
        {
            for ( Map.Entry<String, TypeHelper[]> entry : zRelRefsToTypes.entrySet() )
            {
                String zRelSubFormRef = entry.getKey();
                TypeHelper[] zHelpers = entry.getValue();
                for ( TypeHelper zHelper : zHelpers )
                {
                    checkForChangesInSubForms( zRelSubFormRef, zHelper );
                }
            }
        }
    }

    abstract protected List<String> getRowKeysFor( String pRelSubFormRef );

    private synchronized void checkForChangesInSubForms( String pRelSubFormRef, TypeHelper pTypeHelper )
    {
        List<String> zActualRowKeys = getRowKeysFor( pRelSubFormRef );
        List<String> zReportedRowKeys = mRelSubFormRefToRowObjectKeys.get( pTypeHelper );
        boolean zRowsDifferent = false;
        if ( zReportedRowKeys == null )
        {
            zReportedRowKeys = Collections.emptyList();
            zRowsDifferent = true;
        }
        List<String> zToDeleteRowKeys = new ArrayList<String>( zReportedRowKeys );
        List<String> zToAddRowKeys = new ArrayList<String>();
        for ( int i = 0; i < zActualRowKeys.size(); i++ )
        {
            String zActualRowKey = zActualRowKeys.get( i );
            if ( !zReportedRowKeys.contains( zActualRowKey ) )
            {
                zToAddRowKeys.add( zActualRowKey );
            }
            else
            {
                zToDeleteRowKeys.remove( zActualRowKey );
                if ( !zRowsDifferent )
                {
                    zRowsDifferent = (zReportedRowKeys.size() <= i) ||
                                     !zActualRowKey.equals( zReportedRowKeys.get( i ) );
                }
            }
        }
        for ( String zToDeleteRowKey : zToDeleteRowKeys )
        {
            zRowsDifferent = true;
            pTypeHelper.removeInstanceHelper( zToDeleteRowKey );
        }
        for ( String zToAddRowKey : zToAddRowKeys )
        {
            zRowsDifferent = true;
            InstanceHelper zNewHelper = pTypeHelper.createRelSubInstanceHelper( this, zToAddRowKey );
            zNewHelper.loadAllAttributeValues();
        }
        if ( zRowsDifferent )
        {
            mRelSubFormRefToRowObjectKeys.put( pTypeHelper, zActualRowKeys );
            String[] zKeysAsArray = zActualRowKeys.toArray( new String[zActualRowKeys.size()] );
            mTypeHelper.getCollectorProxy().add(
                    new RelSubFormRowKeys( mFormDataRowKey, mTypeHelper.getFormUniqueID(), //
                                           pRelSubFormRef, zKeysAsArray ) );
        }
    }

    public TypeHelper getTypeHelper()
    {
        return mTypeHelper;
    }
}