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

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.iconservice.*;
import org.litesoft.GWT.client.nonpublic.*;
import org.litesoft.GWT.client.widgets.*;
import org.litesoft.GWT.client.widgets.nonpublic.*;

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

import java.util.*;

public class TaskbarHelper implements FloatableContainerListener {
    private NEWSposition mPosition;
    private List mFavorites = new ArrayList();
    private List mTasks = new ArrayList();
    private AbstractSizeableOneDimensionalPanel mItemsPanel;
    private PopupPanel mPopup;
    private PopupImage mPopupImage;
    private boolean mIsFavorite = false;
    private TaskbarItem mItem;
    private static final int POPUP_WIDTH = 24;
    private static final int POPUP_HEIGHT = 24;
    private FloaterFactoryFactory mFloaterFactoryFactory;
    protected boolean mContextMenuIsShown = false;
    private Image mSeparator;
    private TaskbarDockingPanel mTaskbarDockingPanel;
    private HashMap mFloaterToTaskbarItemMap = new HashMap();

    public TaskbarHelper( FloaterFactoryFactory pFloaterFactoryFactory ) {
        mFloaterFactoryFactory = pFloaterFactoryFactory;

        mPopup = new PopupPanel( true );
        mPopupImage = new PopupImage();

        mPopupImage.addClickListener( new ClickListener() {
            public void onClick( Widget sender ) {
                mPopupImage.click( sender );
            }
        } );

        mPopupImage.addMouseListener( new MouseListenerAdapter() {
            public void onMouseLeave( Widget sender ) {
                // Element toElement = DOM.eventGetToElement( DOM.eventGetCurrentEvent() );
                if ( !mContextMenuIsShown ) {
                    hidePopup();
                    showTaskbarImage( getLastItem() );
                }
            }
        } );
        mPopup.add( mPopupImage );
        mPopup.setPixelSize( POPUP_WIDTH, POPUP_HEIGHT );
    }

    public TaskbarHelper getTaskbarHelper() {
        return this;
    }

    public void setPosition( NEWSposition pPosition ) {
        mPosition = pPosition;
    }

    public void setTaskbarDockingPanel( TaskbarDockingPanel pTaskbarDockingPanel ) {
        mTaskbarDockingPanel = pTaskbarDockingPanel;
    }

    public TaskbarDockingPanel getTaskbarDockingPanel() {
        return mTaskbarDockingPanel;
    }

    public boolean isFirstFavoriteItem( TaskbarItem pTaskbarItem ) {
        return mFavorites.indexOf( pTaskbarItem ) == 0;
    }

    public boolean isLastFavoriteItem( TaskbarItem pTaskbarItem ) {
        return mFavorites.indexOf( pTaskbarItem ) == (mFavorites.size() - 1);
    }

    public void addToTasks( SizeableFloater pFloater, TaskbarEntry pTaskbarEntry ) {
        TaskbarItem taskbarItem = new TaskbarFloaterItem( this, (TaskbarFloaterEntry) pTaskbarEntry );

        mFloaterToTaskbarItemMap.put( pFloater, taskbarItem );
        mTasks.add( taskbarItem );
        Widget taskbarWidget = taskbarItem.getTaskbarWidget();
        mItemsPanel.add( taskbarWidget );
        mItemsPanel.relayout();
    }

    public void removeFromTasks( SizeableFloater pFloater ) {

        TaskbarItem taskbarItem = (TaskbarItem) mFloaterToTaskbarItemMap.get( pFloater );
        if ( taskbarItem != null ) {
            mTasks.remove( taskbarItem );
            mItemsPanel.remove( taskbarItem.getTaskbarWidget() );
            mItemsPanel.relayout();
        }
        mFloaterToTaskbarItemMap.remove( pFloater );
    }

    public TaskbarItem[] getFavorites() {
        return toArray( mFavorites );
    }

    public TaskbarItem[] getTasks() {
        return toArray( mTasks );
    }

    private TaskbarItem[] toArray( List pList ) {
        TaskbarItem[] rv = new TaskbarItem[pList.size()];
        for ( int i = 0; i < pList.size(); i++ ) {
            rv[i] = (TaskbarItem) pList.get( i );
        }
        return rv;
    }

    public void addTo( AbstractSizeableOneDimensionalPanel pPanel, String pSeparatorURL ) {
        mItemsPanel = pPanel;
        TaskbarItem[] items = getFavorites();
        for ( int i = 0; i < items.length; i++ ) {
            pPanel.add( items[i].getTaskbarWidget() );
        }

        mSeparator = new Image( pSeparatorURL );
        pPanel.add( mSeparator );

        items = getTasks();
        for ( int i = 0; i < items.length; i++ ) {
            pPanel.add( items[i].getTaskbarWidget() );
        }
    }

    public void bringToFront( TaskbarItem pItem ) {
        pItem.bringToFront();
    }

    public void manageFloater( TaskbarItem pItem ) {
        pItem.manageFloater();
    }

    public void updateFavoritesDisplay( List pFavorites ) {
        mFavorites.clear();

        for ( int j = 0; j < (pFavorites.size()); j++ ) {
            mFavorites.add( new TaskbarFavoriteItem( this, (TaskbarFavoriteEntry) pFavorites.get( j ) ) );
        }

        if ( mItemsPanel != null ) {
            int separatorIndex = mItemsPanel.getWidgetIndex( mSeparator );
            for ( int i = separatorIndex - 1; i >= 0; i-- ) {
                mItemsPanel.remove( i );
            }

            for ( int j = 0; j < (mFavorites.size()); j++ ) {
                TaskbarItem item = (TaskbarItem) mFavorites.get( j );
                mItemsPanel.insert( item.getTaskbarWidget(), mItemsPanel.getWidgetIndex( mSeparator ) );
            }
            mItemsPanel.relayout();
        }
    }

    public boolean isPositionHorizontal() {
        return mPosition.isNorthOrSouth();
    }

    private TaskbarItem mLastItem = null;

    public TaskbarItem getLastItem() {
        return mLastItem;
    }

    public void showPopup( TaskbarItem pItem ) {
        showTaskbarImage( getLastItem() );
        mLastItem = pItem;
        mPopup.hide();
        mPopupImage.setUrl( pItem.getLargeURL() );
        mPopupImage.setTitle( pItem.getTooltip() );

        int newLeft;
        int newTop;
        Widget widget = pItem.getTaskbarWidget();
        int zWidthDiff = POPUP_WIDTH - widget.getOffsetWidth();
        int zHeightDiff = POPUP_HEIGHT - widget.getOffsetHeight();

        if ( isPositionHorizontal() ) {
            newLeft = widget.getAbsoluteLeft() - (zWidthDiff / 2);

            if ( (widget.getAbsoluteTop() + POPUP_HEIGHT) > (Window.getClientHeight() - 9) ) {
                newTop = widget.getAbsoluteTop() - (POPUP_HEIGHT - widget.getOffsetHeight());
            } else {
                newTop = widget.getAbsoluteTop();
            }
        } else {
            newTop = widget.getAbsoluteTop() - (zHeightDiff / 2);

            if ( (widget.getAbsoluteLeft() + POPUP_WIDTH) > (Window.getClientWidth() - 9) ) {
                newLeft = widget.getAbsoluteLeft() - (POPUP_WIDTH - widget.getOffsetWidth());
            } else {
                newLeft = widget.getAbsoluteLeft();
            }
        }

        mPopup.setPopupPosition( newLeft, newTop );
        mPopup.show();
        hideTaskbarImage( pItem );
    }

    private void hideTaskbarImage( TaskbarItem pItem ) {
        DOM.setStyleAttribute( pItem.getTaskbarWidget().getElement(), "visibility", "hidden" );
    }

    private void showTaskbarImage() {
        if ( mItem != null ) {
            DOM.setStyleAttribute( mItem.getTaskbarWidget().getElement(), "visibility", "visible" );
        }
    }

    private void showTaskbarImage( TaskbarItem pItem ) {
        if ( pItem != null ) {
            DOM.setStyleAttribute( pItem.getTaskbarWidget().getElement(), "visibility", "visible" );
        }
    }

    public void hidePopup() {
        mPopup.hide();
        teardownForPopup();
    }

    public void setupForPopup( boolean pFavorite, TaskbarItem pTaskbarItem ) {
        mIsFavorite = pFavorite;
        mItem = pTaskbarItem;
    }

    private void teardownForPopup() {
        mIsFavorite = false;
        mItem = null;
        mPopupImage.setUrl( "common/images/misc/TransparentSpacer.gif" );
    }

    public void floaterAdded( SizeableFloater pFloater ) {
        if ( pFloater instanceof ITaskbarFloaterManageable ) {
            addToTasks( pFloater, new TaskbarFloaterEntry( (ITaskbarFloaterManageable) pFloater ) );
        }
    }

    public void floaterRemoved( SizeableFloater pFloater ) {
        removeFromTasks( pFloater );
    }

    public void setActive( SizeableFloater pFloater ) {
        BackgroundCellForTaskbarItem widgetForFloater =
                (BackgroundCellForTaskbarItem) getTaskbarWidgetForFloater( pFloater );
        if ( widgetForFloater != null ) {
            widgetForFloater.setActiveStyle();
        }
    }

    public void clearActive( SizeableFloater pFloater ) {
        BackgroundCellForTaskbarItem widgetForFloater =
                (BackgroundCellForTaskbarItem) getTaskbarWidgetForFloater( pFloater );
        if ( widgetForFloater != null ) {
            widgetForFloater.setRegularStyle();
        }
    }

    private Widget getTaskbarWidgetForFloater( SizeableFloater pFloater ) {
        TaskbarItem zTaskbarItem = (TaskbarItem) mFloaterToTaskbarItemMap.get( pFloater );
        if ( zTaskbarItem != null ) {
            return zTaskbarItem.getTaskbarWidget();
        } else {
            return null;
        }
    }

    public void click( Widget sender ) {
        mPopupImage.click( sender );
    }

    private class PopupImage extends OurImage {
        public void click( Widget sender ) {
            if ( mIsFavorite ) {
                clickFavorite( sender );
            } else {
                clickItem();
            }
        }

        private void clickItem() {
            IFloaterPanelMoveAndSize zFloaterPanel = mItem.getFloaterPanel();
            if ( UtilsGwt.wasAltKeyDownOnCurrentEvent() ) {
                mItem.bringToFront();
                mItem.manageFloater();
                showTaskbarImage();
                hidePopup();
            } else if ( zFloaterPanel.isChromed() ) {
                mItem.bringToFront();
            }
        }

        private void clickFavorite( Widget sender ) {
            if ( !UtilsGwt.wasAltKeyDownOnCurrentEvent() ) {
                mFloaterFactoryFactory.launchFloater( ((TaskbarFavoriteItem) mItem).getFloaterFactoryRef() );
                return;
            }
            FavoritesContextMenu zContextMenu = new FavoritesContextMenu( true, getTaskbarHelper(), mItem );
            zContextMenu.addStyleName( "FavoritesPopupMenu" );
            zContextMenu.showContextMenu( sender.getAbsoluteLeft(), sender.getAbsoluteTop() );
            mContextMenuIsShown = true;
            zContextMenu.addPopupListener( new PopupListener() {
                public void onPopupClosed( PopupPanel sender, boolean autoClosed ) {
                    mContextMenuIsShown = false;
                    showTaskbarImage();
                    hidePopup();
                }
            } );
        }
    }
}