package org.simantics.plant3d.scenegraph;

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

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

import org.simantics.g3d.math.MathTools;
import org.simantics.g3d.ontology.G3D;
import org.simantics.g3d.property.annotations.GetPropertyValue;
import org.simantics.g3d.property.annotations.PropertyContributor;
import org.simantics.g3d.property.annotations.SetPropertyValue;
import org.simantics.g3d.scenegraph.IG3DNode;
import org.simantics.g3d.scenegraph.base.ParentNode;
import org.simantics.g3d.tools.NodeTools;
import org.simantics.layer0.Layer0;
import org.simantics.objmap.graph.annotations.RelatedGetValue;
import org.simantics.objmap.graph.annotations.RelatedSetValue;

@PropertyContributor
public abstract class P3DParentNode<T extends IP3DNode> extends ParentNode<T> implements IP3DVisualNode {
	
	private String name;
	

	
	
	@RelatedGetValue(Layer0.URIs.HasName)
	@GetPropertyValue(value = Layer0.URIs.HasName, tabId = "Default", name = "Name")
	public String getName() {
		return name;
	}
	
	@RelatedSetValue(Layer0.URIs.HasName)
	@SetPropertyValue(Layer0.URIs.HasName)
	public void setName(String name) {
		if (name == null)
			return;
		this.name = name;
		firePropertyChanged(Layer0.URIs.HasName);
	}
	
	@Override
	public String toString() {
		return getName();
	}
	
	private Vector3d position = new Vector3d();
	private Quat4d orientation = MathTools.getIdentityQuat();
	
	@Override
	@GetPropertyValue(value = G3D.URIs.hasOrientation, tabId = "Transform", name = "Orientation")
	public Quat4d getOrientation() {
		return orientation;
	}
	
	@RelatedGetValue(G3D.URIs.hasOrientation)
	public double[] getOrientationArr() {
		double arr[] = new double[4];
		orientation.get(arr);
		return arr;
		
	}
	
	@Override
	@GetPropertyValue(value = G3D.URIs.hasPosition, tabId = "Transform", name = "Position")
	public Vector3d getPosition() {
		return position;
	}
	
	@RelatedGetValue(G3D.URIs.hasPosition)
	public double[] getPositionArr() {
		double arr[] = new double[3];
		position.get(arr);
		return arr;
	}
	
	@Override
	@SetPropertyValue(G3D.URIs.hasOrientation)
	public void setOrientation(Quat4d orientation) {
		assert(orientation != null);
		this.orientation = orientation;
		
		firePropertyChanged(G3D.URIs.hasOrientation);
	}
	
	@Override
	@SetPropertyValue(G3D.URIs.hasPosition)
	public void setPosition(Vector3d position) {
		assert(position != null);
		this.position = position;
		
		firePropertyChanged(G3D.URIs.hasPosition);
	}
	
	@RelatedSetValue(G3D.URIs.hasOrientation)
	public void setOrientation(double[] arr) {
		if (arr == null)
			return;
		setOrientation(new Quat4d(arr));
	}
	
	@RelatedSetValue(G3D.URIs.hasPosition)
	public void setPosition(double[] arr) {
		if (arr == null)
			return;
		setPosition(new Vector3d(arr));
	}
	
	@Override
	@GetPropertyValue(value = G3D.URIs.hasWorldPosition, tabId = "Transform", name = "World Position")
	public Vector3d getWorldPosition() {
		IG3DNode parent = (IG3DNode)getParent();
		if (parent == null)
			return position;
		return NodeTools.getWorldPosition(parent, new Vector3d(position));
	}
	
	
	public Vector3d getWorldPosition(Vector3d localPosition) {
		return NodeTools.getWorldPosition(this,localPosition);
	}

	
	@Override
	@GetPropertyValue(value = G3D.URIs.hasWorldOrientation, tabId = "Transform", name = "World Orientation")
	public Quat4d getWorldOrientation() {
		return getWorldOrientation(new Quat4d(orientation));
	}
	
	public Quat4d getWorldOrientation(Quat4d localOrientation) {
		IG3DNode parent = (IG3DNode)getParent();
		if (parent == null)
			return localOrientation;
		return NodeTools.getWorldOrientation(parent, localOrientation);
	}
	
	@Override
	public Vector3d getLocalPosition(Vector3d worldPosition) {
		IG3DNode parent = (IG3DNode)getParent();
		if (parent == null)
			return worldPosition;
		return NodeTools.getLocalPosition(parent,new Vector3d(worldPosition));
	}
	
	@Override
	public Quat4d getLocalOrientation(Quat4d worldOrientation) {
		IG3DNode parent = (IG3DNode)getParent();
		if (parent == null)
			return worldOrientation;
		return NodeTools.getLocalOrientation(parent, new Quat4d(worldOrientation));
	}
	
	@Override
	@SetPropertyValue(G3D.URIs.hasWorldPosition)
	public void setWorldPosition(Vector3d position) {
		Vector3d localPos = getLocalPosition(position);
		setPosition(localPos);
	}
	
	@Override
	@SetPropertyValue(G3D.URIs.hasWorldOrientation)
	public void setWorldOrientation(Quat4d orientation) {
		Quat4d localOr = getLocalOrientation(orientation);
		setOrientation(localOr);
	}
	
	@Override
	public <C> C getAdapter(Class<C> adapter) {
		if (adapter.isInstance(this))
			return adapter.cast(this);
		return null;
	}
	
	public String getUniqueName(String prefix) {
		Set<String> names = new HashSet<String>();
		for (IP3DNode node : getNodes()) {
			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++;
		}
	}

	
}