package org.simantics.plant3d.scenegraph;

import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

import javax.vecmath.Quat4d;
import javax.vecmath.Vector3d;

import org.simantics.db.Resource;
import org.simantics.g3d.math.MathTools;
import org.simantics.g3d.scenegraph.IG3DNode;
import org.simantics.g3d.scenegraph.NodeMap;
import org.simantics.g3d.scenegraph.NodeMapProvider;
import org.simantics.g3d.scenegraph.base.INode;
import org.simantics.g3d.scenegraph.base.NodeException;
import org.simantics.g3d.scenegraph.base.ParentNode;
import org.simantics.objmap.graph.IMapping;
import org.simantics.objmap.graph.annotations.GraphType;
import org.simantics.objmap.graph.annotations.RelatedElementsAdd;
import org.simantics.objmap.graph.annotations.RelatedElementsGet;
import org.simantics.objmap.graph.annotations.RelatedElementsRem;
import org.simantics.plant3d.ontology.Plant3D;

import vtk.vtkProp;

@GraphType(Plant3D.URIs.Plant)
public class P3DRootNode extends ParentNode<INode> implements IG3DNode, NodeMapProvider<Resource, vtkProp, INode> {
	
	// Vertical direction that determines the interpretation of rotation angle origin
	protected Vector3d upVector = new Vector3d(0.0, 1.0, 0.0);

	@RelatedElementsAdd(Plant3D.URIs.children)
	public void addChild(INode node) {
	//public void addChild(IP3DVisualNode node) {
		addNode(Plant3D.URIs.children,node);
	}
	
	@RelatedElementsGet(Plant3D.URIs.children)
	public Collection<INode> getChild() {
		return getNodes(Plant3D.URIs.children);
	}
	
	@RelatedElementsRem(Plant3D.URIs.children)
	public void remChild(INode node) {
	//public void remChild(IP3DNode node) {
		removeNode(Plant3D.URIs.children, node);
	}
	
	private NodeMap<Resource, vtkProp, INode> nodeMap;
	private IMapping<Resource, INode> mapping;
	
	public void setNodeMap(NodeMap<Resource, vtkProp, INode> nodeMap) {
		this.nodeMap = nodeMap;
		this.mapping = nodeMap.getMapping();
	}
	
	public void setMapping(IMapping<Resource, INode> mapping) {
		this.mapping = mapping;
	}
	
	@Override
	public NodeMap<Resource, vtkProp, INode> getNodeMap() {
		return nodeMap;
	}
	
	public Resource getNodeResource(INode node) {
		return mapping.inverseGet(node);
	}
	
	public INode getResourceNode(Resource r) {
		return mapping.get(r);
	}
	
	@Override
	public ParentNode<?> getParent() {
		return null;
	}
	
	@Override
	public ParentNode<?> getRootNode() {
		return this;
	}
	
	public javax.vecmath.Quat4d getOrientation() {
		return MathTools.getIdentityQuat();
	};
	
	@Override
	public Vector3d getPosition() {
		return new Vector3d();
	}
	
	@Override
	public Quat4d getWorldOrientation() {
		return MathTools.getIdentityQuat();
	}
	
	@Override
	public Vector3d getWorldPosition() {
		return new Vector3d();
	}
	
	@Override
	public Quat4d getWorldOrientation(Quat4d localOrientation) {
		return localOrientation;
	}
	
	@Override
	public Vector3d getWorldPosition(Vector3d localPosition) {
		return localPosition;
	}
	
	@Override
	public Quat4d getLocalOrientation(Quat4d worldOrientation) {
		return worldOrientation;
	}
	
	@Override
	public Vector3d getLocalPosition(Vector3d worldPosition) {
		return worldPosition;
	}
	
	@Override
	public void setPosition(Vector3d position) {
		throw new NodeException("Cannot set root node position");
	}
	
	@Override
	public void setOrientation(Quat4d orientation) {
		throw new NodeException("Cannot set root node orientation");
	}
	
	@Override
	public void setWorldOrientation(Quat4d orientation) {
		throw new NodeException("Cannot set root node orientation");
	}
	
	@Override
	public void setWorldPosition(Vector3d position) {
		throw new NodeException("Cannot set root node orientation");
	}
	
	public String getUniqueName(String prefix) {
		Set<String> names = new HashSet<String>();
		for (INode node : getChild()) {
			if (!(node instanceof IP3DVisualNode))
				continue;
			IP3DVisualNode n = (IP3DVisualNode)node;
			names.add(n.getName());
		}
		int i = 1;
		while (true) {
			String genName = prefix + "_" + i;
			if (!names.contains(genName))
				return genName;
			i++;
		}
	}

	
	@Override
	public <T> T getAdapter(Class<T> adapter) {
		if (adapter.isAssignableFrom(NodeMap.class))
			return adapter.cast(nodeMap);
		return null;
	}
	
	public Nozzle createNozzle() {
		return new Nozzle();
	}
	
	public Equipment createEquipment() {
		return new Equipment();
	}
	
	public InlineComponent createInline() {
		return new InlineComponent();
	}
	
	public EndComponent createEnd() {
		return new EndComponent();
	}
	
	public TurnComponent createTurn() {
		return new TurnComponent();
	}

	public Vector3d getUpVector() {
		return upVector;
	}
}