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

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

public abstract class AbstractNumericRequireableAttributeAdapter
        extends AbstractNonStringRequireableAttributeAdapter
{
    private Integer mDecimalPlaces;
    private NumericFormatControl mFormatControl;

    public AbstractNumericRequireableAttributeAdapter( FormInstanceComponentHandler pComponentHandler,
                                                       UiInputDef pUiDef, NumericMetaData pMD )
    {
        super( pComponentHandler, pMD, createFC( pUiDef, pMD ) );
        if ( (null != (mDecimalPlaces = pMD.getDecimalPlaces())) && //
             ((mDecimalPlaces.intValue() < 0) || (mDecimalPlaces.intValue() > 20)) )
        {
            int i = Math.abs( mDecimalPlaces.intValue() );
            mDecimalPlaces = new Integer( (i > 20) ? 20 : i );
        }
        if ( null == (mFormatControl = pMD.getFormatControl()) )
        {
            mFormatControl = NumericFormatControl.JUST_DOT;
        }
    }

    private static FormRightAlignTextField createFC( UiInputDef pUiDef, NumericMetaData pMD )
    {
        String zLabelText = !pUiDef.isLabelLess() ? pMD.getExternalText() : null;
        UiFont zLabelFont = pUiDef.getLabelFont();
        String zTooltip = pMD.getTooltip();

        Integer zPreferredWidth = !pUiDef.isFloodX() ? pMD.getPreferredWidth() : null;
        Integer zMaxChars = pMD.getMaxChars();

        return new FormRightAlignTextField( zLabelText, zLabelFont, zTooltip, zPreferredWidth, zMaxChars );
    }

    protected Object getComponentCurrentValue()
    {
        Object value = super.getComponentCurrentValue();
        if ( value != null )
        {
            value = UtilsCommon.noEmpty( value.toString() );
        }
        return value;
    }

    public void blurOccurred()
    {
        super.blurOccurred();
        if ( !isErrorState() )
        {
            try
            {
                DecimalToStringParts zSP = convert( mComponent.getCurrentText() );
                if ( zSP != null )
                {
                    mComponent.setCurrentValue(
                            mLastErrorComponentCurrentValue = zSP.toString( mFormatControl ) );
                }
            }
            catch ( IllegalArgumentException e )
            {
                // Already in Error State
            }
        }
    }

    protected String transformErrorText( String pErrorText, RPCpassable pSendableCurrentValue,
                                         Object pComponentCurrentValue )
    {
        if ( null == (pErrorText = UtilsCommon.noEmpty( pErrorText )) )
        {
            pErrorText = getCurrentValueErrorText( pComponentCurrentValue );
        }
        return super.transformErrorText( pErrorText, //
                                         pSendableCurrentValue, //
                                         pComponentCurrentValue );
    }

    protected Object convertSendableToComponentValue( RPCpassable pValue )
    {
        try
        {
            DecimalToStringParts zSP = convert( pValue );
            if ( zSP != null )
            {
                return mLastErrorComponentCurrentValue = zSP.toString( mFormatControl );
            }
        }
        catch ( IllegalArgumentException e )
        {
            AlertManager.alert( "DataConversion", null, "Unable to convert value", "Value:" + pValue, e );
        }
        return null;
    }

    protected RPCpassable convertComponentValueToSendable( Object pValue )
    {
        try
        {
            DecimalToStringParts zSP = convert( pValue );
            if ( zSP != null )
            {
                return LLconvertNonNullComponentValueToSendable( zSP.toString() );
            }
        }
        catch ( IllegalArgumentException e )
        {
            mLastErrorText = e.getMessage();
            setErrorTextAndPublish( null, null, mLastErrorComponentCurrentValue );
        }
        return null;
    }

    abstract protected RPCpassable LLconvertNonNullComponentValueToSendable( String pCleanedValue );

    private DecimalToStringParts convert( Object pValue )
            throws IllegalArgumentException
    {
        mLastErrorText = null;
        if ( null != (mLastErrorComponentCurrentValue = conversionHelper( pValue )) )
        {
            DecimalToStringParts zSP = new DecimalToStringParts( mLastErrorComponentCurrentValue, //
                                                                 mFormatControl.getDecimalSeparator() );
            return zSP.forceDecimalPlaces( mDecimalPlaces, false );
        }
        return null;
    }

    private String conversionHelper( Object pValue )
    {
        return (pValue != null) ? UtilsCommon.noEmpty( pValue.toString() ) : null;
    }

    private String getCurrentValueErrorText( Object pComponentCurrentValue )
    {
        if ( !UtilsCommon.areNonArraysEqual( pComponentCurrentValue, mLastErrorComponentCurrentValue ) )
        {
            convertComponentValueToSendable( mComponent.getCurrentText() );
        }
        return mLastErrorText;
    }

    private String mLastErrorComponentCurrentValue = null;
    private String mLastErrorText = null;
}