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

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

import com.google.gwt.user.client.ui.*;

import java.util.*;

public class RelSubFormInstanceComponentHandlerImpl extends AbstractFormInstanceComponentHandler
        implements RelSubFormInstanceComponentHandler {
    private RelSubFormInstanceParentable mParent;
    private RelSubFormTypeHelper mTypeHelper;
    private SubFormRowCarrier mRowCarrier;
    private FormDataRowKey mFormDataRowKey;
    private RelSubFormInstanceRenderer mRenderer = null;

    public RelSubFormInstanceComponentHandlerImpl( RelSubFormInstanceParentable pParent,
                                                   RelSubFormTypeHelper pTypeHelper,
                                                   SubFormRowCarrier pRowCarrier ) {
        Confirm.isNotNull( "Parent", mParent = pParent );
        Confirm.isNotNull( "TypeHelper", mTypeHelper = pTypeHelper );
        Confirm.isNotNull( "RowContainer", mRowCarrier = pRowCarrier );
        mParent.addChild( this );
        mFormDataRowKey = new FormDataRowKey( getFormUniqueID() );
    }

    public void setRenderer( RelSubFormInstanceRenderer pRenderer ) {
        mRenderer = pRenderer;
    }

    public FormDataRowKey getFormDataRowKey() {
        return mFormDataRowKey;
    }

    public FormDataRowKey getParentFormDataRowKey() {
        return mParent.getFormDataRowKey();
    }

    public UberFormInstanceComponentHandler getUberHandler() {
        return mParent.getUberHandler();
    }

    public Integer getFormUniqueID() {
        return mTypeHelper.getFormUniqueID();
    }

    public void addAttributeAdapter( FormAttributeAdapter pAttributeAdapter ) {
        throw new IllegalStateException( "Adding Attributes to the RelSubForm directly is NOT supported" );
    }

    public SubFormRowCarrier getRowCarrier() {
        return mRowCarrier;
    }

    protected void LLdispose( UberFormInstanceComponentHandler pUberHandler ) {
        LLdisposeChildren( pUberHandler );

        super.LLdispose( pUberHandler );

        mTypeHelper = null;

        mParent = null;

        mFormDataRowKey = null;
        mRowCarrier = null;
        mRenderer = null;
    }

    protected boolean LLsetInputDisabledOnUs( String pAttributeName, boolean pDisabled ) {
        return false;
    }

    protected void LLapplyOnUs( AttributeUpdateFormData[] pAttributeUpdates ) {
    }

    protected boolean LLanyUserInitiatedRowChangeOnUs() {
        return mUserInitiatedRowChange;
    }

    protected boolean LLrecalcAnyAttributesOnUs( FormAttributeAdapter.BooleanValueAccessor pValueAccessor ) {
        return false;
    }

    protected void LLpublishAnyPendingAttributeChangesOnUs() {
    }

    // Child Component Handler Management

    protected void LLapplyOnChildren( ActionUpdateFormData[] pActionUpdates ) {
        for ( int i = 0; i < mRows.size(); i++ ) {
            getRow( i ).apply( pActionUpdates );
        }
    }

    protected void LLupdateInputStateOnChildren( boolean pAnyChanged, boolean pAnyErrors ) {
        for ( int i = 0; i < mRows.size(); i++ ) {
            getRow( i ).updateInputState( pAnyChanged, pAnyErrors );
        }
    }

    protected boolean LLsetActionDisabledOnChildren( FormDataRowKey pFormDataRowKey, String pActionID,
                                                     boolean pDisabled ) {
        for ( int i = 0; i < mRows.size(); i++ ) {
            if ( getRow( i ).setActionDisabled( pFormDataRowKey, pActionID, pDisabled ) ) {
                return true;
            }
        }
        return false;
    }

    protected boolean LLsetInputDisabledOnChildren( FormDataRowKey pFormDataRowKey, String pAttributeName,
                                                    boolean pDisabled ) {
        for ( int i = 0; i < mRows.size(); i++ ) {
            if ( getRow( i ).setInputDisabled( pFormDataRowKey, pAttributeName, pDisabled ) ) {
                return true;
            }
        }
        return false;
    }

    protected void LLapplyOnChildren( AttributeUpdateFormData[] pAttributeUpdates ) {
        for ( int i = 0; i < mRows.size(); i++ ) {
            getRow( i ).apply( pAttributeUpdates );
        }
    }

    protected boolean LLanyUserInitiatedRowChangeOnChildren() {
        for ( int i = 0; i < mRows.size(); i++ ) {
            if ( getRow( i ).anyUserInitiatedRowChange() ) {
                return true;
            }
        }
        return false;
    }

    protected boolean LLrecalcAnyAttributesOnChildren(
            FormAttributeAdapter.BooleanValueAccessor pValueAccessor ) {
        for ( int i = 0; i < mRows.size(); i++ ) {
            if ( getRow( i ).recalcAnyAttributes( pValueAccessor ) ) {
                return true;
            }
        }
        return false;
    }

    protected void LLpublishAnyPendingAttributeChangesOnChildren() {
        for ( int i = 0; i < mRows.size(); i++ ) {
            getRow( i ).publishAnyPendingAttributeChanges();
        }
    }

    public void apply( RelSubFormRowKeys[] pList, boolean pFullUpdate, boolean pUserInitiatedAddOrRemoveRow ) {
        if ( isActive() ) {
            Integer zMyContainingFormUniqueID = mParent.getFormUniqueID();
            FormDataRowKey zMyContainingRow = mParent.getFormDataRowKey();
            String zMyRelToParentAttributeName = mTypeHelper.getRelAttribute();
            for ( int i = 0; i < pList.length; i++ ) {
                RelSubFormRowKeys zKeys = pList[i];
                if ( zMyContainingFormUniqueID.equals( zKeys.getContainingFormUniqueID() ) && // Off My Parent
                     zMyRelToParentAttributeName.equals( zKeys.getRelSubFormRef() ) && // For Me && specific
                     Currently.areEqual( zMyContainingRow, zKeys.getContainingRow() ) ) // Sub Row
                {
                    boolean zRowsWereChanged = update( zKeys.getRowKeys() );
                    boolean zSavedUserInitiatedRowChange = mUserInitiatedRowChange;
                    if ( pFullUpdate ) {
                        mUserInitiatedRowChange = false;
                    } else if ( zRowsWereChanged ) {
                        mUserInitiatedRowChange = pUserInitiatedAddOrRemoveRow;
                    }
                    if ( zSavedUserInitiatedRowChange != mUserInitiatedRowChange ) {
                        componentChangedState( mUserInitiatedRowChange );
                    }
                }
            }
            for ( int i = 0; i < mRows.size(); i++ ) {
                getRow( i ).apply( pList, pFullUpdate, pUserInitiatedAddOrRemoveRow );
            }
        }
    }

    private void LLdisposeChildren( UberFormInstanceComponentHandler pUberHandler ) {
        for ( int i = mRows.size(); --i >= 0; ) // Reverse for Safety
        {
            getRow( i ).dispose( pUberHandler );
        }
        mRows.clear();
    }

    private RelSubFormRowInstanceComponentHandlerImpl getRow( int pAt ) {
        return (RelSubFormRowInstanceComponentHandlerImpl) mRows.get( pAt );
    }

    private List mRows = new ArrayList();
    private boolean mUserInitiatedRowChange = false;

    private boolean update( String[] pRowKeys ) {
        boolean anyChange = false;
        if ( Currently.isNullOrEmpty( pRowKeys ) ) {
            if ( !mRows.isEmpty() ) {
                anyChange = true;
                mRowCarrier.clear();
                LLdisposeChildren( getUberHandler() );
            }
            return anyChange;
        }
        int i = 0;
        do {
            String zRowKey = pRowKeys[i];
            int zCurrentlyAt = locate( zRowKey, i );
            if ( zCurrentlyAt != i ) {
                if ( zCurrentlyAt == -1 ) {
                    anyChange = true;
                    insertNewAt( zRowKey, i );
                } else {
                    anyChange = true;
                    moveUpFromTo( zCurrentlyAt, i );
                }
            }
        }
        while ( ++i < pRowKeys.length );
        while ( mRows.size() > i ) {
            anyChange = true;
            removeAt( mRows.size() - 1 );
        }
        return anyChange;
    }

    private int locate( String pRowKey, int pFrom ) {
        for ( int i = pFrom; i < mRows.size(); i++ ) {
            RelSubFormRowInstanceComponentHandlerImpl zRowHandler = getRow( i );
            if ( pRowKey.equals( zRowHandler.getRowObjectKey() ) ) {
                return i;
            }
        }
        return -1; // Not Found
    }

    private void removeAt( int pAt ) {
        for ( int i = mRows.size(); --i > pAt; ) // Reverse for Safety
        {
            getRow( i ).decRowIndex();
        }
        getRow( pAt ).dispose( getUberHandler() );
        mRows.remove( pAt );
    }

    private void insertNewAt( String pRowKey, int pAt ) {
        for ( int i = mRows.size(); --i >= pAt; ) // Reverse for Safety
        {
            getRow( i ).incRowIndex();
        }
        RelSubFormRowInstanceComponentHandlerImpl zHandler =
                new RelSubFormRowInstanceComponentHandlerImpl( this, pRowKey, pAt );
        mRows.add( pAt, zHandler );
        Widget zWidget = mRenderer.renderRow( zHandler, pRowKey, pAt );
        zHandler.init( zWidget );
        FormMetaData zMetaData = mTypeHelper.getFormMetaData();
        UiRelSubFormDef zRelSubForm = mTypeHelper.getRelSubForm();
        AttributeUsage zTabAttributeUsage = zRelSubForm.getTabAttributeUsage();
        if ( (zMetaData != null) && (zTabAttributeUsage != null) ) {
            AttributeMetaData zTabAttributeMD = zMetaData.getAttribute( zTabAttributeUsage.getUniqueID() );
            if ( zTabAttributeMD != null ) {
                zHandler.createTabAttributeAdapter( zTabAttributeMD );
            }
        }
    }

    private void moveUpFromTo( int pFrom, int pTo ) {
        for ( int i = pFrom; --i >= pTo; ) // Reverse for Safety
        {
            getRow( i ).incRowIndex();
        }
        // Move the Row Handler
        RelSubFormRowInstanceComponentHandlerImpl zRowHandler =
                (RelSubFormRowInstanceComponentHandlerImpl) mRows.remove( pFrom );
        mRows.add( pTo, zRowHandler );
        // Move The Widget
        zRowHandler.setRowIndex( pTo );
    }

    public RelSubFormTypeHelper getRelSubFormTypeHelperFor( UiRelSubFormDef pSubFormDef,
                                                            FormMetaData pSubFormMetaData ) {
        RelSubFormTypeHelper zTypeHelper = mTypeHelper.getChild( pSubFormDef.getAttributeName() );
        return (zTypeHelper != null) ? zTypeHelper :
               new RelSubFormTypeHelperImpl( mTypeHelper, pSubFormDef, pSubFormMetaData );
    }
}