package org.litesoft.GWT.client.widgets;

import com.google.gwt.user.client.*;
import com.google.gwt.user.client.ui.*;
import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.widgets.nonpublic.*;
import org.litesoft.core.simpletypes.*;
import org.litesoft.core.util.*;
import org.litesoft.uipopupsupport.*;

public abstract class AbstractContextPopup extends PopupPanel
{
    private static final String ERROR_FROM = "AbstractContextPopup";

    protected AbstractContextPopup( boolean pAutoHide )
    {
        super( pAutoHide );
    }

    protected AbstractContextPopup( boolean autoHide, PopupListener pListener )
    {
        this( autoHide );
        if ( pListener != null )
        {
            addPopupListener( pListener );
        }
    }

    protected void error( String pProblem, RuntimeException pRTE )
    {
        AlertManager.alert( ERROR_FROM, "Contextual Options Error", pProblem, pRTE );
    }

    abstract protected Widget createPopupWidget();

    /**
     * Show the Context Popup, positioning it based on the pEvent's Client X & Y positions, and
     * the two provided Relative Rectangular "meeting" Points.
     *
     * @param pEvent                        !null - used to get the Target (Source) Element & the Mouse
     *                                      location (Client X & Y)
     * @param pRectangleContainmentStrategy !null - Controls Popup location should any of the Popup be off screen.
     * @param pSourceElementRelativeMeetingPoint
     *                                      if not null then indicates to use the clicked on element's
     *                                      location, size, and this "point" as the "meeting" point
     * @param pPopupRelativeMeetingPoint    the Popup's "meeting" point.  null defaults to "CornerTopLeft"
     */
    public void showContextPopup( Event pEvent, //
                                  RectangleContainmentStrategy pRectangleContainmentStrategy,
                                  CommonRectangularPoint pSourceElementRelativeMeetingPoint,
                                  CommonRectangularPoint pPopupRelativeMeetingPoint )
    {
        Widget zWidget;
        try
        {
            if ( null == (zWidget = createPopupWidget()) )
            {
                error( "No Widget", null );
                return;
            }
        }
        catch ( RuntimeException e )
        {
            error( e.getMessage(), e );
            return;
        }

        setWidget( zWidget );

        setPopupPositionAndShow( new MyPositionCallback( pRectangleContainmentStrategy,
                                                         pSourceElementRelativeMeetingPoint, pEvent,
                                                         (pPopupRelativeMeetingPoint != null) ? //
                                                         pPopupRelativeMeetingPoint : //
                                                         CommonRectangularPoint.LeftTop ) );
    }

    public void show()
    {
        super.show();
        mSavedCaptureElement = DOM.getCaptureElement();
        if ( mSavedCaptureElement != null )
        {
            DOM.releaseCapture( mSavedCaptureElement );
        }
    }

    private Element mSavedCaptureElement = null;

    public void hide()
    {
        if ( mSavedCaptureElement != null )
        {
            DOM.setCapture( mSavedCaptureElement );
            mSavedCaptureElement = null;
        }
        super.hide();
    }

    private class MyPositionCallback implements PositionCallback
    {
        private ContextPopupPositioner mPositioner;

        public MyPositionCallback( RectangleContainmentStrategy pRectangleContainmentStrategy,
                                   CommonRectangularPoint pSourceElementRelativeMeetingPoint, Event pEvent,
                                   CommonRectangularPoint pPopupRelativeMeetingPoint )
        {
            SizeXY zClientSize = new SizeXY( Window.getClientWidth(), Window.getClientHeight() );
            PointXY zClientPos = new PointXY( DOM.eventGetClientX( pEvent ), DOM.eventGetClientY( pEvent ) );

            if ( pSourceElementRelativeMeetingPoint == null )
            {
                mPositioner = new ContextPopupPositioner( pRectangleContainmentStrategy,
                                                          pPopupRelativeMeetingPoint,//
                                                          zClientPos, zClientSize );
            }
            else
            {
                Element zTargetElement = DOM.eventGetTarget( pEvent );
                int zSrcElementXpos = DOM.getAbsoluteLeft( zTargetElement );
                int zSrcElementYpos = DOM.getAbsoluteTop( zTargetElement );
                int zSrcElementXsize = CommonElementHelper.getOffsetWidth( zTargetElement );
                int zSrcElementYsize = CommonElementHelper.getOffsetHeight( zTargetElement );
                Rect zSourceElementRect = new Rect( zSrcElementXpos, zSrcElementYpos, //
                                                    zSrcElementXsize, zSrcElementYsize );
                mPositioner = new SourceRelativeContextPopupPositioner( pRectangleContainmentStrategy,
                                                                        pPopupRelativeMeetingPoint,
                                                                        zClientPos, zClientSize,
                                                                        pSourceElementRelativeMeetingPoint,
                                                                        zSourceElementRect );
            }
        }

        public String toString()
        {
            return mPositioner.toString();
        }

        public void setPosition( int pPopupXsize, int pPopupYsize )
        {
            adjustPopup( mPositioner.determinePosition( new Rect( 0, 0, pPopupXsize, pPopupYsize ) ) );
        }

        protected void adjustPopup( Rect pRect )
        {
            setPopupPosition( pRect.getXpos(), pRect.getYpos() );
        }
    }
}