package org.litesoft.GWT.forms.client.components.factories.input;

import java.util.*;

import com.google.gwt.user.client.ui.*;
import org.litesoft.GWT.forms.client.components.factories.*;
import org.litesoft.GWT.forms.client.components.impls.input.*;
import org.litesoft.GWT.forms.client.nonpublic.*;
import org.litesoft.core.simpletypes.*;
import org.litesoft.rpcpassable.*;
import org.litesoft.ui.def.nonpublic.*;
import org.litesoft.ui.def.nonpublic.support.*;
import org.litesoft.uispecification.*;

public class UiComboBoxWidgetFactory implements InputWidgetFactory
{
    public Widget create( FormInstanceComponentHandler pComponentHandler, //
                          UiInputDef pUiDef, AttributeMetaData pMetaData,
                          boolean pHasHorizontalPeer )
    {
        ComboBoxMetaData zMD = (ComboBoxMetaData) pMetaData;

        String zLabelText = !pUiDef.isLabelLess() ? zMD.getExternalText() : null;
        UiFont zLabelFont = pUiDef.getLabelFont();
        String zTooltip = zMD.getTooltip();

        return new MyFormAdapter( pComponentHandler, zMD,
                                  createFormComboBox( zLabelText, zLabelFont, zTooltip ) ).init();
    }

    protected FormComboBox createFormComboBox( String pLabelText, UiFont pLabelFont, String pTooltip )
    {
        return new FormComboBox( pLabelText, pLabelFont, pTooltip );
    }

    private static final class MyFormAdapter extends AbstractFormRequireableAttributeAdapter
    {
        private FormComboBox mFC;
        private SimpleKeyValuePair mOptionZero;
        private SimpleKeyValuePair[] mValidOptions;
        private List<RPCpassable> mNewValidOptions = new ArrayList<RPCpassable>();
        private boolean mHasFocus = false;

        public MyFormAdapter( FormInstanceComponentHandler pComponentHandler, //
                              ComboBoxMetaData pMD, FormComboBox pFC )
        {
            super( pComponentHandler, pMD, pMD, pFC );
            mFC = pFC;
            mFC.addItem( mOptionZero = pMD.getNoSendOptionZero() );
            mFC.addItems( mValidOptions = pMD.getValidOptions() );
        }

        public void updateValidOptions( RPCpassable[] pValidOptions )
        {
            convertOptions( pValidOptions );
            if ( !mHasFocus || mFC.areOptionsAlwaysUpdatable() )
            {
                LLupdateValidOptions();
            }
        }

        private void convertOptions( RPCpassable[] pValidOptions )
        {
            mNewValidOptions.clear();
            if ( pValidOptions != null )
            {
                for ( RPCpassable zValidOption : pValidOptions )
                {
                    SimpleKeyValuePair option = convertOption( zValidOption );
                    if ( option != null )
                    {
                        mNewValidOptions.add( option );
                    }
                }
            }
        }

        private void LLupdateValidOptions()
        {
            if ( !mNewValidOptions.isEmpty() )
            {
                // save the currently select & null it if it is the default option zero
                SimpleKeyValuePair selected = convertOption( mFC.getSelectedKeyValuePair() );

                mFC.setSelectedIndex( -1 );
                
                // Remove all the old options
                for ( SimpleKeyValuePair zValuePair : mValidOptions )
                {
                    mFC.removeItem( zValuePair );
                }
                // Add all the new ones & note if old current selected was found
                mValidOptions = new SimpleKeyValuePair[mNewValidOptions.size()];
                boolean found = false;
                for ( int i = 0; i < mNewValidOptions.size(); i++ )
                {
                    SimpleKeyValuePair option = (SimpleKeyValuePair) mNewValidOptions.get( i );
                    found |= option.equals( selected );
                    mFC.addItem( mValidOptions[i] = option );
                }
                mNewValidOptions.clear();

                setComponentCurrentValue( found ? selected : null );
            }
        }

        protected Object getComponentCurrentValue()
        {
            Object rv = super.getComponentCurrentValue();
            return !areEqual( rv, mOptionZero ) ? rv : null;
        }

        protected void setComponentCurrentValue( Object pCurrentValue )
        {
            if ( pCurrentValue == null )
            {
                pCurrentValue = mOptionZero;
            }
            super.setComponentCurrentValue( pCurrentValue );
        }

        protected RPCpassable convertComponentValueToSendable( Object pValue )
        {
            return !areEqual( pValue, mOptionZero ) ? (RPCpassable) pValue : null;
        }

        protected Object convertSendableToComponentValue( RPCpassable pValue )
        {
            return convertOption( pValue );
        }

        protected String convertComponentValueToString( Object pValue )
        {
            if ( pValue instanceof SimpleKeyValuePair )
            {
                return "@" + ((SimpleKeyValuePair) pValue).getKey();
            }
            return (pValue == null) ? "null" : "?" + pValue;
        }

        protected Object convertStringToComponentValue( String pValue )
        {
            if ( (pValue == null) || pValue.equals( "null" ) )
            {
                return null;
            }
            return pValue.startsWith( "@" ) ? pValue.substring( 1 ) : pValue;
        }

        public void focusOccured()
        {
            super.focusOccured();
            mHasFocus = true;
        }

        public void blurOccurred()
        {
            mHasFocus = false;
            LLupdateValidOptions();
            super.blurOccurred();
        }

        private SimpleKeyValuePair convertOption( RPCpassable pValue )
        {
            if ( pValue == null )
            {
                return null;
            }
            SimpleKeyValuePair rv = (pValue instanceof SimpleKeyValuePair) ? //
                                    (SimpleKeyValuePair) pValue : //
                                    new StringKeyValuePair( pValue.toString() );

            return !areEqual( rv, mOptionZero ) ? rv : null;
        }
    }
}