package org.simantics.plant3d.scenegraph;

import java.util.HashMap;
import java.util.Map;

import javax.vecmath.Point3d;
import javax.vecmath.Vector3d;

import org.simantics.g3d.math.MathTools;
import org.simantics.g3d.property.annotations.GetPropertyValue;
import org.simantics.g3d.property.annotations.SetPropertyValue;
import org.simantics.g3d.scenegraph.base.ParentNode;
import org.simantics.objmap.graph.annotations.DynamicGraphType;
import org.simantics.objmap.graph.annotations.GetType;
import org.simantics.objmap.graph.annotations.RelatedGetValue;
import org.simantics.objmap.graph.annotations.RelatedSetValue;
import org.simantics.objmap.graph.annotations.SetType;
import org.simantics.plant3d.ontology.Plant3D;
import org.simantics.plant3d.scenegraph.controlpoint.ControlPointFactory;
import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint;
import org.simantics.plant3d.scenegraph.controlpoint.PipingRules;

@DynamicGraphType(Plant3D.URIs.InlineComponent)
public class InlineComponent extends PipelineComponent {

	private String type;
	private PipeControlPoint controlPoint;
	private boolean componentCalculatedOffset = false;
	
	@GetType(Plant3D.URIs.InlineComponent)
	public String getType() {
		return type;
	}
	
	@SetType(Plant3D.URIs.InlineComponent)
	public void setType(String type) throws Exception{
		this.type = type;
		controlPoint = ControlPointFactory.create(this);
		
	}
	
	@Override
	public PipeControlPoint getControlPoint() {
		return controlPoint;
	}
	
	@Override
	public void setParent(ParentNode<?> parent, String name) {
		super.setParent(parent, name);
		setPipeRun((PipeRun)parent);
	}
	
	public boolean isVariableLength() {
		return !controlPoint.isFixed();
	}
	
	public boolean isModifialble() {
        return controlPoint.isMod();
    }
	
	public boolean isSizeChange() {
		return controlPoint.isSizeChange();
	}
	
	@RelatedGetValue(Plant3D.URIs.HasRotationAngle)
	@GetPropertyValue(name="Rotation Angle", value=Plant3D.URIs.HasRotationAngle, tabId = "Default")
	public Double getRotationAngle() {
		if (!controlPoint.isRotate())
			return null;
		Double d = controlPoint.getRotationAngle();
		if (d == null)
			return 0.0;
		return MathTools.radToDeg(d);
	}
	
	@RelatedSetValue(Plant3D.URIs.HasRotationAngle)
	@SetPropertyValue(value=Plant3D.URIs.HasRotationAngle)
	public void setRotationAngle(Double angle) {
		if (!controlPoint.isRotate())
			return;
		
		if (angle == null || Double.isInfinite(angle) || Double.isNaN(angle)) {
			return;
		}
		angle = MathTools.degToRad(angle);
		if (controlPoint.getRotationAngle() != null && Math.abs(controlPoint.getRotationAngle()-angle) < MathTools.NEAR_ZERO)
			return;
		controlPoint.setRotationAngle(angle);
		try {
			PipingRules.requestUpdate(getControlPoint());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	
	}
	
	@RelatedGetValue(Plant3D.URIs.IsReversed)
	@GetPropertyValue(name="Reverse", value=Plant3D.URIs.IsReversed, tabId = "Default")
	public Boolean isReversed() {
		if (!controlPoint.isReverse())
			return null;
		Boolean d = controlPoint._getReversed();
		return d;
	}
	@RelatedSetValue(Plant3D.URIs.IsReversed)
	@SetPropertyValue(value=Plant3D.URIs.IsReversed)
	public void setReversed(Boolean reverse) {
		if (!controlPoint.isReverse())
			return;
		
		if (reverse == null) {
			return;
		}
		controlPoint.setReversed(reverse);
		try {
			PipingRules.requestUpdate(getControlPoint());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	
	}
	
	@Override
	public void updateParameters() {
		super.updateParameters();
		if (!isVariableLength()) {
			Map<String,Object> calculated = getCalculatedParameters();
			
			if (calculated.containsKey("offset")) {
				controlPoint.setOffset((Double)calculated.get("offset"));
				componentCalculatedOffset = true;
			} else {
				componentCalculatedOffset = false;
			}
			
			Map<String,Object> total = getTotalParameters();
			
			if (total.containsKey("length")) {
                controlPoint.setLength((Double)total.get("length"));
            }
			
			PipingRules.requestUpdate(getControlPoint());
		}
	}
	
	@Override
	public void setPipeRun(PipeRun pipeRun) {
		// TODO Auto-generated method stub
		super.setPipeRun(pipeRun);
		if (getPipeRun() != null && getAlternativePipeRun() != null) {
			updateOffset();
		}
	}
	
	@Override
	public void setAlternativePipeRun(PipeRun pipeRun) {
		// TODO Auto-generated method stub
		super.setAlternativePipeRun(pipeRun);
		if (getPipeRun() != null && getAlternativePipeRun() != null) {
			updateOffset();
		}
	}
	
	private void updateOffset() {
		if (!componentCalculatedOffset && getControlPoint().isOffset()) {
			getControlPoint().setOffset(getPipeRun().getPipeDiameter()*0.5 - getAlternativePipeRun().getPipeDiameter()*0.5);
		}
	}

	@Override
	public Map<String, Object> updateParameterMap() {
		Map<String,Object> map = new HashMap<String, Object>();
		if (controlPoint != null) {
			if (!Double.isNaN(controlPoint.getLength()) && controlPoint.isVariableLength())
				map.put("length", controlPoint.getLength());
			if (controlPoint.isDualInline()) {
				PipeControlPoint sub = controlPoint.getDualSub();
				PipeRun pipeRun2 = sub.getPipeRun();
				if (pipeRun2 != null) {
					map.put("radius2", pipeRun2.getPipeDiameter() * 0.5);
				}
				if (controlPoint.isOffset() && !componentCalculatedOffset) {
					map.put("offset", controlPoint.getOffset());
				}
			}
		}
			
		PipeRun pipeRun = getPipeRun();
		if (pipeRun != null) {
			map.put("radius", pipeRun.getPipeDiameter() * 0.5);
		}
		return map;
	}
	
	@SetPropertyValue("flowlength")
	public void setFlowLength(double l) {
		// Not allowed, if not at the end of a run
		if (getNext() != null)
			throw new IllegalStateException("Cannot edit length of a connected component");
		
		double length = getFlowLength();
		Point3d p1 = new Point3d(), p2 = new Point3d();
		controlPoint.getControlPointEnds(p1, p2);
		Vector3d dir = new Vector3d();
		dir.sub(p2, p1);
		dir.normalize();
		dir.scale((l - length)/2);
		Vector3d pos = new Vector3d(getPosition());
		pos.add(dir);
		setPosition(pos);
	}
}