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

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.widgets.*;
import org.litesoft.GWT.client.widgets.nonpublic.*;
import org.litesoft.GWT.forms.client.components.nonpublic.*;
import org.litesoft.core.simpletypes.*;
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 FormImageSelector extends AbstractFocusWidgetErrorableFormElement implements ISizeableWidget
{
    public static final String NO_IMAGE = "common/images/misc/tmp/NotAvailable.cache.gif";

    protected PopupPanel mPicker;

    private boolean mViewOnly;
    private SizeableDualImage mDualImage = new SizeableDualImage();
    protected IconButton mPickerButton = null;

    protected String mPickerButtonTooltip = "";

    private boolean mBlurring = false;
    private boolean mPicking = false;

    protected ResourceKeyNameURL mCurrentResourceKeyNameURL = null;

    protected ISizeableDimensionHelper mWidthHelper;
    protected ISizeableDimensionHelper mHeightHelper;

    public FormImageSelector( String pFieldLabel, UiFont pLabelFont, String pTooltip, boolean pViewOnly, Integer pInitialWidth, boolean pWidthNotStretchable, Integer pInitialHeight, boolean pHeightNotStretchable )
    {
        super( new MyFocusPanel(), pTooltip, "frmImageSelector", false );
        mViewOnly = pViewOnly;
        mWidthHelper = pWidthNotStretchable ? NullWidthHelper.INSTANCE : new StretchableWidthHelper( this );
        mHeightHelper = pHeightNotStretchable ? NullHeightHelper.INSTANCE : new StretchableHeightHelper( this );

        initialize( pFieldLabel, pLabelFont, pTooltip );

        MyFocusPanel zFocusPanel = (MyFocusPanel) mInputWidget;

        zFocusPanel.add( mDualImage );

        zFocusPanel.addMouseDownHandler( new MouseDownHandler()
        {
            public void onMouseDown( MouseDownEvent event )
            {
                setFocus();
            }
        } );

        if ( pInitialWidth != null )
        {
            mDualImage.setImageWidth( pInitialWidth );
        }
        if ( pInitialHeight != null )
        {
            mDualImage.setImageHeight( pInitialHeight );
        }

        setEnabled( true );
    }

    public ISizeableDimensionHelper getWidthHelper()
    {
        return mWidthHelper;
    }

    public ISizeableDimensionHelper getHeightHelper()
    {
        return mHeightHelper;
    }

    /**
     * Sets the object's width. This width does not include decorations such as
     * border, margin, and padding.
     *
     * @param width the object's new width, in CSS units (e.g. "10px", "1em")
     */
    public void setWidth( String width )
    {
        setDimensionFromWidget( getWidthHelper(), width );
    }

    /**
     * Sets the object's height. This height does not include decorations such as
     * border, margin, and padding.
     *
     * @param height the object's new height, in CSS units (e.g. "10px", "1em")
     */
    public void setHeight( String height )
    {
        setDimensionFromWidget( getHeightHelper(), height );
    }

    protected void setPicker( PopupPanel pPicker )
    {
        (mPicker = pPicker).addCloseHandler( new CloseHandler<PopupPanel>()
        {
            public void onClose( CloseEvent<PopupPanel> event )
            {
                pickerClosed( event.isAutoClosed() );
            }
        } );
    }

    public void simulateUserTextEntry( String pText )
    {
        throw new UnsupportedOperationException( "simulateUserTextEntry on '" + mFieldLabel + "' to:" + pText ); //todo...
    }

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

    @Override public void onFocus( FocusEvent event ) // FocusPanel / Button
    {
        if ( mBlurring )
        {
            mBlurring = false;
        }
        else
        {
            super.onFocus( event );
        }
    }

    @Override public void onBlur( BlurEvent event ) // FocusPanel / Button
    {
        mBlurring = true;
        defferBlur();
    }

    protected void processDefferredBlur()
    {
        if ( mBlurring && !mPicking )
        {
            mBlurring = false;
            super.onBlur( null );
        }
    }

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

    protected void showPicker( int pAbsoluteLeft, int pAbsoluteTop )
    {
        mBlurring = mPicking = true;
        setFocus();
        LLshowPicker( new PointXY( pAbsoluteLeft, pAbsoluteTop ) );
    }

    protected void LLshowPicker( PointXY pPointXY )
    {
        mPicker.setPopupPositionAndShow( new PopupPanelVisiblePositionCallBack( mPicker, //
                                                                                pPointXY.getX(), pPointXY.getY() ) );
    }

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

    protected void pickerClosed( boolean autoClosed )
    {
        if ( !autoClosed )
        {
            setFocus();
        }
        mPicking = false;
        defferBlur();
    }

    public boolean isViewOnly()
    {
        return mViewOnly;
    }

    protected int buildComponentPanel( String pLabel, UiFont pLabelFont )
    {
        int zUniqueID = super.buildComponentPanel( pLabel, pLabelFont );
        if ( !mViewOnly )
        {
            mInnerHTMLpanel.add( mPickerButton = createPickerButton(), "imgPick_" + zUniqueID );
            mPickerButton.addFocusHandler( this );
            mPickerButton.addBlurHandler( this );
        }

        return zUniqueID;
    }

    protected String buildInputRow( String pTrId, String pInputId, int pUniqueID )
    {
        String zAdditionalInputCell =
                mViewOnly ? "" : "<td valign='top'><div class='litesoft-PickerButtonContainer' id='imgPick_" + pUniqueID + "'></div></td>";
        return buildInputRowWithOptionalCell( pTrId, pInputId, zAdditionalInputCell );
    }

    protected String buildInputRowWithOptionalCell( String pTrId, String pInputId, String pAdditionalInputCell )
    {
        return "<tr class='litesoft-FormComponentInputRow'><td id='" + pInputId + "'></td>" + "<td valign='top'>" +
               "<table cellpadding='0' cellspacing='0'><tr id='" + pTrId + "'>" + pAdditionalInputCell + "</tr></table></td></tr>";
    }

    protected void addIndicator( String pTrId )
    {
        if ( !mViewOnly )
        {
            mInnerHTMLpanel.add( mIndicatorTd = new IndicatorTd(), pTrId );
        }
    }

    protected IconButton createPickerButton()
    {
        mPickerButton = new IconButton( "litesoft-IconImagePickerButton" );
        mPickerButton.setTabIndex( -1 );

        mPickerButton.addClickHandler( new ClickHandler()
        {
            public void onClick( ClickEvent event )
            {
                int absoluteLeft = mPickerButton.getAbsoluteLeft();
                int absoluteTop = mPickerButton.getAbsoluteTop();
                showPicker( absoluteLeft, absoluteTop );
            }
        } );

        return mPickerButton;
    }

    public ResourceKeyNameURL getCurrentResourceKeyNameURL()
    {
        return mCurrentResourceKeyNameURL;
    }

    public void setCurrentResourceKeyNameURL( ResourceKeyNameURL pNewResourceKeyNameURL )
    {
        if ( null == (mCurrentResourceKeyNameURL = pNewResourceKeyNameURL) )
        {
            mDualImage.setUrl( NO_IMAGE, "No Image", null );
        }
        else
        {
            mDualImage.setUrl( mCurrentResourceKeyNameURL.getURL(), "" + mCurrentResourceKeyNameURL.getValue(), //
                               new Command()
                               {
                                   public void execute()
                                   {
                                       if ( UtilsGwt.wasAltKeyDownOnCurrentEvent() )
                                       {
                                           UtilsGwt.windowOpen( mDualImage.getUrl(), "", "" );
                                       }
                                   }
                               } );
        }
        fireChangeListeners();
    }

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

    public void relayout()
    {
    }

    private static class MyFocusPanel extends FocusPanel implements IFocusWidget
    {
        private boolean mEnabled = true;

        public boolean isEnabled()
        {
            return mEnabled;
        }

        public void setEnabled( boolean pEnabled )
        {
            mEnabled = pEnabled;
        }
    }

    protected static class NullWidthHelper extends AbstractWidthHelper
    {
        public static final NullWidthHelper INSTANCE = new NullWidthHelper();

        private NullWidthHelper()
        {
            super( false );
        }
    }

    protected static class NullHeightHelper extends AbstractWidthHelper
    {
        public static final NullWidthHelper INSTANCE = new NullWidthHelper();

        private NullHeightHelper()
        {
            super( false );
        }
    }

    private void setDimensionFromWidget( ISizeableDimensionHelper pDimensionHelper, String pSize_1D )
    {
        int zSize_1D;
        try
        {
            zSize_1D = AbstractSizeableWidget.parse( pSize_1D );
        }
        catch ( NumberFormatException e )
        {
            throw new IllegalArgumentException( "Attempt to set" + pDimensionHelper.getWhat() + "( \"" + pSize_1D + "\" ) on " + getClass().getName() );
        }
        pDimensionHelper.deligateSetDimensionFromWidget( zSize_1D );
    }

    private static abstract class AbstractHeightHelper extends AbstractDimensionHelper
    {
        protected AbstractHeightHelper( boolean pStretchable )
        {
            super( pStretchable, HeightDimensionHelper.INSTANCE );
        }
    }

    private static abstract class AbstractWidthHelper extends AbstractDimensionHelper
    {
        protected AbstractWidthHelper( boolean pStretchable )
        {
            super( pStretchable, WidthDimensionHelper.INSTANCE );
        }
    }

    private static class StretchableHeightHelper extends AbstractHeightHelper
    {
        public static final int DUAL_IMAGE_OVERHEAD = 9;

        private FormImageSelector mOurWidget;

        public StretchableHeightHelper( FormImageSelector pOurWidget )
        {
            super( true );
            mOurWidget = pOurWidget;
        }

        public void setDimension( int pDimension )
        {
            setDimension( mOurWidget, pDimension );
        }

        public int getDimension()
        {
            return getDimension( mOurWidget );
        }

        public int getDimensionMaxShrinkability()
        {
            return getDimension( mOurWidget.mDualImage ) - DUAL_IMAGE_OVERHEAD;
        }

        public int getDecorationSize()
        {
            return getDimension() - getDimension( mOurWidget.mDualImage );
        }

        public void deligateSetDimensionFromWidget( int pDimension )
        {
            pDimension -= getDecorationSize();
            if ( pDimension > DUAL_IMAGE_OVERHEAD )
            {
                setDimension( mOurWidget.mDualImage, pDimension );
            }
        }
    }

    private static class StretchableWidthHelper extends AbstractWidthHelper
    {
        public static final int DUAL_IMAGE_OVERHEAD = 9;

        private FormImageSelector mOurWidget;

        public StretchableWidthHelper( FormImageSelector pOurWidget )
        {
            super( true );
            mOurWidget = pOurWidget;
        }

        public void setDimension( int pDimension )
        {
            setDimension( mOurWidget, pDimension );
        }

        public int getDimension()
        {
            return getDimension( mOurWidget );
        }

        public int getDimensionMaxShrinkability()
        {
            return getDimension( mOurWidget.mDualImage ) - DUAL_IMAGE_OVERHEAD;
        }

        public int getDecorationSize()
        {
            return getDimension() - getDimension( mOurWidget.mDualImage );
        }

        public void deligateSetDimensionFromWidget( int pDimension )
        {
            pDimension -= getDecorationSize();
            if ( pDimension > DUAL_IMAGE_OVERHEAD )
            {
                setDimension( mOurWidget.mDualImage, pDimension );
            }
        }
    }
}