package org.simantics.plant3d.actions;

import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseWheelEvent;
import java.util.HashSet;
import java.util.Set;

import javax.vecmath.Vector3d;

import org.eclipse.swt.widgets.Display;
import org.simantics.g3d.scenegraph.NodeMap;
import org.simantics.g3d.scenegraph.base.INode;
import org.simantics.g3d.vtk.swt.InteractiveVtkComposite;
import org.simantics.g3d.vtk.swt.vtkSwtAction;
import org.simantics.plant3d.Activator;
import org.simantics.plant3d.dialog.ComponentSelectionDialog;
import org.simantics.plant3d.gizmo.TerminalSelectionGizmo;
import org.simantics.plant3d.scenegraph.InlineComponent;
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.controlpoint.PipeControlPoint;
import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.Direction;
import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.PositionType;
import org.simantics.plant3d.scenegraph.controlpoint.PipingRules;
import org.simantics.plant3d.utils.ComponentUtils;
import org.simantics.plant3d.utils.Item;
import org.simantics.plant3d.utils.ComponentUtils.InsertInstruction;
import org.simantics.plant3d.utils.Item.Type;
import org.simantics.utils.threads.ThreadUtils;
import org.simantics.utils.ui.ExceptionUtils;

import vtk.vtkProp;

public class AddComponentAction extends vtkSwtAction {
	

	private P3DRootNode root;
	private PipelineComponent component;
	private NodeMap<vtkProp,INode> nodeMap;
	
	private TerminalSelectionGizmo gizmo;
	
	private Set<PositionType> allowed = new HashSet<PositionType>();
	
	private Item toAdd = null;
	private PositionType insertPosition;
	private boolean insertAdjustable;
	private boolean lengthAdjustable;
	
	public AddComponentAction(InteractiveVtkComposite panel, P3DRootNode root) {
		super(panel);
		this.root = root;
		setText("Add Component");
		setImageDescriptor(Activator.imageDescriptorFromPlugin(Activator.PLUGIN_ID, "icons/Component.png"));
		nodeMap = root.getNodeMap();
		gizmo = new TerminalSelectionGizmo(panel);
	}
	
	public void setComponent(PipelineComponent component) {
		this.component = component;
		
		allowed.clear();
		if (component instanceof Nozzle) {
			if (component.getNext() == null && component.getPrevious() == null) {
				allowed.add(PositionType.NEXT);
			}  
		} else {
			if (component.getNext() == null) {
				allowed.add(PositionType.NEXT);
			}
			if (component.getPrevious() == null) {
				allowed.add(PositionType.PREVIOUS);
			}
			if (component instanceof InlineComponent && !component.getControlPoint().isFixed()){
				allowed.add(PositionType.SPLIT);
			}
		}
		setEnabled(allowed.size() > 0);
	}
	
	private Double length;
	private Double angle;
	private Double diameter;
	private Double turnRadius;
	
	@Override
	public void run() {
		
		ComponentSelectionDialog dialog = new ComponentSelectionDialog(Display.getCurrent().getActiveShell(), allowed, component);
		if (dialog.open() == ComponentSelectionDialog.CANCEL)
			return;
		toAdd = dialog.getSelected();
		if (toAdd == null)
			return;
		this.insertPosition = dialog.getInsertPosition();
		this.insertAdjustable = dialog.isInsertAdjustable();
		this.lengthAdjustable = dialog.isLenghtAdjustable();
		this.length = dialog.getLength();
		this.angle = dialog.getAngle();
		this.diameter = dialog.getDiameter();
		this.turnRadius = dialog.getTurnRadius();
		allowed = dialog.filterAllowed();
		gizmo.setComponent(component, allowed);
		super.run();
		panel.refresh();
	}
	
	@Override
	public boolean keyPressed(KeyEvent e) {
		if (e.getKeyCode() == KeyEvent.VK_ESCAPE)
			panel.useDefaultAction();
		return true;
		
	}
	
	public void attach() {
		if (component == null)
			return;
		
		super.attach();
		ThreadUtils.asyncExec(panel.getThreadQueue(), new Runnable() {
			public void run() {
				attachUI();
			}
		});
		
	}
	
	public void deattach() {
//		deactivate();
		component = null;
		nodeMap.commit("Add component");
		deattachUI();
		super.deattach();
		panel.refresh();
	}
	
	private void attachUI() {
		//panel.setCursor(activeCursor);
		gizmo.attach(panel);
	}
	
	private void deattachUI() {
		//panel.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
		gizmo.deattach();
	}
	
	@Override
	public boolean mouseMoved(MouseEvent e) {
		return getDefaultAction().mouseMoved(e);
	}
	
	@Override
	public boolean mousePressed(MouseEvent e) {
		return getDefaultAction().mousePressed(e);
	}

	@Override
	public boolean mouseReleased(MouseEvent e) {
		return getDefaultAction().mouseReleased(e);
	}
	
	@Override
	public boolean mouseDragged(MouseEvent e) {
		return getDefaultAction().mouseDragged(e);
	}
	
	public void doInsert(PositionType position) {
		try  {
			InsertInstruction inst = new InsertInstruction();
			inst.typeUri = toAdd.getUri();
			inst.angle = angle;
			inst.diameter = diameter;
			inst.length = length;
			inst.turnRadius = turnRadius;
			inst.insertPosition = insertPosition;
			inst.position = position;
			ComponentUtils.addComponent(root, component, inst);
		} catch (Exception e) {
			ExceptionUtils.logAndShowError("Cannot add component", e);
		}
//		try  {
//			PipelineComponent newComponent = ComponentUtils.createComponent(root,toAdd.getUri());
//			PipeControlPoint newPcp = newComponent.getControlPoint();
//			
//			PipeControlPoint toPcp = component.getControlPoint();
//			PipeRun pipeRun = toPcp.getPipeRun();
//			
//			Vector3d dir = null;
//			Vector3d pos = null;
//		
//			
//			if (toPcp.isInline()) {
//			    switch (position) {
//	            case NEXT: 
//	                if (toPcp.isDualInline())
//	                    toPcp = toPcp.getSubPoint().get(0);
//	                
//	                break;
//	            case PREVIOUS:
//	                if (toPcp.isDualSub())
//	                    toPcp = toPcp.parent;
//	            }
//			    Vector3d start = new Vector3d();
//			    Vector3d end = new Vector3d();
//	            dir = new Vector3d();
//	            toPcp.getInlineControlPointEnds(start, end, dir);
//	            dir.normalize();
//	           switch (position) {
//                case NEXT:
//                    pos = new Vector3d(end);
//                    break;
//                case PREVIOUS:
//                    pos = new Vector3d(start);
//                    break;
//                case SPLIT:
//                    pos = new Vector3d(toPcp.getWorldPosition());
//                    break;
//                }
//	           
//			} else if (toPcp.isDirected()) {
//			    dir = new Vector3d(toPcp.getDirection(Direction.NEXT));
//			    pos = new Vector3d(toPcp.getWorldPosition());
//			} else if (toPcp.isTurn() && toPcp.isFixed()) {
//			    dir = new Vector3d(toPcp.getDirection(position == PositionType.NEXT ? Direction.NEXT : Direction.PREVIOUS));
//                pos = new Vector3d(toPcp.getWorldPosition());
//                if (!lengthAdjustable) {
//                    Vector3d v = new Vector3d(dir);
//                    v.scale(toPcp.getInlineLength());
//                    pos.add(v);
//                } else {
//                    if (insertPosition == PositionType.NEXT) {
//                        Vector3d v = new Vector3d(dir);
//                        v.scale(toPcp.getInlineLength());
//                        pos.add(v);
//                    } else if (insertPosition == PositionType.SPLIT) {
//                        // scale 0.5*length so that we don't remove the length twice from the new component
//                        Vector3d v = new Vector3d(dir);
//                        v.scale(toPcp.getInlineLength()*0.5);  
//                        pos.add(v);
//                    }
//                }
//			}
//			
//			
//			if (!toAdd.isSizeChange()) {
//				String name = component.getPipeRun().getUniqueName(toAdd.getName());
//				newComponent.setName(name);
//
//				pipeRun.addChild(newComponent);
//				if (toAdd.isVariable()) {
//					// TODO: these options are not stored into DB. Should they?!
//					if (toAdd.getType() == Type.INLINE) {
//						newPcp.setLength(length);
////						newPcp.setFixed(true);
//					} else if (toAdd.getType() == Type.TURN) {
//						newPcp.setTurnAngle(angle);
////						newPcp.setFixed(true);
//					}
//				}
//				newComponent.updateParameters();
//				
//			    Vector3d v = new Vector3d(dir);
//			    if (insertAdjustable) {
//    			    if (insertPosition == PositionType.NEXT)
//    			        v.scale(newComponent.getControlPoint().getInlineLength());
//    			    else if (insertPosition == PositionType.SPLIT)
//    			        v.set(0, 0, 0);
//    			    else if (insertPosition == PositionType.PREVIOUS)
//    			        v.scale(-newComponent.getControlPoint().getInlineLength());
//			    } else {
//			        v.scale(newComponent.getControlPoint().getInlineLength());
//			    }
//                switch (position) {
//                case NEXT:
//                    pos.add(v);
//                    break;
//                case PREVIOUS:
//                    pos.sub(v);
//                    break;
//                case SPLIT:
//                    break;
//                }
//				
//				switch (position) {
//				case NEXT: 
//					if (toPcp.isDualInline())
//						toPcp = toPcp.getSubPoint().get(0);
//					newPcp.insert(toPcp, Direction.NEXT);
//					newPcp.setWorldPosition(pos);
//					break;
//				case PREVIOUS:
//					if (toPcp.isDualSub())
//						toPcp = toPcp.parent;
//					newPcp.insert(toPcp, Direction.PREVIOUS);
//					newPcp.setWorldPosition(pos);
//					break;
//				case SPLIT:
//					PipingRules.splitVariableLengthComponent(newComponent, (InlineComponent)component, true);
//				}
//			} else {
//				PipeRun other = new PipeRun();
//				String n = root.getUniqueName("PipeRun");
//				other.setName(n);
//				other.setPipeDiameter(diameter);
//				other.setTurnRadius(turnRadius);
//				root.addChild(other);
//				
//				
//				if (position == PositionType.NEXT) {
//					PipingRules.addSizeChange(false, pipeRun, other, (InlineComponent)newComponent, toPcp, null);
//        		} else if (position == PositionType.PREVIOUS){
//        			PipingRules.addSizeChange(true, pipeRun, other, (InlineComponent)newComponent, toPcp, null);
//        		}
//				newPcp.setWorldPosition(pos);
//				// TODO : chicken-egg problem
//				newComponent.updateParameters();
//			    Vector3d v = new Vector3d(dir);
//                v.scale(newComponent.getControlPoint().getLength()*0.5);
//                switch (position) {
//                case NEXT:
//                    pos.add(v);
//                    break;
//                case PREVIOUS:
//                    pos.sub(v);
//                    break;
//                case SPLIT:
//                    break;
//                }
//                newPcp.setWorldPosition(pos);
//				
//			}
//			
//			
//		} catch (Exception e) {
//			ExceptionUtils.logAndShowError("Cannot add component", e);
//		}
	}
	
	public boolean mouseClicked(MouseEvent e) {
		if (e.getClickCount() == 1 && e.getButton() == MouseEvent.BUTTON1) {
			int type = panel.getPickType();
			//panel.setPickType(0);
			panel.setPickType(5);
			vtkProp[] picked = panel.pick(e.getX(), e.getY());
			panel.setPickType(type);
			PositionType position = gizmo.getPickedPosition(picked);

			if (position != null) {
				doInsert(position);
				panel.useDefaultAction();
				return true;
			}
		} 
		return getDefaultAction().mouseClicked(e);
	}
	
	@Override
	public boolean mouseWheelMoved(MouseWheelEvent e) {
		return getDefaultAction().mouseWheelMoved(e);
	}
}