package org.litesoft.GWT.client.nonpublic;

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.widgets.*;
import org.litesoft.GWT.client.widgets.nonpublic.*;
import org.litesoft.GWT.client.widgets.nonpublic.external.*;
import org.litesoft.core.delayed.*;
import org.litesoft.core.util.*;

import com.google.gwt.event.shared.*;
import com.google.gwt.user.client.*;
import com.google.gwt.user.client.Event.*;
import com.google.gwt.user.client.ui.*;
import com.google.gwt.widgetideas.client.*;

public abstract class AbstractDialog extends PopupPanel // PopupPanel is a SimplePanel
        implements Dialog,
                   UiPositionAndSizeAdjustable
{
    private static final String TOP = "Top";
    private static final String LEFT = "Left";
    private static final String RIGHT = "Right";
    private static final String BOTTOM = "Bottom";

    protected String mDefaultTitle;
    private Opaqueness mOpaqueness;

    private AbstractFloaterPanel mOuterPanel;
    private DialogCloseCallBack mCloseCallBack = null;
    protected boolean mShowing = false;
    private int mMinimumMarginWidth = 1;
    private int mMinimumMarginHeight = 1;
    private boolean mMaximize = false;

    public AbstractDialog( String pDefaultTitle, Opaqueness pOpaqueness )
    {
        super( false, true );

        mDefaultTitle = pDefaultTitle;
        mOpaqueness = (pOpaqueness != null) ? pOpaqueness : Opaqueness.Full;
    }

    private void setBorder( Grid pGrid, int pRow, String pRowClass, int pCol, String pColClass )
    {
        TransparentImage zWidget = new TransparentImage();
        pGrid.setWidget( pRow, pCol, zWidget );
        Element zParent = DOM.getParent( zWidget.getElement() );
        CommonElementHelper.setStyleClass( zParent, "litesoft-DialogOuterBorder" + pColClass + pRowClass );
    }

    private void setBorderRow( Grid pGrid, int pRow, String pRowClass )
    {
        setBorder( pGrid, pRow, pRowClass, 0, LEFT );
        setBorder( pGrid, pRow, pRowClass, 1, "" );
        setBorder( pGrid, pRow, pRowClass, 2, RIGHT );
    }

    public AbstractDialog initialize( String pTitle, DialogCloseCallBack pCloseCallBack )
    {
        mCloseCallBack = pCloseCallBack;
        mOuterPanel = new FloaterPanelBody( this );
        Grid zGrid = new TightGrid( 3, 3 );
        setBorderRow( zGrid, 0, TOP );
        setBorder( zGrid, 1, "", 0, LEFT );
        zGrid.setWidget( 1, 1, mOuterPanel );
        setBorder( zGrid, 1, "", 2, RIGHT );
        setBorderRow( zGrid, 2, BOTTOM );
        setWidget( zGrid );

        mOuterPanel.setTitleBar( new CloseableFloaterPanelTitleBar( "Dialog", UtilsGwt.deEmpty( pTitle, mDefaultTitle ), new HideCommand() ) );
        mOuterPanel.setWidget( createBodyPanel() );

        return this;
    }

    @Override
    public String getTitle()
    {
        return mOuterPanel.getTitle();
    }

    @Override
    public void setTitle( String pTitle )
    {
        if ( null != (pTitle = UtilsCommon.noEmpty( pTitle )) )
        {
            mOuterPanel.setTitle( pTitle );
        }
    }

    abstract protected Widget createBodyPanel();

    public int getMinimumMarginWidth()
    {
        return mMinimumMarginWidth;
    }

    public void setMinimumMarginWidth( int pMinimumMarginWidth )
    {
        mMinimumMarginWidth = pMinimumMarginWidth;
    }

    public int getMinimumMarginHeight()
    {
        return mMinimumMarginHeight;
    }

    public void setMinimumMarginHeight( int pMinimumMarginHeight )
    {
        mMinimumMarginHeight = pMinimumMarginHeight;
    }

    public void setMinimumMargin( int pHeight, int pWidth )
    {
        setMinimumMarginHeight( pHeight );
        setMinimumMarginWidth( pWidth );
    }

    public void setMaximize()
    {
        mMaximize = true;
    }

    @Override
    public void setWidth( String width )
    {
//        super.setWidth( width );
        mOuterPanel.setWidth( width );
    }

    @Override
    public void setHeight( String height )
    {
//        super.setHeight( height );
        mOuterPanel.setHeight( height );
    }

    @Override
    public void show()
    {
        if ( !mShowing )
        {
            mShowing = true;
            DeferredCommand.addCommand( new Command()
            {
                public void execute()
                {
                    showDeferred();
                }
            } );
        }
    }

    private void showDeferred()
    {
        addGlassPane();
        setVisible( false );
        setAnimationEnabled( false );
        if ( mMaximize )
        {
            mOuterPanel.setWidth( "" + (Window.getClientWidth() - (mMinimumMarginWidth + mMinimumMarginWidth)) );
            mOuterPanel.setHeight( "" + (Window.getClientHeight() - (mMinimumMarginHeight + mMinimumMarginHeight)) );
        }
        super.show();
        final HandlerRegistration[] previewRegistration = new HandlerRegistration[1];
        previewRegistration[0] = Event.addNativePreviewHandler( new NativePreviewHandler()
        {
            public void onPreviewNativeEvent( NativePreviewEvent pEvent )
            {
                if ( pEvent.getTypeInt() == Event.ONMOUSEOUT )
                {
                    pEvent.consume(); // direct to continue propagation
                    previewRegistration[0].removeHandler();
                }
            }
        } );
        mOuterPanel.relayout();
        TimedRunnableManager.INSTANCE.runIn( new Centerer(), 20 );
    }

    private void finiShowCenter()
    {
        int zClientWidth = Window.getClientWidth();
        int zClientHeight = Window.getClientHeight();

        int zDialogWidth = mOuterPanel.getOffsetWidth();
        int zDialogHeight = mOuterPanel.getOffsetHeight();

        int zActualWidth = getOffsetWidth();
        int zActualHeight = getOffsetHeight();

        int zMaxWidth = zClientWidth - (mMinimumMarginWidth + mMinimumMarginWidth);
        if ( zDialogWidth > zMaxWidth )
        {
            mOuterPanel.setWidth( "" + zMaxWidth );
            zActualWidth -= zDialogWidth - zMaxWidth;
        }
        int zMaxHeight = zClientHeight - (mMinimumMarginHeight + mMinimumMarginHeight);
        if ( zDialogHeight > zMaxHeight )
        {
            setHeight( "" + zMaxHeight );
            zActualHeight -= zDialogHeight - zMaxHeight;
        }

        int left = (zClientWidth - zActualWidth) >> 1;
        int top = (zClientHeight - zActualHeight) >> 1;
        setPopupPosition( Window.getScrollLeft() + left, Window.getScrollTop() + top );

        setVisible( true );
    }

    private class Centerer implements TimedRunnable
    {
        private boolean mSizingPending = true;

        public Again runOnce()
        {
            if ( mSizingPending )
            {
                mSizingPending = mOuterPanel.isSizingPending();
                return new RunAgainIn( 20 );
            }
            finiShowCenter();
            return null;
        }
    }

    @Override
    public void hide()
    {
        if ( mShowing )
        {
            mShowing = false;
            super.hide();
            removeGlassPane();
            if ( mCloseCallBack != null )
            {
                mCloseCallBack.dialogClosed();
            }
        }
    }

    public boolean adjustWidthBy( int pDelta )
    {
        return mOuterPanel.adjustWidthBy( pDelta );
    }

    public boolean adjustHeightBy( int pDelta )
    {
        return mOuterPanel.adjustHeightBy( pDelta );
    }

    public void setPosition( int pLeft, int pTop )
    {
        setPosLeft( pLeft );
        setPosTop( pTop );
    }

    public void setPosLeft( int pPosLeft )
    {
        DOM.setStyleAttribute( getElement(), "left", pPosLeft + "px" );
    }

    public void setPosTop( int pPosTop )
    {
        DOM.setStyleAttribute( getElement(), "top", pPosTop + "px" );
    }

    public int getPosLeft()
    {
        return parse( DOM.getStyleAttribute( getElement(), "left" ) );
    }

    public int getPosTop()
    {
        return parse( DOM.getStyleAttribute( getElement(), "top" ) );
    }

    public int minPosLeft()
    {
        return 0;
    }

    public int minPosTop()
    {
        return 0;
    }

    public int maxPosLeft()
    {
        return WindowSizingPanel.width - getOffsetWidth();
    }

    public int maxPosTop()
    {
        return WindowSizingPanel.height - getOffsetHeight();
    }

    private int parse( String pSize_1D )
    {
        try
        {
            return AbstractSizeableWidget.parse( pSize_1D );
        }
        catch ( NumberFormatException e )
        {
            return -9999;
        }
    }

    private static class FloaterPanelBody extends AbstractFloaterPanel
    {
        private UiPositionAndSizeAdjustable mPopupWrapper;

        public FloaterPanelBody( UiPositionAndSizeAdjustable pPopupWrapper )
        {
            super( "Dialog" );
            mPopupWrapper = pPopupWrapper;

            mTitleBarPanel.addController( mDragController = createTitleBarDragController( pPopupWrapper ) );

            finishContainerTable( pPopupWrapper );
        }

        private DragController createTitleBarDragController( UiPositionable pUiPositionable )
        {
            return createDragController( createThresholdFilter( createTitleBarDragGesture( pUiPositionable ) ) );
        }

        @Override
        protected DragController createBorderDragController( DragGesture pResizer )
        {
            return createDragController( createThresholdFilter( pResizer ) );
        }

        public void setPosLeft( int pPosLeft )
        {
            mPopupWrapper.setPosLeft( pPosLeft );
        }

        public void setPosTop( int pPosTop )
        {
            mPopupWrapper.setPosTop( pPosTop );
        }

        public int getPosLeft()
        {
            return mPopupWrapper.getPosLeft();
        }

        public int getPosTop()
        {
            return mPopupWrapper.getPosTop();
        }

        public int minPosLeft()
        {
            return mPopupWrapper.minPosLeft();
        }

        public int minPosTop()
        {
            return mPopupWrapper.minPosTop();
        }

        public int maxPosLeft()
        {
            return mPopupWrapper.maxPosLeft();
        }

        public int maxPosTop()
        {
            return mPopupWrapper.maxPosTop();
        }
    }

    private GlassPanel mGlassPanel = null;

    private void addGlassPane()
    {
        removeGlassPane();
        mGlassPanel = new GlassPanel( false );
        mGlassPanel.addStyleName( "DialogGlassPaneOpaqueness" + mOpaqueness );
        RootPanel.get().add( mGlassPanel, 0, 0 );
    }

    private void removeGlassPane()
    {
        if ( mGlassPanel != null )
        {
            mGlassPanel.removeFromParent();
            mGlassPanel = null;
        }
    }

    public class CancelButton extends RedButton
    {
        public CancelButton()
        {
            super( "Cancel", new HideCommand() );
        }
    }

    public class HideCommand implements Command
    {
        public void execute()
        {
            hide();
        }
    }
}