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

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

import com.google.gwt.core.client.*;
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 Button 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>() {
            @Override
            public void onClose( CloseEvent<PopupPanel> event ) {
                pickerClosed( event.isAutoClosed() );
            }
        } );
    }

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

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

    protected Button createPickerButton() {
        final Button button = PickerButton.factory( mPickerButtonName ).create();

        button.addClickHandler( new ClickHandler() {
            @Override
            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;
    }

    @Override
    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();
        }
    }

    @Override
    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;

    @Override
    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;
    }

    @Override
    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 + "]" );
    }

    @Override
    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;
        deferBlur();
    }

    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 deferBlur() {
        Scheduler.get().scheduleDeferred( new Command() {
            @Override
            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;
        deferBlur();
        if ( !autoClosed ) {
            setCursor();
        }
    }
}