package org.simantics.plant3d.editor;

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

import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.resource.LocalResourceManager;
import org.eclipse.jface.viewers.DecorationOverlayIcon;
import org.eclipse.jface.viewers.IDecoration;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.events.MenuDetectEvent;
import org.eclipse.swt.events.MenuDetectListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Menu;
import org.simantics.db.Resource;
import org.simantics.g3d.scenegraph.base.INode;
import org.simantics.g3d.scenegraph.base.ParentNode;
import org.simantics.g3d.vtk.common.NodeSelectionProvider2;
import org.simantics.g3d.vtk.common.VTKContentOutlinePage;
import org.simantics.plant3d.Activator;
import org.simantics.plant3d.ontology.Plant3D;
import org.simantics.plant3d.scenegraph.EndComponent;
import org.simantics.plant3d.scenegraph.Equipment;
import org.simantics.plant3d.scenegraph.Nozzle;
import org.simantics.plant3d.scenegraph.P3DRootNode;
import org.simantics.plant3d.scenegraph.PipeRun;
import org.simantics.plant3d.scenegraph.PipelineComponent;
import org.simantics.plant3d.scenegraph.TurnComponent;
import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint;

public class P3DContentOutlinePage extends VTKContentOutlinePage<Resource, INode>{
	
	private static final boolean DEBUG = false;
	protected Menu contextMenu;
	
	private LocalResourceManager manager = new LocalResourceManager(JFaceResources.getResources());
	
	private Image nozzleImage;
	private Image pipeImage;
	private Image tankImage;
	private Image elbowImage;
	private Image componentImage;
	
	
	private Image nozzleErrorImage;
    private Image pipeErrorImage;
    private Image tankErrorImage;
    private Image elbowErrorImage;
    private Image componentErrorImage;
    
	public  P3DContentOutlinePage(ParentNode<? extends INode> rootNode, NodeSelectionProvider2<Resource,INode> provider) {
		super(rootNode,provider);
		
		ImageDescriptor nozzleDesc = Activator.imageDescriptorFromPlugin(Activator.PLUGIN_ID, "icons/Nozzle.png");
		ImageDescriptor straightDesc = Activator.imageDescriptorFromPlugin(Activator.PLUGIN_ID, "icons/Straight.png");
		ImageDescriptor tankDesc = Activator.imageDescriptorFromPlugin(Activator.PLUGIN_ID, "icons/tank.png");
		ImageDescriptor elbowDesc = Activator.imageDescriptorFromPlugin(Activator.PLUGIN_ID, "icons/Elbow.png");
		ImageDescriptor componentDesc = Activator.imageDescriptorFromPlugin(Activator.PLUGIN_ID, "icons/Component.png");
		nozzleImage = manager.createImage(nozzleDesc);
		pipeImage = manager.createImage(straightDesc);
		tankImage = manager.createImage(tankDesc);
		elbowImage = manager.createImage(elbowDesc);
		componentImage = manager.createImage(componentDesc);
		
		ImageDescriptor error = Activator.imageDescriptorFromPlugin("org.simantics.issues.ui", "icons/warning_decoration.png");
		nozzleErrorImage = manager.createImage(new DecorationOverlayIcon(nozzleDesc, error, IDecoration.BOTTOM_RIGHT));
		pipeErrorImage = manager.createImage(new DecorationOverlayIcon(straightDesc, error, IDecoration.BOTTOM_RIGHT));
		tankErrorImage = manager.createImage(new DecorationOverlayIcon(tankDesc, error, IDecoration.BOTTOM_RIGHT));
		elbowErrorImage = manager.createImage(new DecorationOverlayIcon(elbowDesc, error, IDecoration.BOTTOM_RIGHT));
		componentErrorImage = manager.createImage(new DecorationOverlayIcon(componentDesc, error, IDecoration.BOTTOM_RIGHT));
	}
	
	@Override
	protected void createProviders(TreeViewer viewer) {
		viewer.setContentProvider(new ScenegraphContentProvider() {
			@Override
			public Object[] getChildren(Object parentElement) {
				if (parentElement instanceof P3DRootNode) {
					return ((P3DRootNode)parentElement).getChild().toArray();
				}
				if (parentElement instanceof PipeRun) {
					if (DEBUG) {
						List<Object> list = new ArrayList<Object>();
						list.addAll(((PipeRun)parentElement).getControlPoints());
						list.addAll(((PipeRun)parentElement).getSortedChild());
						return list.toArray();
					}
					return ((PipeRun)parentElement).getSortedChild().toArray();
				}
				if (DEBUG) {
					if (parentElement instanceof PipelineComponent) {
						return new Object[]{((PipelineComponent) parentElement).getControlPoint()};
					} else if (parentElement instanceof PipeControlPoint) {
						PipeControlPoint pcp = (PipeControlPoint) parentElement;
						Object arr[] = new Object[pcp.children.size()+1];
						arr[0] = pcp.getPipelineComponent();
						for (int i = 0; i < pcp.children.size();i++) {
							arr[i+1] = pcp.children.get(i);
						}
						return arr;
					}
				}
				return super.getChildren(parentElement);
			}
			
			@Override
			public boolean hasChildren(Object element) {
				if (element instanceof P3DRootNode) {
					return ((P3DRootNode)element).getChild().size() > 0;
				}
				if (!DEBUG) {
					if (element instanceof PipeRun) {
						return ((PipeRun)element).getChild().size() > 0;
					}
				} else {
					if (element instanceof PipelineComponent) {
						return ((PipelineComponent) element).getControlPoint() != null;
					} else if (element instanceof PipeControlPoint) {
						return ((PipeControlPoint) element).getPipelineComponent() != null;
					}
				}
				return super.hasChildren(element);
			}
		});
		viewer.setLabelProvider(new P3DLabelProvider());
		
		hookContextMenu(viewer);
		viewer.getTree().addMenuDetectListener(new MenuDetectListener() {

			@Override
			public void menuDetected(MenuDetectEvent e) {
				contextMenu.setLocation(e.x, e.y);
				contextMenu.setVisible(true);
			}
		});
		
	}
	
	@Override
	public void propertyChanged(INode node, String id) {
	    // TODO Auto-generated method stub
	    if (node instanceof PipelineComponent) {
	        if (Plant3D.URIs.HasNext.equals(id) || Plant3D.URIs.HasPrevious.equals(id)) {
	            refershViewer(node.getParent());
	            return;
	        }
	    }
	    super.propertyChanged(node, id);
	}
	
	@Override
	public void dispose() {
		manager.dispose();
		super.dispose();
	}
	
	protected void hookContextMenu(TreeViewer viewer) {
		MenuManager menuMgr = new MenuManager("#PopupMenu");
		menuMgr.setRemoveAllWhenShown(true);
		menuMgr.addMenuListener(new IMenuListener() {
			public void menuAboutToShow(IMenuManager manager) {
				createContextMenu(manager);
			}
		});
		contextMenu = menuMgr.createContextMenu(viewer.getTree());
	}
	
	protected void createContextMenu(IMenuManager manager) {
		
	}

	private class P3DLabelProvider extends ScenegraphLabelProvider {
		@Override
		public Image getImage(Object element) {
			if (element instanceof PipelineComponent) {
				PipelineComponent comp = (PipelineComponent)element;
				if (comp instanceof TurnComponent) {
				    if (comp.getError() == null)
				        return elbowImage;
				    else
				        return elbowErrorImage;
				} else if (comp instanceof EndComponent) {
				    if (comp.getError() == null)
				        return componentImage;
				    else
				        return componentErrorImage;
				} else if (comp instanceof Nozzle) {
				    if (comp.getError() == null)
				        return nozzleImage;
				    else
				        return nozzleErrorImage;
				} else if (comp.getControlPoint().isFixed()) {
				    if (comp.getError() == null)
				        return componentImage;
				    else
				        return componentErrorImage;
				}
				if (comp.getError() == null)
				    return pipeImage;
				else
				    return pipeErrorImage;
			} else if (element instanceof Equipment) {
				return tankImage;
			} else if (element instanceof PipeRun) {
				return pipeImage;
			}
			return null;
		}
	}
}