package org.litesoft.GWT.forms.client.nonpublic;

import org.litesoft.GWT.forms.client.components.*;
import org.litesoft.core.util.*;
import org.litesoft.rpcpassable.*;
import org.litesoft.ui.def.nonpublic.support.*;

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

public abstract class AbstractFormAttributeAdapter extends AbstractFormComponentAdapter
        implements FormAttributeAdapter,
                   IFormComponent.Listener
{
    private Integer mUniqueID;
    private String mAttributeReference;
    private IFormComponent mComponent;
    private String mErrorText = null;
    private Object mPublishedComponentValue = null;
    private Object mErrorComponentValue = null;
    private Object mBaseComponentValue = null;

    public AbstractFormAttributeAdapter( FormInstanceComponentHandler pComponentHandler,
                                         AttributeMetaData pMD, IFormComponent pComponent )
    {
        super( pComponentHandler );
        mUniqueID = pMD.getUniqueID();
        mAttributeReference = pMD.getAttributeReference();
        mComponent = pComponent;
        if ( pMD.isDisabled() )
        {
            mComponent.setEnabled( false );
        }
    }

    public final Widget init()
    {
        mComponent.addFormComponentListener( this );
        mComponentFormHandler.addAttributeAdapter( this );
        Widget widget = initWidget();
        Object zComponentCurrentValue = getComponentCurrentValue();
        RPCpassable zSendableCurrentValue = convertComponentValueToSendable( zComponentCurrentValue );
        LLsetErrorText( null, zSendableCurrentValue, zComponentCurrentValue );
        return widget;
    }

    public void add( IFormComponent pComponent )
    {
        // As we already have the Component, we can ignore this call...
    }

    public void remove( IFormComponent pComponent )
    {
        // Our Components life cycle is managed differently, we can ignore this call...
    }

    protected Widget initWidget()
    {
        return (Widget) mComponent;
    }

    // FormAttributeAdapter

    public Integer getUniqueID()
    {
        return mUniqueID;
    }

    public String getAttributeReference()
    {
        return mAttributeReference;
    }

    public boolean isErrorState()
    {
        return mErrorText != null;
    }

    public String getErrorText()
    {
        return mErrorText;
    }

    public void setErrorText( String pErrorText )
    {
        Object zComponentCurrentValue = getComponentCurrentValue();
        RPCpassable zSendableCurrentValue = convertComponentValueToSendable( zComponentCurrentValue );
        setErrorTextAndPublish( pErrorText, zSendableCurrentValue, zComponentCurrentValue );
    }

    public boolean isChangedState()
    {
        return !areEqual( mBaseComponentValue, getComponentCurrentValue() );
    }

    public RPCpassable getBaseValue()
    {
        return convertComponentValueToSendable( mBaseComponentValue );
    }

    public void setBaseValue( RPCpassable pBaseValue )
    {
        mBaseComponentValue = convertSendableToComponentValue( pBaseValue );
        setComponentCurrentValue( mPublishedComponentValue = mBaseComponentValue );
        chkChangeOccurred( pBaseValue, mBaseComponentValue );
    }

    public RPCpassable getCurrentValue()
    {
        return convertComponentValueToSendable( getComponentCurrentValue() );
    }

    public void setCurrentValue( RPCpassable pCurrentValue )
    {
        Object zComponentCurrentValue = convertSendableToComponentValue( pCurrentValue );
        setComponentCurrentValue( zComponentCurrentValue );
        chkChangeOccurred( pCurrentValue, zComponentCurrentValue );
    }

    public String getUserValue()
    {
        return convertComponentValueToString( getComponentCurrentValue() );
    }

    public void setUserValue( String pValue )
    {
        setComponentUserValue( convertStringToComponentValue( pValue ) );

        // handle change
        Object zComponentCurrentValue = getComponentCurrentValue();
        RPCpassable zSendableCurrentValue = convertComponentValueToSendable( zComponentCurrentValue );
        chkChangeOccurred( zSendableCurrentValue, zComponentCurrentValue );

        // handle update
        if ( !areEqual( mPublishedComponentValue, zComponentCurrentValue ) )
        {
            mPublishedComponentValue = zComponentCurrentValue;
            publishUpdatedValue( zSendableCurrentValue );
        }
    }

    protected void setComponentUserValue( Object pComponentValue )
    {
        setComponentCurrentValue( pComponentValue );
    }

    public void publishAnyPendingChanges()
    {
        mComponent.publishAnyPendingChanges();
    }

    public void updateValidOptions( RPCpassable[] pValidOptions )
    {
        // Do nothing as most components do NOT support valid Options
    }

    // FormComponentAdapter

    public boolean isVisible()
    {
        return mComponent.isVisible();
    }

    public boolean setFocus()
    {
        return mComponent.setFocus();
    }

    protected void setWidgetEnabled( boolean pEnabled )
    {
        mComponent.setEnabled( pEnabled );
    }

    public boolean isEnabled()
    {
        return mComponent.isEnabled();
    }

    // IFormComponent.Listener

    public void changeOccurred()
    {
        Object zComponentCurrentValue = getComponentCurrentValue();
//        System.out.println( "changeOccurred: " + this + " | " + zComponentCurrentValue );
        RPCpassable zSendableCurrentValue = convertComponentValueToSendable( zComponentCurrentValue );
        chkChangeOccurred( zSendableCurrentValue, zComponentCurrentValue );
    }

    public void blurOccurred()
    {
//        System.out.println( "blurOccurred: " + this );
        mComponent.setFocused( false );
        optionallyPublishUpdatedValue();
    }

    public void focusOccured()
    {
//        System.out.println( "focusOccured: " + this );
        mComponent.setFocused( true );
    }

    // Support...

    protected Object getComponentCurrentValue()
    {
        return mComponent.getCurrentValue();
    }

    protected void setComponentCurrentValue( Object pNewComponentCurrentValue )
    {
        mComponent.setCurrentValue( pNewComponentCurrentValue );
    }

    protected void setErrorTextAndPublish( String pErrorText, RPCpassable pSendableCurrentValue,
                                           Object pComponentCurrentValue )
    {
        LLsetErrorText( pErrorText, pSendableCurrentValue, pComponentCurrentValue );
        mErrorComponentValue = pComponentCurrentValue;
        publishErrorState( isErrorState() );
    }

    protected void LLsetErrorText( String pErrorText, RPCpassable pSendableCurrentValue,
                                   Object pComponentCurrentValue )
    {
        mComponent.setError( mErrorText = transformErrorText( pErrorText, //
                                                              pSendableCurrentValue, //
                                                              pComponentCurrentValue ) );
    }

    protected String transformErrorText( String pErrorText, RPCpassable pSendableCurrentValue,
                                         Object pComponentCurrentValue )
    {
        pErrorText = UtilsCommon.noEmpty( pErrorText );
        if ( (pErrorText == null) && (pComponentCurrentValue instanceof FormTextInputErrorValue) )
        {
            return ((FormTextInputErrorValue)pComponentCurrentValue).getErrorMessage();
        }
        return pErrorText;
    }

    protected void chkChangeOccurred( RPCpassable pSendableCurrentValue, Object pComponentCurrentValue )
    {
        boolean changedFromBaseCV = !areEqual( mBaseComponentValue, pComponentCurrentValue );
        boolean changedFromErrorCV = !areEqual( mErrorComponentValue, pComponentCurrentValue );
        if ( changedFromErrorCV )
        {
            resetErrorOnChangeOccurred( pSendableCurrentValue, pComponentCurrentValue );
        }
        mComponent.setValueChanged( changedFromBaseCV );
        publishChangedState( changedFromBaseCV );
    }

    protected void optionallyPublishUpdatedValue()
    {
        Object zComponentCurrentValue = getComponentCurrentValue();
        RPCpassable zSendableCurrentValue = convertComponentValueToSendable( zComponentCurrentValue );
        if ( !areEqual( mPublishedComponentValue, zComponentCurrentValue ) )
        {
            mPublishedComponentValue = zComponentCurrentValue;
            publishUpdatedValue( zSendableCurrentValue );
        }
    }

    protected void publishErrorState( boolean pErrorState )
    {
        mComponentFormHandler.componentErrorState( pErrorState );
    }

    protected void publishChangedState( boolean pChangedState )
    {
        mComponentFormHandler.componentChangedState( pChangedState );
    }

    protected void publishUpdatedValue( RPCpassable pCurrentValue )
    {
        mComponentFormHandler.componentUpdatedValue( this, pCurrentValue );
    }

    protected void resetErrorOnChangeOccurred( RPCpassable pSendableCurrentValue,
                                               Object pComponentCurrentValue )
    {
        setErrorTextAndPublish( null, pSendableCurrentValue,
                                pComponentCurrentValue ); // Turn off error - assume no error
    }

    protected RPCpassable convertComponentValueToSendable( Object pValue )
    {
        if ( (pValue == null) || (pValue instanceof FormTextInputErrorValue) )
        {
            return null;
        }
        return LLconvertNonNullComponentValueToSendable( pValue );
    }

    protected RPCpassable LLconvertNonNullComponentValueToSendable( Object pValue )
    {
        return (RPCpassable) pValue;
    }

    abstract protected Object convertSendableToComponentValue( RPCpassable pValue );

    abstract protected String convertComponentValueToString( Object pValue );

    abstract protected Object convertStringToComponentValue( String pValue );

    public String toString()
    {
        return "FormAttributeAdapter(" + getAttributeReference() + ")";
    }
}