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.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;
	
	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);
		if (dialog.open() == ComponentSelectionDialog.CANCEL)
			return;
		toAdd = dialog.getSelected();
		if (toAdd == null)
			return;
		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  {
			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:
                    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());
                Vector3d v = new Vector3d(dir);
                v.scale(toPcp.getInlineLength());
                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);
                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);
	}
}