/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.util.Geometry;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.graphics.Cursor;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;
import org.eclipse.ui.IViewReference;
import org.eclipse.ui.internal.dnd.AbstractDropTarget;
import org.eclipse.ui.internal.dnd.DragUtil;
import org.eclipse.ui.internal.dnd.IDragOverListener;
import org.eclipse.ui.internal.dnd.IDropTarget;
import org.eclipse.ui.presentations.PresentationUtil;

/**
 * @since 3.3
 *
 */
public class FastViewDnDHandler implements IDragOverListener {
	private String id;
	private ToolBarManager tbm;
	private WorkbenchWindow wbw;
    private ViewDropTarget dropTarget = null;

    private Listener dragListener = new Listener() {
        public void handleEvent(Event event) {
            Point position = DragUtil.getEventLoc(event);
            
            ToolBar toolbar = tbm.getControl();
            Point local = toolbar.toControl(position);
            ToolItem item = toolbar.getItem(local);
            IViewReference ref = (IViewReference) item
            .getData(ShowFastViewContribution.FAST_VIEW);

            if (ref != null) {
                startDraggingFastView(ref, position, false);
            }
        }
    };

    class ViewDropTarget extends AbstractDropTarget {
        List panes;
        ToolItem curItem;

        /**
         * @param panesToDrop the list of ViewPanes to drop at the given position
         */
        public ViewDropTarget(List panesToDrop, ToolItem position) {
            setTarget(panesToDrop, position);
        }
        
        public void setTarget(List panesToDrop, ToolItem position) {
            panes = panesToDrop;
            this.curItem = position;            
        }

        /* (non-Javadoc)
         * @see org.eclipse.ui.internal.dnd.IDropTarget#drop()
         */
        public void drop() {
            Perspective persp = wbw.getActiveWorkbenchPage().getActivePerspective();
            FastViewManager fvm = persp.getFastViewManager();

            int insertIndex = tbm.getControl().indexOf(curItem);
            Iterator iter = panes.iterator();
            while (iter.hasNext()) {
                ViewPane pane = (ViewPane) iter.next();
                IViewReference ref = pane.getViewReference();
        		adoptRef(ref);
                fvm.addViewReference(id, insertIndex++, ref, !iter.hasNext());
            }
        }

        private void adoptRef(IViewReference ref) {
			Perspective persp = wbw.getActiveWorkbenchPage()
					.getActivePerspective();
			PerspectiveHelper helper = persp.getPresentation();
			ContainerPlaceholder ourContainerPlaceholder = (ContainerPlaceholder) helper
					.findPart(id, null);
			LayoutPart refPart = helper.findPart(ref.getId(), ref
					.getSecondaryId());
			ILayoutContainer refContainer = refPart.container;
			if (refContainer != ourContainerPlaceholder) {
				// remove the old part... if it's represented by a
				// placeholder then just remove it...
				if (refPart instanceof PartPlaceholder) {
					if (refContainer instanceof ContainerPlaceholder) {
						// just remove the placeholder
						ViewStack realContainer = (ViewStack) ((ContainerPlaceholder) refContainer)
								.getRealContainer();
						realContainer.remove(refPart);
					}
					else if (refContainer instanceof ViewStack) {
						refContainer.remove(refPart);
					}
				}
				else {
					// If its a real view ref then defref it...
					helper.derefPart(refPart);
				}
				PartPlaceholder newPlaceholder = new PartPlaceholder(ref
						.getId());
				ourContainerPlaceholder.add(newPlaceholder);
			}
		}
        
        /*
		 * (non-Javadoc)
		 * 
		 * @see org.eclipse.ui.internal.dnd.IDropTarget#getCursor()
		 */
        public Cursor getCursor() {
            return DragCursors.getCursor(DragCursors.FASTVIEW);
        }

        public Rectangle getSnapRectangle() {
            if (curItem == null) {
                // As long as the toolbar is not empty, highlight the place
                // where this view will appear (we
                // may have compressed it to save space when empty, so the actual
                // icon location may not be over the toolbar when it is empty)
                if (tbm.getControl().getItemCount() > 0) {
                    return getLocationOfNextIcon();
                }
                // If the toolbar is empty, highlight the entire toolbar 
                return DragUtil.getDisplayBounds(tbm.getControl());
			}

			return Geometry.toDisplay(tbm.getControl(), curItem.getBounds());
        }
    }
    
	/**
	 * 
	 */
	public FastViewDnDHandler(String id, final ToolBarManager tbm, WorkbenchWindow wbw) {
		this.id = id;
		this.tbm = tbm;
		this.wbw = wbw;
		
		// Hook the 'drop' listener to the control
		DragUtil.addDragTarget(tbm.getControl(), this);
        PresentationUtil.addDragListener(tbm.getControl(), dragListener);
		
		// Clean up on dispose
		tbm.getControl().addDisposeListener(new DisposeListener() {
			public void widgetDisposed(DisposeEvent e) {
				DragUtil.removeDragTarget((Control)(e.widget), FastViewDnDHandler.this);
		        PresentationUtil.removeDragListener(tbm.getControl(), dragListener);
			}
		});
	}

    /**
     * Returns the toolbar item at the given position, in display coordinates
     * @param position
     */
    private ToolItem getToolItem(Point position) {
        ToolBar toolbar = tbm.getControl();
        Point local = toolbar.toControl(position);
        return toolbar.getItem(local);
    }
    
	/* (non-Javadoc)
	 * @see org.eclipse.ui.internal.dnd.IDragOverListener#drag(org.eclipse.swt.widgets.Control, java.lang.Object, org.eclipse.swt.graphics.Point, org.eclipse.swt.graphics.Rectangle)
	 */
	public IDropTarget drag(Control currentControl, Object draggedObject,
			Point position, Rectangle dragRectangle) {
		// If we're trying to drop onto a 'standalone' stack, don't...
		if (isStandaloneStack())
			return null;
		
        ToolItem targetItem = getToolItem(position);
        if (draggedObject instanceof ViewPane) {
            ViewPane pane = (ViewPane) draggedObject;

            // Can't drag views between windows
            if (pane.getWorkbenchWindow() != wbw) {
                return null;
            }

            List newList = new ArrayList(1);
            newList.add(draggedObject);

            return createDropTarget(newList, targetItem);
        }
        if (draggedObject instanceof ViewStack) {
            ViewStack folder = (ViewStack) draggedObject;

            if (folder.getWorkbenchWindow() != wbw) {
                return null;
            }

            List viewList = new ArrayList(folder.getItemCount());
            LayoutPart[] children = folder.getChildren();

            for (int idx = 0; idx < children.length; idx++) {
                if (!(children[idx] instanceof PartPlaceholder)) {
                    viewList.add(children[idx]);
                }
            }

            return createDropTarget(viewList, targetItem);
        }

        return null;
	}
    /**
     * Tests the view references associated with the stack and
     * returns <code>true</code> if any view is a stand-alone view
     * 
	 * @return <code>true</code> is any view is stand-alone
	 */
	private boolean isStandaloneStack() {
		Perspective persp = wbw.getActiveWorkbenchPage().getActivePerspective();
		List fvs = persp.getFastViewManager().getFastViews(id);
		for (Iterator iterator = fvs.iterator(); iterator.hasNext();) {
			IViewReference ref = (IViewReference) iterator.next();
			if (persp.isStandaloneView(ref))
				return true;
		}
		
		return false;
	}

	private IDropTarget createDropTarget(List viewList, ToolItem targetItem) {
        if (dropTarget == null) {
            dropTarget = new ViewDropTarget(viewList, targetItem);
        } else {
            dropTarget.setTarget(viewList, targetItem);
        }
        return dropTarget;
    }

    /**
     * Returns the approximate location where the next fastview icon
     * will be drawn (display coordinates)
     */
    public Rectangle getLocationOfNextIcon() {
        ToolBar control = tbm.getControl();

        Rectangle result = control.getBounds();
        Point size = control.computeSize(SWT.DEFAULT, SWT.DEFAULT, false);
        result.height = size.y;
        result.width = size.x;
        
        boolean horizontal = (control.getStyle() & SWT.VERTICAL) == 0;
        if (control.getItemCount() == 0) {
        	Geometry.setDimension(result, horizontal, 0);
        }
        
        int hoverSide = horizontal ? SWT.RIGHT : SWT.BOTTOM;

        result = Geometry.getExtrudedEdge(result, -Geometry.getDimension(
                result, !horizontal), hoverSide);

        return Geometry.toDisplay(control.getParent(), result);
    }

    /**
     * Returns the index of the ToolItem fronting the view ref
     * @param toFind the view reference to find the index of
     * @return the index or -1 if not found
     */
    private int getIndex(IViewReference toFind) {
        ToolItem[] items = tbm.getControl().getItems();
        for (int i = 0; i < items.length; i++) {
            if (items[i].getData(ShowFastViewContribution.FAST_VIEW) == toFind) {
                return i;
            }
        }

        return -1;
    }
    
    /**
     * Begins dragging a particular fast view
     * 
     * @param ref
     * @param position
     */
    protected void startDraggingFastView(IViewReference ref, Point position,
            boolean usingKeyboard) {
        int index = getIndex(ref);
        if (index == -1)
        	return;
        
        ToolItem item = tbm.getControl().getItem(index);
        Rectangle dragRect = Geometry.toDisplay(tbm.getControl(), item.getBounds());
        startDrag(((WorkbenchPartReference) ref).getPane(), dragRect, position,
				usingKeyboard);
    }

    private void startDrag(Object toDrag, Rectangle dragRect, Point position,
            boolean usingKeyboard) {
        WorkbenchPage page = wbw.getActiveWorkbenchPage();
        Perspective persp = page.getActivePerspective();

        // Prevent dragging non-movable refs out of a minimized stack  
        if (toDrag instanceof ViewPane) {
        	ViewPane pane = (ViewPane) toDrag;
        	if (!persp.isMoveable(pane.getViewReference()))
        		return;
        }
        
        IViewReference oldFastView = null;
        if (persp != null) {
            oldFastView = persp.getActiveFastView();

            if (page != null) {
                page.hideFastView();
            }
        }

        if (page.isPageZoomed()) {
            page.zoomOut();
        }

        boolean success = DragUtil.performDrag(toDrag, dragRect, position,
                !usingKeyboard);

        // If the drag was cancelled, reopen the old fast view
        if (!success && oldFastView != null && page != null) {
            page.toggleFastView(oldFastView);
        }
    }
}