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

import org.litesoft.GWT.client.widgets.*;
import org.litesoft.GWT.forms.client.components.*;
import org.litesoft.uispecification.*;

import com.google.gwt.event.dom.client.*;
import com.google.gwt.event.logical.shared.*;
import com.google.gwt.user.client.*;
import com.google.gwt.user.client.ui.*;

public abstract class AbstractTextFieldWithPicker extends AbstractTextField
{
    protected DialogBox mPicker;
    private boolean mBlurring = false;
    private boolean mPicking = false;
    private PickerImageButton mPickerButton = null;
    private String mPickerButtonName;

    public AbstractTextFieldWithPicker( String pTooltip, boolean pMixedSizeChars, int pWidth, //
                                        String pPickerButtonName, DialogBox pPicker )
    {
        super( pTooltip, pMixedSizeChars, pWidth, pWidth + 1 );
        mPickerButtonName = pPickerButtonName;
        (mPicker = pPicker).addCloseHandler( new CloseHandler<PopupPanel>()
        {
            public void onClose( CloseEvent<PopupPanel> event )
            {
                pickerClosed( event.isAutoClosed() );
            }
        } );
    }

    protected int buildComponentPanel( String pLabel, UiFont pLabelFont )
    {
        int zUniqueID = super.buildComponentPanel( pLabel, pLabelFont );
        mInnerHTMLpanel.add( (mPickerButton = createPickerButton()), "cal_" + zUniqueID );
        return zUniqueID;
    }

    protected String buildInputRow( String pTrId, String pInputId, int pUniqueID )
    {
        return buildInputRowWithOptionalCell( pTrId, pInputId, "<td><div class='litesoft-PickerButtonContainer' id='cal_" + pUniqueID + "'></div></td>" );
    }

    protected PickerImageButton createPickerButton()
    {
        final PickerImageButton button = new PickerImageButton( mPickerButtonName, null );

        button.addClickHandler( new ClickHandler()
        {
            public void onClick( ClickEvent event )
            {
                int absoluteLeft = button.getAbsoluteLeft();
                int absoluteTop = button.getAbsoluteTop();

                Object currentValue = getCurrentValue();
                showPicker( absoluteLeft, absoluteTop, currentValue, mLastValidInternalFormValue );
            }
        } );

        button.setTabIndex( -1 );

        button.addFocusHandler( this );
        button.addBlurHandler( this );

        return button;
    }

    public void setEnabled( boolean pEnabled )
    {
        if ( mPickerButton != null )
        {
            mPickerButton.setEnabled( pEnabled );
        }
        super.setEnabled( pEnabled );
    }

    protected void setCursor()
    {
        TextBox textfield = getTextBox();
        textfield.setFocus( true );
        int length = textfield.getText().length();
        textfield.setCursorPos( length );
    }

    protected void setTextValueFromPicker( String pFromPicker )
    {
        if ( !getCurrentText().equals( pFromPicker ) )
        {
            setCurrentText( pFromPicker );
            fireChangeListeners();
        }
    }

    protected void fireChangeListeners()
    {
        mInternalFormValid = false;
        super.fireChangeListeners();
    }

    private boolean mInternalFormValid = false;
    private Object mInternalFormValue = null;
    private Object mLastValidInternalFormValue = null;

    abstract protected Object parseNotEmptyTextFieldToInternalForm( String pText, Object pLastValidInternalFormValue )
            throws IllegalArgumentException;

    public Object getCurrentValue()
    {
        if ( !mInternalFormValid )
        {
            Object zInternalFormValue = null;
            String currentText = getCurrentText();
            if ( currentText.length() != 0 )
            {
                try
                {
                    zInternalFormValue = parseNotEmptyTextFieldToInternalForm( currentText, mLastValidInternalFormValue );
                }
                catch ( IllegalArgumentException e )
                {
                    return new FormTextInputErrorValue( currentText, e.getMessage() );
                }
            }
            mLastValidInternalFormValue = mInternalFormValue = zInternalFormValue;
            mInternalFormValid = true;
        }
        return mInternalFormValue;
    }

    public void setCurrentValue( Object pNewValue )
    {
        if ( pNewValue instanceof String )
        {
            mInternalFormValid = false;
            setCurrentText( pNewValue.toString() ); // this line and
            getCurrentValue(); // .................... this one are are doing reformatting/validation!
            return;
        }
        mLastValidInternalFormValue = mInternalFormValue = pNewValue;
        mInternalFormValid = true;
        setCurrentText( (pNewValue == null) ? "" : pNewValue.toString() );
    }

    private void show( String pMsg, Object pSender )
    {
        if ( LOGGER.trace.isEnabled() )
        {
            LLshow( pMsg + "(" + simpleClassname( pSender ) + ")" );
        }
    }

    protected void show( String pMsg, boolean pParam1 )
    {
        if ( LOGGER.trace.isEnabled() )
        {
            LLshow( pMsg + "(" + pParam1 + ")" );
        }
    }

    protected void show( String pMsg )
    {
        if ( LOGGER.trace.isEnabled() )
        {
            LLshow( pMsg );
        }
    }

    private void LLshow( String pMsg )
    {
        LOGGER.trace.log( simpleClassname( this ) + " - " + pMsg + "  [" + mBlurring + ":Blurring-Picking:" + mPicking + "]" );
    }

    public void publishAnyPendingChanges()
    {
        show( "publishAnyPendingChanges" );
        if ( hidePicker() || mBlurring )
        {
            mPicking = false;
            processDefferredBlur();
        }
        super.publishAnyPendingChanges();
    }

    @Override public void onFocus( FocusEvent event ) // TextBox / Button
    {
        show( "onFocus", event.getSource() );
        if ( mBlurring )
        {
            mBlurring = false;
        }
        else
        {
            super.onFocus( event );
        }
    }

    @Override public void onBlur( BlurEvent event ) // TextBox / Button
    {
        show( "onLostFocus", event.getSource() );
        mBlurring = true;
        defferBlur();
    }

    protected void processDefferredBlur()
    {
        show( "defferredBlur" );
        if ( mBlurring && !mPicking )
        {
            mBlurring = false;
            // Attempt to reformat
            Object value = getCurrentValue();
            if ( !(value instanceof String) && !(value instanceof FormTextInputErrorValue) )
            {
                setCurrentValue( value );
            }
            super.onBlur( null );
        }
    }

    protected void defferBlur()
    {
        DeferredCommand.addCommand( new Command()
        {
            public void execute()
            {
                processDefferredBlur();
            }
        } );
    }

    protected void showPicker( int pAbsoluteLeft, int pAbsoluteTop, Object pCurrentValue, Object pLastValidInternalFormValue )
    {
        show( "showPicker" );
        mBlurring = mPicking = true;
        setFocus();
        mPicker.setPopupPositionAndShow( new PopupPanelVisiblePositionCallBack( mPicker, //
                                                                                pAbsoluteLeft, pAbsoluteTop ) );
    }

    protected boolean hidePicker()
    {
        show( "hidePicker" );
        boolean rv = mPicking;
        if ( mPicking )
        {
            mPicker.hide();
        }
        return rv;
    }

    protected void pickerClosed( boolean autoClosed )
    {
        show( "pickerClosed", autoClosed );
        mPicking = false;
        defferBlur();
        if ( !autoClosed )
        {
            setCursor();
        }
    }
}