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

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.forms.client.components.*;
import org.litesoft.commonfoundation.base.*;
import org.litesoft.ui.def.nonpublic.support.*;

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

import java.io.*;

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();
        Serializable 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();
        Serializable zSendableCurrentValue = convertComponentValueToSendable( zComponentCurrentValue );
        setErrorTextAndPublish( pErrorText, zSendableCurrentValue, zComponentCurrentValue );
    }

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

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

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

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

    public void setCurrentValue( Serializable 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();
        Serializable 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( Serializable[] 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 );
        Serializable 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, Serializable pSendableCurrentValue,
                                           Object pComponentCurrentValue ) {
        LLsetErrorText( pErrorText, pSendableCurrentValue, pComponentCurrentValue );
        mErrorComponentValue = pComponentCurrentValue;
        publishErrorState( isErrorState() );
    }

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

    protected String transformErrorText( String pErrorText, Serializable pSendableCurrentValue,
                                         Object pComponentCurrentValue ) {
        pErrorText = ConstrainTo.significantOrNull( pErrorText );
        if ( (pErrorText == null) && (pComponentCurrentValue instanceof FormTextInputErrorValue) ) {
            return ((FormTextInputErrorValue) pComponentCurrentValue).getErrorMessage();
        }
        return pErrorText;
    }

    protected void chkChangeOccurred( Serializable 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();
        Serializable 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( Serializable pCurrentValue ) {
        mComponentFormHandler.componentUpdatedValue( this, pCurrentValue );
    }

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

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

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

    abstract protected Object convertSendableToComponentValue( Serializable pValue );

    abstract protected String convertComponentValueToString( Object pValue );

    abstract protected Object convertStringToComponentValue( String pValue );

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

    @Override
    public void enterPressed( KeyboardKeyModifier pModifiers ) {
        // todo: Implement!
    }
}