package org.simantics.plant3d.scenegraph;

import java.util.Collections;
import java.util.Map;

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

import org.simantics.g3d.math.MathTools;
import org.simantics.g3d.property.annotations.GetPropertyValue;
import org.simantics.g3d.property.annotations.PropertyContributor;
import org.simantics.objmap.graph.annotations.RelatedGetObj;
import org.simantics.objmap.graph.annotations.RelatedSetObj;
import org.simantics.plant3d.ontology.Plant3D;
import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint;
import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.Direction;
import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.PointType;
import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.PositionType;
import org.simantics.plant3d.scenegraph.controlpoint.PipingRules;

/**
 * 
 * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
 *
 */
@PropertyContributor
public abstract class PipelineComponent extends GeometryNode {

	
	private PipeRun pipeRun;
	private PipeRun alternativePipeRun;
	private PipelineComponent next;
	private PipelineComponent previous;
	
	public PipeRun getPipeRun() {
		return pipeRun;
	}
	
	/**
	 * Sets the pipe run.
	 * 
	 * With in-line,turn, and end components, the pipe run is the parent object in the scene-graph.
	 * With nozzles, the pipe run setting is explicit (nozzle has to be linked to the piperun, since the parent object is equipment).
	 * With size change components (in-line), there is also alternative pipe run, which must match the next component's pipe run.
	 * 
	 * @param pipeRun
	 */
	public void setPipeRun(PipeRun pipeRun) {
		if (pipeRun == this.pipeRun)
			return;
		this.pipeRun = pipeRun;
		if (getControlPoint() != null) {
			getControlPoint().deattach();
			if (pipeRun != null) {
				pipeRun.addChild(getControlPoint());
			}
		}
		updateParameters();
	}
	
	@RelatedGetObj(Plant3D.URIs.HasAlternativePipeRun)
	public PipeRun getAlternativePipeRun() {
		return alternativePipeRun;
	}
	
	@RelatedSetObj(Plant3D.URIs.HasAlternativePipeRun)
	public void setAlternativePipeRun(PipeRun pipeRun) {
		if (this.alternativePipeRun == pipeRun)
			return;
		this.alternativePipeRun = pipeRun;
		if (getControlPoint().isDualInline()) {
			PipeControlPoint sub = getControlPoint().getSubPoint().get(0);
			if (sub.getParent() != this.alternativePipeRun)
				this.alternativePipeRun.addChild(sub);
		}
		firePropertyChanged(Plant3D.URIs.HasAlternativePipeRun);
	}
	
	@Override
	public void updateParameters() {
		setParameterMap(updateParameterMap());
		super.updateParameters();
	}
	
	public abstract void setType(String typeURI) throws Exception;
	
	@RelatedGetObj(Plant3D.URIs.HasNext)
	public PipelineComponent getNext() {
		return next;
	}
	
	@RelatedSetObj(Plant3D.URIs.HasNext)
	public void setNext(PipelineComponent comp) {
		if (next == comp)
			return;
		if (this.next != null)
			this.next._removeRef(this);
		this.next = comp;
		this.syncnext = false;
		syncNext();
		firePropertyChanged(Plant3D.URIs.HasNext);
		if (comp != null)
			comp.sync();
//		System.out.println(this + " next " + comp);
	}
	
	
	@RelatedGetObj(Plant3D.URIs.HasPrevious)
	public PipelineComponent getPrevious() {
		return previous;
	}
	
	@RelatedSetObj(Plant3D.URIs.HasPrevious)
	public void setPrevious(PipelineComponent comp) {
		if (previous == comp)
			return;
		if (this.previous != null)
			this.previous._removeRef(this);
		this.previous = comp;
		this.syncprev = false;
		syncPrevious();
		firePropertyChanged(Plant3D.URIs.HasPrevious);
		if (comp != null)
			comp.sync();
//		System.out.println(this + " prev " + comp);
	}
	private PipelineComponent branch0;
	
	@RelatedGetObj(Plant3D.URIs.HasBranch0)
	public PipelineComponent getBranch0() {
		return branch0;
	}
	
	@RelatedSetObj(Plant3D.URIs.HasBranch0)
	public void setBranch0(PipelineComponent comp) {
		if (branch0 == comp)
			return;
		if (this.branch0 != null)
			this.branch0._removeRef(this);
		this.branch0 = comp;
		this.syncbr0 = false;
		syncBranch0();
		firePropertyChanged(Plant3D.URIs.HasBranch0);
		if (comp != null)
			comp.sync();
//		System.out.println(this + " next " + comp);
	}

	@GetPropertyValue(name="Previous",tabId="Debug",value=Plant3D.URIs.HasPrevious)
	public String getPreviousDebug() {
		if (previous == null)
			return null;
		return previous.getName();
	}
	
	@GetPropertyValue(name="Next",tabId="Debug",value=Plant3D.URIs.HasNext)
	public String getNextDebug() {
		if (next == null)
			return null;
		return next.getName();
	}
	
	@GetPropertyValue(name="Branch0",tabId="Debug",value=Plant3D.URIs.HasBranch0)
	public String getBR0Debug() {
		if (branch0 == null)
			return null;
		return branch0.getName();
	}

	
	
	private PipeControlPoint getBranchPoint() {
		PipeControlPoint branchPoint;
		if (getControlPoint().getSubPoint().size() > 0) {
			branchPoint = getControlPoint().getSubPoint().get(0);
		} else {
			if (branch0.getPipeRun() == null)
				return null;
			branchPoint = new PipeControlPoint(this,branch0.getPipeRun());
			branchPoint.setFixed(false);
			branchPoint.setType(PointType.END);
			branchPoint.parent = getControlPoint();
			getControlPoint().children.add(branchPoint);
			branchPoint.setWorldOrientation(getControlPoint().getWorldOrientation());
			branchPoint.setWorldPosition(getControlPoint().getWorldPosition());
		}
		return branchPoint;
	}
	
	private boolean _connectNext(PipeControlPoint pcp, PipeControlPoint nextPCP) {
		if (nextPCP == null)
			return false;
		if (pcp.getNext() != nextPCP) {
			pcp.setNext(nextPCP);
		}
		if (pcp.isDualInline()) {
			PipeControlPoint sub = pcp.getSubPoint().get(0);
			if (sub.getNext() != nextPCP)
				sub.setNext(nextPCP);
		}
		return true;
	}
	
	private boolean  _connectPrev(PipeControlPoint pcp, PipeControlPoint prevPCP) {
		if (prevPCP == null)
			return false;
		if (prevPCP.isDualInline())
			prevPCP = prevPCP.getSubPoint().get(0);
		if (pcp.getPrevious() != prevPCP) {
			pcp.setPrevious(prevPCP);
		}
		if (pcp.isDualInline()) {
			PipeControlPoint sub = pcp.getSubPoint().get(0);
			if (sub.getPrevious() != prevPCP)
				sub.setPrevious(prevPCP);
		}
		return true;
	}
	
	// When link to a component is removed, also link to the other direction must be removed at the same time, or
	// Control point structure is left into illegal state.
	private void _removeRef(PipelineComponent comp) {
		if (next == comp) {
			next = null;
			syncnext = false;
			syncNext();
		} else if (previous == comp) {
			previous = null;
			syncprev = false;
			syncPrevious();
		} else if (branch0 == comp) {
			branch0 = null;
			syncbr0 = false;
			syncBranch0();
		}
	}
	
	boolean syncnext = false;
	private void syncNext() {
		if (syncnext)
			return;
		syncnext = _syncNext();
	}
	
	
	private boolean _syncNext() {
		PipeControlPoint pcp = getControlPoint();
		if (pcp != null) {
			
			if (next != null ) {
				if (next.getControlPoint() != null) {
					
					// TODO, relying that the other direction is connected.
					boolean nxt = next.getPrevious() == this;
					boolean br0 = next.getBranch0() == this;
					if (nxt){
						return _connectNext(pcp, next.getControlPoint());	
					} else if (br0) {
						return _connectNext(pcp, next.getBranchPoint());
					} else {
						return false;
					}
				} else {
					return false;
				}
				
			} else if (pcp.getNext() != null) {
				pcp.setNext(null);
				return true;
			}
		} else {
			return false;
		}
		return true;
	}
	
	boolean syncprev = false;
	private void syncPrevious() {
		if (syncprev)
			return;
		syncprev = _syncPrevious();
	}
	
	private boolean _syncPrevious() {
		PipeControlPoint pcp = getControlPoint();
		if (pcp != null) {
			if (previous != null ) {
				if (previous.getControlPoint() != null) {
					
					// TODO, relying that the other direction is connected.
					boolean prev = previous.getNext() == this;
					boolean br0 = previous.getBranch0() == this;
					if (prev){
						return _connectPrev(pcp, previous.getControlPoint());	
					} else if (br0) {
						return _connectPrev(pcp, previous.getBranchPoint());
					} else {
						return false;
					}
				} else {
					return false;
				}
				
			} else if (pcp.getPrevious() != null) {
				pcp.setPrevious(null);
				return true;
			}
		} else {
			return false;
		}
		return true;
	}
	
	boolean syncbr0 = false;
	private void syncBranch0() {
		if (syncbr0)
			return;
		syncbr0 = _syncBranch0();
	}
	
	private boolean _syncBranch0() {
		if (getControlPoint() != null) {
			if (getControlPoint().isDualInline()) {
				branch0 = null;
				return false;
			}
			if (branch0 != null) {
				if (branch0.getControlPoint() != null) {
					PipeControlPoint branchPoint = getBranchPoint();
					if (branchPoint == null)
						return false;
					PipeControlPoint pcp = branch0.getControlPoint();
					// TODO, relying that the other direction is connected.
					boolean next = branch0.getPrevious() == this; // this --> branch0
					boolean prev = branch0.getNext() == this;
					if (next) {
						_connectNext(branchPoint, pcp);
					} else if (prev){
						_connectPrev(branchPoint, pcp);	
					} else {
						return false;
					}
					
				} else {
					return false;
				}
				
			} else if (getControlPoint().getSubPoint().size() > 0) { // TODO : this may cause problems? (Removes branch point, before branch has been set?)
				getControlPoint().getSubPoint().get(0).remove();
				getControlPoint().children.clear();
				return true;
			}
		} else {
			return false;
		}
		return true;
	}
	
	public void sync() {
		syncPrevious();
		syncNext();
		syncBranch0();
	}
	
	public void sync2() {
//		if (getControlPoint().isDualInline()) {
//			PipeControlPoint sub = getControlPoint().getSubPoint().get(0);
//			next.getControlPoint().getPipeRun().addChild(sub);
//		}
		getControlPoint()._setWorldOrientation(getWorldOrientation());
		getControlPoint()._setWorldPosition(getWorldPosition());
	}
	
	public Map<String,Object> updateParameterMap() {
		return Collections.EMPTY_MAP;
	}
	
	public abstract String getType();
	public abstract PipeControlPoint getControlPoint();
	
	@Override
	public void remove() {
		PipeControlPoint pcp = getControlPoint();
		// Second check is needed, when remove process is initiated from control point.
		if (pcp != null && pcp.getPipelineComponent() != null) {
			pcp.remove();
		}
		super.remove();
	}
	
	public void removeAndSplit() {
	    PipeControlPoint pcp = getControlPoint();
        // Second check is needed, when remove process is initiated from control point.
        if (pcp != null && pcp.getPipelineComponent() != null) {
            pcp.removeAndSplit();
        }
        super.remove();
	}

	@Override
	protected double[] getColor() {
		if (getControlPoint() == null || !getControlPoint().isFixed())
			return new double[]{0.7,0.7,0.7};
		else
			return new double[]{1.0,0.0,0.0};
	}
	
	@Override
	protected double[] getSelectedColor() {
		return new double[]{0.5,0,0.5};
	}
	
	@Override
	public void setOrientation(Quat4d orientation) {
		if (MathTools.equals(orientation, getOrientation()))
			return;
		super.setOrientation(orientation);
		if (getControlPoint() != null) {
			getControlPoint()._setWorldOrientation(getWorldOrientation());
			try {
				PipingRules.requestUpdate(getControlPoint());
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}	
		}
	}
	
	@Override
	public void setPosition(Vector3d position) {
		if (MathTools.equals(position, getPosition()))
			return;
		super.setPosition(position);
		if (getControlPoint() != null) {
			getControlPoint()._setWorldPosition(getWorldPosition());
			try {
				PipingRules.requestUpdate(getControlPoint());
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
	
	public void _setWorldPosition(Vector3d position) {
		Vector3d localPos = getLocalPosition(position);
		super.setPosition(localPos);
	}
	
	public void _setWorldOrientation(Quat4d orientation) {
		Quat4d localOr = getLocalOrientation(orientation);
		super.setOrientation(localOr);
	}
	
	@GetPropertyValue(name="Flow Length", value="flowlength", tabId = "Default")
	public Double getFlowLength() {
		PipeControlPoint pcp = getControlPoint(); 
		if (pcp == null)
			return null;
		switch (pcp.getType()) {
			case INLINE:
				return pcp.getLength();
			case END:
				return null;
			case TURN: {
				double r = getPipeRun().getTurnRadius();
				double a = pcp.getTurnAngle();
				return a*r;
			}
			default:
				return null;
		}
	}
	
	public void getEnds(Tuple3d p1, Tuple3d p2) {
		getControlPoint().getControlPointEnds(p1, p2);
	}
	
	public void getEndDirections(Tuple3d v1, Tuple3d v2) {
		getControlPoint().getEndDirections(v1, v2);
	}
	
	public void getCentroid(Tuple3d p) {
		PipeControlPoint pcp = getControlPoint(); 
		if (pcp == null)
			throw new IllegalStateException("No centroid defined");
		
		switch (pcp.getType()) {
		case INLINE:
		case END:
			// Just return the world location
			if (!pcp.isSizeChange()) {
				p.set(pcp.getWorldPosition());
				return;
			}
			
			// Calculate center of mass for the frustum
			double r1 = getPipeRun().getPipeDiameter();
			double r2 = getAlternativePipeRun().getPipeDiameter();
			
			Vector3d p1 = new Vector3d(), p2 = new Vector3d();
			pcp.getInlineControlPointEnds(p1, p2);
			
			// Squared sum of radii
			double r12 = r1 + r2;
			r12 *= r12;
			
			// The larger of the radii form the base of a frustum
			double rmax = Math.max(r1, r2);
			
			// Relative distance from the base of the frustum
			double h = (r12 + 2*rmax*rmax) / (4 * (r12 - r1*r2));
			
			// Relative distance from p1 to p2
			if (r1 < r2)
				h = 1 - h;
			
			p2.sub(p1);
			p1.scaleAdd(h, p2);
			
			p.set(p1);
			return;
		case TURN: {
			Vector3d loc = pcp.getRealPosition(PositionType.PREVIOUS);
			
			double r = getPipeRun().getTurnRadius();
			double a = pcp.getTurnAngle();
			double pipeRadius = pcp.getPipeRun().getPipeDiameter() / 2;
			
			// Unit vector in inlet flow direction
			Vector3d inletDir = pcp.getPathLegDirection(Direction.PREVIOUS);
			inletDir.scale(-1.0);
			inletDir.normalize();
			
			// Normal to both inletDir and turn axis in world coordinates
			Vector3d outletDir = pcp.getPathLegDirection(Direction.NEXT);
			Vector3d normal = new Vector3d(inletDir);
			normal.scaleAdd(-inletDir.dot(outletDir), outletDir);
			normal.normalize();
			
			// Location of turn axis
			Vector3d center = new Vector3d(normal);
			center.scaleAdd(r, loc);
			
			// Add vector components from axis to centroid
			double c = r + pipeRadius * pipeRadius / (4 * r);
			double c1 = c * Math.sin(a) / a;
			double c2 = c * (1 - Math.cos(a)) / a;
			normal.scale(-c1);
			inletDir.scale(c2);
			center.add(normal);
			center.add(inletDir);
		
			// Return value
			p.set(center);
			return;
		}
		default:
			throw new IllegalStateException("No centroid defined");
		}
	}
	
	public double getVolume() {
		PipeControlPoint pcp = getControlPoint(); 
		if (pcp == null)
			throw new IllegalStateException("No centroid defined");
		
		double pipeRadius = getPipeRun().getPipeDiameter() / 2;
		
		switch (pcp.getType()) {
		case INLINE:
		case END:
			if (!pcp.isSizeChange()) {
				// Just return the cylinder volume
				return pcp.getLength() * Math.PI * pipeRadius * pipeRadius;
			}
			
			// Calculate center of mass for the frustum
			double r1 = pipeRadius;
			double r2 = getAlternativePipeRun().getPipeDiameter() / 2;
			return pcp.getLength() * Math.PI * (r1*r1 + r1*r2 + r2*r2) / 4;
		case TURN: {
			double r = getPipeRun().getTurnRadius();
			double a = pcp.getTurnAngle();
			return r * a * Math.PI * pipeRadius * pipeRadius;
		}
		default:
			throw new IllegalStateException("No centroid defined");
		}
	}
}