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.Type;
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;
	
	/**
	 * 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(Type.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();
					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 PipeRun getPipeRun() {
		return pipeRun;
	}
	
	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();
	}

	@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 getControlPointEnds(Tuple3d p1, Tuple3d p2) {
		getControlPoint().getControlPointEnds(p1, p2);
	}
	
	public Vector3d getNormal() {
		Vector3d v = new Vector3d();
		MathTools.rotate(getWorldOrientation(), MathTools.Z_AXIS, v);
		return v;
	}
	
}