// This Source Code is in the Public Domain per: http://unlicense.org
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.commonfoundation.typeutils.*;
import org.litesoft.core.delayed.*;

import com.google.gwt.core.client.*;
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;
    }

    public boolean isCancelable() {
        return true;
    }

    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 );

        HideCommand zCloseCommand = isCancelable() ? new HideCommand() : null;
        mOuterPanel.setTitleBar( new CloseableFloaterPanelTitleBar( "Dialog", Strings.deEmpty( pTitle, mDefaultTitle ), zCloseCommand ) );
        mOuterPanel.setWidget( createBodyPanel() );

        return this;
    }

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

    @Override
    public void setTitle( String pTitle ) {
        if ( null != (pTitle = Strings.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;
            Scheduler.get().scheduleDeferred( new Command() {
                @Override
                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() {
            @Override
            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;

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

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

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

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

    @Override
    public void setPosLeft( int pPosLeft ) {
        CommonElementHelper.setLeft( getElement(), pPosLeft );
    }

    @Override
    public void setPosTop( int pPosTop ) {
        CommonElementHelper.setTop( getElement(), pPosTop );
    }

    @Override
    public int getPosLeft() {
        return parse( getElement().getStyle().getLeft() );
    }

    @Override
    public int getPosTop() {
        return parse( getElement().getStyle().getTop() );
    }

    @Override
    public int minPosLeft() {
        return 0;
    }

    @Override
    public int minPosTop() {
        return 0;
    }

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

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

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

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

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

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

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

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

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

        @Override
        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 HideCommand implements Command {
        @Override
        public void execute() {
            hide();
        }
    }
}