// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.ui_1_5;

import java.io.*;

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.commonfoundation.typeutils.Objects;
import org.litesoft.ui.def.nonpublic.support.*;

public class ServicePeerToFormDataCollector extends AbstractServicePeerToFormData
{
    private boolean mForceReturn = false;
    private Integer mAsyncMessageNumber;
    private boolean mFullUpdate = false;
    private String mRootType;
    private String mRootObjectKey;
    private boolean mCloseRequested = false;
    private String mSuccessfulTriggeringActionID = null;
    private Serializable mServicePeerXtra = null;
    private List<ActionUpdateFormData> mActionUpdates = new ArrayList<ActionUpdateFormData>();
    private List<String> mFormErrors = new ArrayList<String>();
    private List<String> mFormWarnings = new ArrayList<String>();
    private List<AttributeUpdateFormData> mAttributeUpdates = new ArrayList<AttributeUpdateFormData>();
    private List<RelSubFormRowKeys> mRelSubFormRowKeysList = new ArrayList<RelSubFormRowKeys>();
    private List<FormPopupMessage> mPopups;

    public boolean shouldReturn()
    {
        return mForceReturn || (mAsyncMessageNumber != null) || isDirty();
    }

    public boolean isDirty()
    {
        return mCloseRequested || mFullUpdate || //
               (mSuccessfulTriggeringActionID != null) || //
               (mRootType != null) || //
               (mRootObjectKey != null) || //
               (mServicePeerXtra != null) || //
               !mActionUpdates.isEmpty() || //
               !mFormErrors.isEmpty() || //
               !mFormWarnings.isEmpty() || //
               !mAttributeUpdates.isEmpty() || //
               !mRelSubFormRowKeysList.isEmpty();
    }

    public void update( FormInteractionStructure pCurData, FormInteractionStructure pNewData )
    {
        if ( !Objects.areNonArraysEqual( pCurData.getRootType(), pNewData.getRootType() ) )
        {
            setRootType( pNewData.getRootType() );
        }
        if ( !Objects.areNonArraysEqual( pCurData.getRootObjectKey(), pNewData.getRootObjectKey() ) )
        {
            setRootObjectKey( pNewData.getRootObjectKey() );
        }
    }

    public void forceReturn()
    {
        mForceReturn = true;
    }

    public Integer getAsyncMessageNumber()
    {
        return mAsyncMessageNumber;
    }

    public void setAsyncMessageNumber( Integer pAsyncMessageNumber )
    {
        mAsyncMessageNumber = pAsyncMessageNumber;
    }

    public boolean isFullUpdate()
    {
        return mFullUpdate;
    }

    public void setFullUpdate( boolean pFullUpdate )
    {
        mFullUpdate = pFullUpdate;
    }

    public String getRootType()
    {
        return mRootType;
    }

    public void setRootType( String pRootType )
    {
        mRootType = Strings.noEmpty( pRootType );
    }

    public String getRootObjectKey()
    {
        return mRootObjectKey;
    }

    public void setRootObjectKey( String pRootObjectKey )
    {
        mRootObjectKey = Strings.noEmpty( pRootObjectKey );
    }

    public boolean isCloseRequested()
    {
        return mCloseRequested;
    }

    public void setCloseRequested( boolean pCloseRequested )
    {
        mCloseRequested = pCloseRequested;
    }

    public String getSuccessfulTriggeringActionID()
    {
        return mSuccessfulTriggeringActionID;
    }

    public void setSuccessfulTriggeringActionID( String pSuccessfulTriggeringActionID )
    {
        mSuccessfulTriggeringActionID = Strings.noEmpty( pSuccessfulTriggeringActionID );
    }

    public Serializable getServicePeerXtra()
    {
        return mServicePeerXtra;
    }

    public void setServicePeerXtra( Serializable pServicePeerXtra )
    {
        mServicePeerXtra = pServicePeerXtra;
    }

    public void add( ActionUpdateFormData pActionUpdate )
    {
        if ( pActionUpdate != null )
        {
            pActionUpdate.validate();
            mActionUpdates.add( pActionUpdate );
        }
    }

    protected ActionUpdateFormData[] LLgetActionUpdates()
    {
        if ( mActionUpdates.isEmpty() )
        {
            return null;
        }
        return mActionUpdates.toArray( new ActionUpdateFormData[mActionUpdates.size()] );
    }

    public boolean hasErrors()
    {
        return !mFormErrors.isEmpty();
    }

    public void addError( String pFormError )
    {
        if ( null != (pFormError = Strings.noEmpty( pFormError )) )
        {
            mFormErrors.add( pFormError );
        }
    }

    protected String[] LLgetFormErrors()
    {
        if ( mFormErrors.isEmpty() )
        {
            return null;
        }
        return mFormErrors.toArray( new String[mFormErrors.size()] );
    }

    public void addWarning( String pFormWarning )
    {
        if ( null != (pFormWarning = Strings.noEmpty( pFormWarning )) )
        {
            mFormWarnings.add( pFormWarning );
        }
    }

    protected String[] LLgetFormWarnings()
    {
        if ( mFormWarnings.isEmpty() )
        {
            return null;
        }
        return mFormWarnings.toArray( new String[mFormWarnings.size()] );
    }

    public void add( AttributeUpdateFormData pAttributeUpdate )
    {
        if ( pAttributeUpdate != null )
        {
            pAttributeUpdate.validate();
            mAttributeUpdates.add( pAttributeUpdate );
        }
    }

    protected AttributeUpdateFormData[] LLgetAttributeUpdates()
    {
        if ( mAttributeUpdates.isEmpty() )
        {
            return null;
        }
        return mAttributeUpdates.toArray( new AttributeUpdateFormData[mAttributeUpdates.size()] );
    }

    public void add( RelSubFormRowKeys pRowKeys )
    {
        if ( pRowKeys != null )
        {
            pRowKeys.validate();
            mRelSubFormRowKeysList.add( pRowKeys );
        }
    }

    protected RelSubFormRowKeys[] LLgetRelSubFormRowKeysList()
    {
        if ( mRelSubFormRowKeysList.isEmpty() )
        {
            return null;
        }
        return mRelSubFormRowKeysList.toArray( new RelSubFormRowKeys[mRelSubFormRowKeysList.size()] );
    }

    public void addPopup( FormPopupMessage popup )
    {
        if ( mPopups == null )
        {
            mPopups = new ArrayList<FormPopupMessage>();
        }
        mPopups.add( popup );
    }

    public FormPopupMessage[] getPopups()
    {
        if ( mPopups == null )
        {
            return new FormPopupMessage[0];
        }
        return mPopups.toArray( new FormPopupMessage[mPopups.size()] );
    }
}