/*******************************************************************************
 * Copyright (c) 2012, 2013 Association for Decentralized Information Management in
 * Industry THTH ry.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     VTT Technical Research Centre of Finland - initial API and implementation
 *******************************************************************************/
package org.simantics.g3d.property;

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

import org.simantics.g3d.Activator;
import org.simantics.g3d.math.EulerTools;
import org.simantics.g3d.math.EulerTools.Order;
import org.simantics.g3d.math.MathTools;
import org.simantics.g3d.preferences.PreferenceConstants;

public class QuatPropertyManipulator implements PropertyManipulator {
	
	ValueProvider provider;
	protected Object input;
	
	enum EditType {QUATERNION,AXIS_ANGLE,EULER};
	
	EditType type = EditType.QUATERNION;
	Order order;
	
	boolean editMode;
	Object editValue = null;
	
	public QuatPropertyManipulator(ValueProvider provider, Object input) {
		this.provider = provider;
		this.input = input;
		
		String set = Activator.getDefault().getPreferenceStore().getString(PreferenceConstants.ORIENTATION_PRESENTATION);
		if ("quat".equals(set)) {
			type = EditType.QUATERNION;
		} else if ("aa".equals(set)) {
			type = EditType.AXIS_ANGLE;
		} else if ("euler".equals(set)) {
			type = EditType.EULER;
			String eulerOrder = Activator.getDefault().getPreferenceStore().getString(PreferenceConstants.EULER_ANGLE_ORDER);
			order = Order.valueOf(eulerOrder);
			if (order == null)
				order = Order.YXZ;
		}
	}
	
	@Override
	public String getDescription(int i) {
		switch (type) {
		case QUATERNION:
			if (i == 0)
				return "X";
			if (i == 1)
				return "Y";
			if (i == 2)
				return "Z";
			if (i == 3)
				return "W";
			break;
		case AXIS_ANGLE:
			if (i == 0)
				return "X";
			if (i == 1)
				return "Y";
			if (i == 2)
				return "Z";
			if (i == 3)
				return "Angle";
			break;
		case EULER:
			if (i > 3)
				return null;
			return order.toString().substring(i, i+1);
		default:
			break;
		}
		return null;
	}
	
	@Override
	public int getValueCount() {
		switch (type) {
		case QUATERNION:
			return 4;
		case AXIS_ANGLE:
			return 4;
		case EULER:
			return 3;
		default:
			break;
		}
		return 0;
	}
	
	@Override
	public String getValue(int i) {
		try {
			Quat4d q = (Quat4d) provider.getValue(input);
			double d = 0;
			switch (type) {
			case QUATERNION:
				if (editMode)
					q = (Quat4d)editValue;
				else
					q = new Quat4d(q);
				
				if (i == 0)
					d = q.x;
				if (i == 1)
					d = q.y;
				if (i == 2)
					d = q.z;
				if (i == 3)
					d = q.w;
				break;
				
			case AXIS_ANGLE: {
				AxisAngle4d aa;
				if (editMode)
					aa = (AxisAngle4d)editValue;
				else {
					aa = new AxisAngle4d();
					aa.set(q);
				}
				if (i == 0)
					d = aa.x;
				if (i == 1)
					d = aa.y;
				if (i == 2)
					d = aa.z;
				if (i == 3)
					d = MathTools.radToDeg(aa.angle);
				break;
			}
			case EULER: {
				Vector3d aa;
				if (editMode)
					aa = (Vector3d)editValue;
				else
					aa = EulerTools.getEulerFromQuat(order, q);//MathTools.getEuler(q);
				if (i == 0)
					d = aa.x;
				if (i == 1)
					d = aa.y;
				if (i == 2)
					d = aa.z;
				d = MathTools.radToDeg(d);
			}

			default:
				break;
			}
			return Double.toString(d);
		} catch (Exception e) {
			return null;
		}
	}
	
	
	
	@Override
	public String setValue(String value, int i) {
		try {
			Double d = Double.parseDouble(value);
			Quat4d q = (Quat4d) provider.getValue(input);
			switch (type) {
			case QUATERNION:
				if (editMode)
					q = (Quat4d)editValue;
				else
					q = new Quat4d(q);
				
				if (i == 0)
					q.x = d;
				if (i == 1)
					q.y = d;
				if (i == 2)
					q.z = d;
				if (i == 3)
					q.w = d;
				break;
			case AXIS_ANGLE: {
				AxisAngle4d aa;
				if (editMode)
					aa = (AxisAngle4d) editValue;
				else {
					aa = new AxisAngle4d();
					aa.set(q);
				}
				if (i == 0)
					aa.x = d;
				if (i == 1)
					aa.y = d;
				if (i == 2)
					aa.z = d;
				if (i == 3)
					aa.angle = MathTools.degToRad(d);
				q = new Quat4d();
				MathTools.getQuat(aa,q);
				break;
			}
			case EULER: {
				Vector3d e;
				if (editMode)
					e = (Vector3d)editValue;
				else 
					e = EulerTools.getEulerFromQuat(order, q);//MathTools.getEuler(q);
				d = MathTools.degToRad(d);
				if (i == 0)
					e.x = d;
				if (i == 1)
					e.y = d;
				if (i == 2)
					e.z = d;
				q = EulerTools.getQuatFromEuler(order, e);//MathTools.getQuat(e);
			}
			default:
				break;
			}
			q.normalize();
			setValue(q);
		} catch (Exception e) {
			return e.getMessage();
		}
		return null;
	}
	
	protected void setValue(Quat4d q) throws Exception {
		provider.setValue(input, q);
	}
	
	private void storeEditValue() {
		try {
			Quat4d q = (Quat4d) provider.getValue(input);
			switch (type) {
			case QUATERNION:
				editValue = q;
				break;
			case AXIS_ANGLE:
				AxisAngle4d aa = new AxisAngle4d();
				aa.set(q);
				editValue = aa;
				break;
			case EULER:
				Vector3d e = EulerTools.getEulerFromQuat(order, q);
				editValue = e;
				break;
			}
		} catch (Exception e) {
			
		}
	}
	
	@Override
	public boolean getEditMode() {
		return editMode;
	}
	
	@Override
	public void setEditMode(boolean b) {
		editMode = b;
		if (editMode) {
			storeEditValue();
		}
		
	}

}