package org.litesoft.GWT.forms.client;

import java.util.*;

import org.litesoft.GWT.forms.client.components.impls.input.*;
import org.litesoft.GWT.forms.client.components.nonpublic.*;
import org.litesoft.bo.*;
import org.litesoft.bo.attributes.*;
import org.litesoft.bo.views.*;
import org.litesoft.core.simpletypes.*;
import org.litesoft.core.simpletypes.temporal.*;
import org.litesoft.core.util.*;

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

public class FormBinder<T extends IViewObject>
{
    public static final String LABEL_EXTENSION_REQUIRED = " *";
    public static final String LABEL_EXTENSION_UNIQUE = " **";

    private T mObject = null;
    private FormEngine mFE;
    private VoMetaData<T> mVoMetaData;
    private SSMap mTooltipMap = new SSMap();
    private static final String NO_CASE_SPECIFICATION = "NoCaseSpecification";

    public FormBinder( FormEngine pFE, VoMetaData<T> pVoMetaData )
    {
        UtilsCommon.assertNotNull( "FormEngine", mFE = pFE );
        UtilsCommon.assertNotNull( "VoMetaData", mVoMetaData = pVoMetaData );
    }

    public T getObject()
    {
        return mObject;
    }

    public void setExistingObject( T pObject, FormEngine.Mode pMode )
    {
        mFE.setMode( pMode );
        updateExistingObject( pObject );
    }

    public void updateExistingObject( T pObject )
    {
        UtilsCommon.assertNotNull( "Object", mObject = pObject );
        if ( FormEngine.Mode.NewFromSearch.equals( mFE.getMode() ) )
        {
            mFE.setMode( FormEngine.Mode.EditFromSearch );
        }
        populateForm();
    }

    public void setNewObject( T pObject )
    {
        UtilsCommon.assertNotNull( "Object", mObject = pObject );
        mFE.setMode( FormEngine.Mode.NewFromSearch );
    }

    private void populateForm()
    {
        List<String> zNames = getAppropriateNames();
        for ( String zName : zNames )
        {
            Object zValue = mObject.getAttributeValue( zName );
            mFE.setNamedComponentValue( zName, zValue );
        }
        mFE.resetForm();
    }

    public void commitForm()
    {
        if ( mObject == null )
        {
            throw new IllegalStateException( "No Object currently bound to Form" );
        }
        List<String> zNames = getAppropriateNames();
        for ( String zName : zNames )
        {
            Object zValue = mFE.getNamedComponentValue( zName );
            mObject.setAttributeValue( zName, zValue );
        }
    }

    private List<String> getAppropriateNames()
    {
        List<String> zNames = new ArrayList<String>();
        Set<String> zFormNames = mFE.getNamedComponentNames();
        for ( String zName : mObject.getBoMetaData().getAttributeNames() )
        {
            if ( zFormNames.contains( zName ) )
            {
                zNames.add( zName );
            }
        }
        return zNames;
    }

    public Widget add( String pAttibuteName )
    {
        return add( pAttibuteName, null, null );
    }

    public Widget add( String pAttibuteName, boolean pViewOnly )
    {
        return add( pAttibuteName, pViewOnly, null, null );
    }

    public Widget add( String pAttibuteName, String pLabelOveride )
    {
        return add( pAttibuteName, null, pLabelOveride );
    }

    public Widget add( String pAttibuteName, boolean pViewOnly, String pLabelOveride )
    {
        return add( pAttibuteName, pViewOnly, null, pLabelOveride );
    }

    public Widget add( String pAttibuteName, Integer pDisplayWidthOveride )
    {
        return add( pAttibuteName, pDisplayWidthOveride, null );
    }

    public Widget add( String pAttibuteName, boolean pViewOnly, Integer pDisplayWidthOveride )
    {
        return add( pAttibuteName, pViewOnly, pDisplayWidthOveride, null );
    }

    public Widget add( String pAttibuteName, Integer pDisplayWidthOveride, String pLabelOveride )
    {
        return add( pAttibuteName, false, pDisplayWidthOveride, pLabelOveride );
    }

    public Widget add( String pAttibuteName, boolean pViewOnly, Integer pDisplayWidthOveride, String pLabelOveride )
    {
        String zLabel = UtilsCommon.noEmpty( (pLabelOveride != null) ? pLabelOveride : DeCamelizer.resolve( pAttibuteName ) );

        BoAttribute zAttribute = mVoMetaData.getBoAttribute( pAttibuteName );

        if ( zAttribute instanceof SimpleVoAttribute )
        {
            SimpleVoAttribute zSA = (SimpleVoAttribute) zAttribute;
            AttributeMetaData zAMD = zSA.getMetaData();
            switch ( zAMD.getType() )
            {
                case Boolean:
                    return addBoolean( zSA, pViewOnly, zLabel );
                case Float:
                    break;
                case Integer:
                    return addInteger( zSA, pViewOnly, pDisplayWidthOveride, zLabel );
                case Long:
                    return addLong( zSA, pViewOnly, pDisplayWidthOveride, zLabel );
                case Password:
                    return addPassword( zSA, pViewOnly, pDisplayWidthOveride, zLabel );
                case Primitive_boolean:
                    break;
                case Primitive_int:
                    break;
                case SimpleDate:
                    return addSimpleDate( zSA, pViewOnly, zLabel );
                case SimpleFixedPointLong:
                    break;
                case SimpleFloatingPointLong:
                    break;
                case SimpleMoney:
                    return addSimpleMoney( zSA, pViewOnly, pDisplayWidthOveride, zLabel );
                case SimpleTime:
                    break;
                case SimpleTimestamp:
                    break;
                case String:
                    return addString( zSA, pViewOnly, pDisplayWidthOveride, zLabel );
                case Text:
                    return addText( zSA, pViewOnly, pDisplayWidthOveride, zLabel );
                case TextLines:
                    break;
                case ValidOptions:
                    return addValidOptions( zSA, pViewOnly, pDisplayWidthOveride, zLabel );
                default:
                    break;
            }
            throw new UnsupportedOperationException( "Auto-Component generation not currently supported for " + zAMD.getType() );
        }

        throw new UnsupportedOperationException( "Auto-Component generation not currently supported for " + zAttribute );
    }

    private Widget addBoolean( SimpleVoAttribute pAttribute, boolean pViewOnly, String pLabel )
    {
        String zName = pAttribute.getName();
        AbstractFormElement zFormElement = new FormCheckBox( adjustLabelUnique( pAttribute, pLabel, pViewOnly ), null, //
                                                             mTooltipMap.get( zName ), false );
        if ( pViewOnly )
        {
            zFormElement = disable( zFormElement );
        }
        return mFE.add( zName, zFormElement );
    }

    private Widget addInteger( SimpleVoAttribute pAttribute, boolean pViewOnly, Integer pDisplayWidthOveride, String pLabel )
    {
        AttributeMetaData zAMD = pAttribute.getMetaData();
        return add( pAttribute, pViewOnly, //
                    new FormRightAlignTextField( adjustLabel( pAttribute, pLabel, pViewOnly ), null, mTooltipMap.get( pAttribute.getName() ), //
                                                 positiveOverride( pDisplayWidthOveride, DisplayLength.get( zAMD ) ), //
                                                 positiveOnly( MaxLength.get( zAMD ) ) ) );
    }

    private Widget addLong( SimpleVoAttribute pAttribute, boolean pViewOnly, Integer pDisplayWidthOveride, String pLabel )
    {
        AttributeMetaData zAMD = pAttribute.getMetaData();
        return add( pAttribute, pViewOnly, //
                    new FormRightAlignTextField( adjustLabel( pAttribute, pLabel, pViewOnly ), null, mTooltipMap.get( pAttribute.getName() ), //
                                                 positiveOverride( pDisplayWidthOveride, DisplayLength.get( zAMD ) ), //
                                                 positiveOnly( MaxLength.get( zAMD ) ) ) );
    }

    protected Widget addPassword( SimpleVoAttribute pAttribute, boolean pViewOnly, Integer pDisplayWidthOveride, String pLabel )
    {
        AttributeMetaData zAMD = pAttribute.getMetaData();
        return add( pAttribute, pViewOnly, //
                    new FormPasswordField( adjustLabel( pAttribute, pLabel, pViewOnly ), null, mTooltipMap.get( pAttribute.getName() ), //
                                           positiveOverride( pDisplayWidthOveride, DisplayLength.get( zAMD ) ), //
                                           positiveOnly( MaxLength.get( zAMD ) ) ) );
    }

    private static DateFormatControl sDFC = null;

    private Widget addSimpleDate( SimpleVoAttribute pAttribute, boolean pViewOnly, String pLabel )
    {
        String zFieldLabel = adjustLabel( pAttribute, pLabel, pViewOnly );
        String zTooltip = mTooltipMap.get( pAttribute.getName() );

        if ( pViewOnly )
        {
            return add( pAttribute, pViewOnly, new FormTextField( zFieldLabel, null, zTooltip, 12, 12 ) );
        }
        if ( sDFC == null )
        {
            sDFC = new DateFormatControl( DateFormatControl.DEFAULT_DATE_FORMAT );
        }
        return add( pAttribute, pViewOnly, new FormDatePicker( zFieldLabel, null, zTooltip, "Cancel", "Today", sDFC ) );
    }

    private Widget addSimpleMoney( SimpleVoAttribute pAttribute, boolean pViewOnly, Integer pDisplayWidthOveride, String pLabel )
    {
        AttributeMetaData zAMD = pAttribute.getMetaData();
        return add( pAttribute, pViewOnly, //
                    new FormRightAlignTextField( adjustLabel( pAttribute, pLabel, pViewOnly ), null, mTooltipMap.get( pAttribute.getName() ), //
                                                 positiveOverride( pDisplayWidthOveride, DisplayLength.get( zAMD ) ), //
                                                 positiveOnly( MaxLength.get( zAMD ) ) ) );
    }

    private Widget addString( SimpleVoAttribute pAttribute, boolean pViewOnly, Integer pDisplayWidthOveride, String pLabel )
    {
        String zName = pAttribute.getName();

        AttributeMetaData zAMD = pAttribute.getMetaData();

        FormTextField zTextField = new FormTextField( adjustLabel( pAttribute, pLabel, pViewOnly ), null, mTooltipMap.get( zName ), //
                                                      positiveOverride( pDisplayWidthOveride, DisplayLength.get( zAMD ) ), //
                                                      positiveOnly( MaxLength.get( zAMD ) ) );

        if ( !pViewOnly && Case.Form.AsEntered.equals( Case.get( zAMD ) ) && mFE.isSearchFilter( zName ) )
        {
            zTextField.addStyleName( NO_CASE_SPECIFICATION );
        }
        return add( pAttribute, pViewOnly, zTextField );
    }

    private Widget addText( SimpleVoAttribute pAttribute, boolean pViewOnly, Integer pDisplayWidthOveride, String pLabel )
    {
        AttributeMetaData zAMD = pAttribute.getMetaData();
        return add( pAttribute, pViewOnly, //
                    new FormTextarea( adjustLabel( pAttribute, pLabel, pViewOnly ), null, mTooltipMap.get( pAttribute.getName() ), false, //
                                      positiveOverride( pDisplayWidthOveride, DisplayWidthInitial.get( zAMD ) ), false, //
                                      positiveOnly( DisplayHeightInitial.get( zAMD ) ), false ) );
    }

    private Widget addValidOptions( SimpleVoAttribute pAttribute, boolean pViewOnly, Integer pDisplayWidthOveride, String pLabel )
    {
        AttributeMetaData zAMD = pAttribute.getMetaData();
        String zName = pAttribute.getName();
        if ( pViewOnly )
        {
            return mFE.add( zName, disable( new FormTextField( pLabel, null, mTooltipMap.get( zName ), //
                                                               positiveOverride( pDisplayWidthOveride, Options.getLength( zAMD ) ), //
                                                               Options.getLength( zAMD ) ) ) );
        }
        String[] zOptions = Options.get( zAMD );
        pLabel = adjustLabelUnique( pAttribute, pLabel, false );
        if ( !pAttribute.isRequired() )
        {
            return mFE.add( zName, new FormComboBox( pLabel, null, mTooltipMap.get( zName ), "" ).addItems( zOptions ) );
        }
        if ( zOptions.length <= 3 )
        {
            return mFE.add( zName, new FormRadioGroup( pLabel, null, mTooltipMap.get( zName ), zOptions ) );
        }
        return mFE.add( zName, new FormComboBox( pLabel, null, mTooltipMap.get( zName ) ).addItems( zOptions ) );
    }

    private Widget add( SimpleVoAttribute pAttribute, boolean pViewOnly, AbstractFormElement pFormElement )
    {
        boolean zRequired = pAttribute.isRequired();
        if ( pViewOnly )
        {
            zRequired = false;
            pFormElement = disable( pFormElement );
        }
        return mFE.add( pAttribute.getName(), zRequired, pFormElement );
    }

    private AbstractFormElement disable( AbstractFormElement pField )
    {
        pField.setEnabled( false );
        return pField;
    }

    public FormBinder addTooltip( String pAttributeName, String pTooltip )
    {
        return UtilsCommon.isNotNullOrEmpty( pTooltip ) ? LLaddTooltip( pAttributeName, pTooltip ) : this;
    }

    private FormBinder LLaddTooltip( String pAttributeName, String pTooltip )
    {
        mTooltipMap.put( pAttributeName, pTooltip );
        return this;
    }

    private String adjustLabel( VoAttribute pAttribute, String pLabel, boolean pViewOnly )
    {
        if ( !pViewOnly && (pLabel != null) )
        {
            if ( isUnique( pAttribute ) )
            {
                return pLabel + LABEL_EXTENSION_UNIQUE;
            }
            if ( pAttribute.isRequired() || mFE.isEditRequired( pAttribute.getName() ) )
            {
                return pLabel + LABEL_EXTENSION_REQUIRED;
            }
        }
        return pLabel;
    }

    private String adjustLabelUnique( BoAttribute pAttribute, String pLabel, boolean pViewOnly )
    {
        return (!pViewOnly && (pLabel != null) && isUnique( pAttribute )) ? pLabel + LABEL_EXTENSION_UNIQUE : pLabel;
    }

    private boolean isUnique( BoAttribute pAttribute )
    {
        return mFE.isUnique( pAttribute.getName() );
    }

    private Integer positiveOverride( Integer pOveride, Integer pAttribute )
    {
        return positiveOnly( (pOveride != null) ? pOveride : pAttribute );
    }

    private Integer positiveOnly( Integer pValue )
    {
        return ((pValue != null) && (pValue > 0)) ? pValue : null;
    }
}