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

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

import com.google.gwt.user.client.ui.*;
import com.google.gwt.user.client.*;

public class DockablePanelHelper implements OnBrowserEventListener
{
    public static final int COLLAPSABLE_BAR_SIZE = 9;

    private AbstractSizeableOneDimensionalPanel mDockablePanel;
    private GwtDomDimensionHelper mDimensionHelper;
    private TaskbarHelper mTaskbarHelper;
    private Widget mDecoratedContent;
    private MoveNEWScommands mContextMenu;
    private CommonRectangularPoint mPopupRelativeMeetingPoint;
    private RectangleContainmentStrategy mRectangleContainmentStrategy;
    private String[] mArrows;
    private Image mArrow;
    private int mIndexArrow;

    private boolean mShowing = true;
    private Integer mDecoratedContentSize = null;

    public DockablePanelHelper( AbstractSizeableOneDimensionalPanel pDockablePanel,
                                GwtDomDimensionHelper pDimensionHelper, TaskbarHelper pTaskbarHelper,
                                NEWSposition pPosition, String pSeparatorURL, MoveNEWScommands pContextMenu,
                                AbstractSizeableOneDimensionalPanel pDecoratedContent,
                                AbstractSizeableOneDimensionalPanel pInnerDecoratedContent,
                                AbstractSizeableOneDimensionalPanel pContent,
                                AbstractSizeableOneDimensionalPanel pCollapsableBar,
                                boolean pContentThenCollapsableBar, String pDefaultUrl,
                                CommonRectangularPoint pPopupRelativeMeetingPoint, String[] pArrows,
                                RectangleContainmentStrategy pRectangleContainmentStrategy )
    {
        mDockablePanel = pDockablePanel;
        mDimensionHelper = pDimensionHelper;
        (mTaskbarHelper = pTaskbarHelper).setPosition( pPosition );
        mDecoratedContent = pDecoratedContent;
        mTaskbarHelper.addTo( pContent, pSeparatorURL );
        mContextMenu = pContextMenu;
        mPopupRelativeMeetingPoint = pPopupRelativeMeetingPoint;
        mRectangleContainmentStrategy = pRectangleContainmentStrategy;
        mArrows = pArrows;

        mArrow = new Image( pDefaultUrl );
        mIndexArrow = mArrows[0].equals( pDefaultUrl ) ? 0 : 1;

        pInnerDecoratedContent.add( pContent );
//        pInnerDecoratedContent.add( new SizeableSpacer( 1 ).stretchable() );

        pDecoratedContent.add( new TransparentImage( "TaskBarPreItems" + pPosition ) );
        pInnerDecoratedContent.addStyleName( "taskbar_bg" + pPosition );
        pDecoratedContent.add( pInnerDecoratedContent );
        pDecoratedContent.add( new TransparentImage( "TaskBarPostItems" + pPosition ) );

        pCollapsableBar.addStyleName( "collapsablebar_bg" + pPosition );
        pCollapsableBar.add( new SizeableSpacer( COLLAPSABLE_BAR_SIZE ).stretchable() );
        pCollapsableBar.add( mArrow );
        pCollapsableBar.add( new SizeableSpacer( COLLAPSABLE_BAR_SIZE ).stretchable() );

        if ( pContentThenCollapsableBar )
        {
            mDockablePanel.add( pDecoratedContent );
            mDockablePanel.add( pCollapsableBar );
        }
        else
        {
            mDockablePanel.add( pCollapsableBar );
            mDockablePanel.add( pDecoratedContent );
        }

        pCollapsableBar.setOnBrowserEventListener( Event.MOUSEEVENTS, this );
    }

    public void updateArrow()
    {
        mArrow.setUrl( mArrows[mIndexArrow = (mIndexArrow + 1) & 1] );
    }

    public boolean onBrowserEvent( Event event )
    {
        switch ( DOM.eventGetType( event ) )
        {
            case Event.ONMOUSEUP:
                UtilsGwt.eventPreventDefaultAndCancelBubble( event );
                if ( UtilsGwt.wasAltKeyDownOnCurrentEvent() )
                {
                    AbstractContextPopup zPopup = new MoveDockedWidgetContextPopup( mContextMenu );
                    zPopup.addStyleName( "DockPopupMenu" );
                    zPopup.showContextPopup( event, mRectangleContainmentStrategy, null,
                                             mPopupRelativeMeetingPoint );
                }
                else
                {
                    setOpen( !isOpen() );
                }
            case Event.ONMOUSEOVER:
            case Event.ONMOUSEOUT:
            case Event.ONMOUSEDOWN:
            case Event.ONMOUSEMOVE:
            default:
                break;
        }
        return false;
    }

    public TaskbarHelper getTaskbarHelper()
    {
        return mTaskbarHelper;
    }

    public boolean isOpen()
    {
        return mShowing;
    }

    private class SetOpenDelayedProcess implements DelayedProcess
    {
        private boolean mRequestedOpenState;

        public boolean isRequestedOpenState()
        {
            return mRequestedOpenState;
        }

        public void setRequestedOpenState( boolean pRequestedOpenState )
        {
            mRequestedOpenState = pRequestedOpenState;
        }

        public boolean process()
        {
            mPendingSetOpen = false;
            return LLsetOpen( mRequestedOpenState );
        }
    }

    private SetOpenDelayedProcess mSetOpenDelayedProcess = new SetOpenDelayedProcess();
    private EscalatingProcess mSetOpenEscalatingProcess = null;
    private boolean mPendingSetOpen = false;

    private void cancelPendingSetOpen()
    {
        if ( mPendingSetOpen && (mSetOpenEscalatingProcess != null) )
        {
            mPendingSetOpen = false;
            mSetOpenEscalatingProcess.cancel();
        }
    }

    private void schedulePendingSetOpen( boolean pRequestedOpenState )
    {
        mSetOpenDelayedProcess.setRequestedOpenState( pRequestedOpenState );
        if ( !mPendingSetOpen )
        {
            if ( mSetOpenEscalatingProcess == null )
            {
                mSetOpenEscalatingProcess = new EscalatingProcess( mSetOpenDelayedProcess );
            }
            mPendingSetOpen = true;
        }
        mSetOpenEscalatingProcess.schedule();
    }

    public void setOpen( boolean pOpen )
    {
        if ( LLsetOpen( pOpen ) )
        {
            cancelPendingSetOpen();
        }
        else
        {
            schedulePendingSetOpen( pOpen );
        }
    }

    private boolean LLsetOpen( boolean pOpen )
    {
        if ( isOpen() != pOpen )
        {
            if ( !isContentReady() )
            {
                return false;
            }
            updateArrow();
            int zNewSize = COLLAPSABLE_BAR_SIZE + (pOpen ? mDecoratedContentSize : 0);
            mDecoratedContent.setVisible( mShowing = pOpen );
            mDimensionHelper.setDimension( mDockablePanel, zNewSize );
            mDockablePanel.relayout();
        }
        return true;
    }

    private boolean isContentReady()
    {
        if ( mDecoratedContentSize == null )
        {
            int zContentSize = mDimensionHelper.getOffsetDimension( mDecoratedContent.getElement() );
            if ( zContentSize < 15 )
            {
                return false;
            }
            mDecoratedContentSize = zContentSize;
        }
        return true;
    }
}