/******************************************************************************
 * Spine Runtimes Software License
 * Version 2.1
 * 
 * Copyright (c) 2013, Esoteric Software
 * All rights reserved.
 * 
 * You are granted a perpetual, non-exclusive, non-sublicensable and
 * non-transferable license to install, execute and perform the Spine Runtimes
 * Software (the "Software") solely for internal use. Without the written
 * permission of Esoteric Software (typically granted by licensing Spine), you
 * may not (a) modify, translate, adapt or otherwise create derivative works,
 * improvements of the Software or develop new applications using the Software
 * or (b) remove, delete, alter or obscure any trademarks or any copyright,
 * trademark, patent or other intellectual property or proprietary rights
 * notices on or in the Software, including any copy thereof. Redistributions
 * in binary or source form must include this license and terms.
 * 
 * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 * EVENT SHALL ESOTERIC SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/

using System;
using System.Collections.Generic;

namespace Spine {
	public class IkConstraint {
		private const float radDeg = 180 / (float)Math.PI;

		internal IkConstraintData data;
		internal List<Bone> bones = new List<Bone>();
		internal Bone target;
		internal int bendDirection = 1;
		internal float mix = 1;

		public IkConstraintData Data { get { return data; } }
		public List<Bone> Bones { get { return bones; } }
		public Bone Target { get { return target; } set { target = value; } }
		public int BendDirection { get { return bendDirection; } set { bendDirection = value; } }
		public float Mix { get { return mix; } set { mix = value; } }

		public IkConstraint (IkConstraintData data, Skeleton skeleton) {
			this.data = data;
			mix = data.mix;
			bendDirection = data.bendDirection;

			bones = new List<Bone>(data.bones.Count);
			foreach (BoneData boneData in data.bones)
				bones.Add(skeleton.FindBone(boneData.name));
			target = skeleton.FindBone(data.target.name);
		}

		public void apply () {
			Bone target = this.target;
			List<Bone> bones = this.bones;
			switch (bones.Count) {
			case 1:
				apply(bones[0], target.worldX, target.worldY, mix);
				break;
			case 2:
				apply(bones[0], bones[1], target.worldX, target.worldY, bendDirection, mix);
				break;
			}
		}

		override public String ToString () {
			return data.name;
		}

		/// <summary>Adjusts the bone rotation so the tip is as close to the target position as possible. The target is specified
		/// in the world coordinate system.</summary>
		static public void apply (Bone bone, float targetX, float targetY, float alpha) {
			float parentRotation = (!bone.data.inheritRotation || bone.parent == null) ? 0 : bone.parent.worldRotation;
			float rotation = bone.rotation;
			float rotationIK = (float)Math.Atan2(targetY - bone.worldY, targetX - bone.worldX) * radDeg - parentRotation;
			bone.rotationIK = rotation + (rotationIK - rotation) * alpha;
		}

		/// <summary>Adjusts the parent and child bone rotations so the tip of the child is as close to the target position as
		/// possible. The target is specified in the world coordinate system.</summary>
		/// <param name="child">Any descendant bone of the parent.</param>
		static public void apply (Bone parent, Bone child, float targetX, float targetY, int bendDirection, float alpha) {
			float childRotation = child.rotation, parentRotation = parent.rotation;
			if (alpha == 0) {
				child.rotationIK = childRotation;
				parent.rotationIK = parentRotation;
				return;
			}
			float positionX, positionY;
			Bone parentParent = parent.parent;
			if (parentParent != null) {
				parentParent.worldToLocal(targetX, targetY, out positionX, out positionY);
				targetX = (positionX - parent.x) * parentParent.worldScaleX;
				targetY = (positionY - parent.y) * parentParent.worldScaleY;
			} else {
				targetX -= parent.x;
				targetY -= parent.y;
			}
			if (child.parent == parent) {
				positionX = child.x;
				positionY = child.y;
			} else {
				child.parent.localToWorld(child.x, child.y, out positionX, out positionY);
				parent.worldToLocal(positionX, positionY, out positionX, out positionY);
			}
			float childX = positionX * parent.worldScaleX, childY = positionY * parent.worldScaleY;
			float offset = (float)Math.Atan2(childY, childX);
			float len1 = (float)Math.Sqrt(childX * childX + childY * childY), len2 = child.data.length * child.worldScaleX;
			// Based on code by Ryan Juckett with permission: Copyright (c) 2008-2009 Ryan Juckett, http://www.ryanjuckett.com/
			float cosDenom = 2 * len1 * len2;
			if (cosDenom < 0.0001f) {
				child.rotationIK = childRotation + ((float)Math.Atan2(targetY, targetX) * radDeg - parentRotation - childRotation)
					* alpha;
				return;
			}
			float cos = (targetX * targetX + targetY * targetY - len1 * len1 - len2 * len2) / cosDenom;
			if (cos < -1)
				cos = -1;
			else if (cos > 1)
				cos = 1;
			float childAngle = (float)Math.Acos(cos) * bendDirection;
			float adjacent = len1 + len2 * cos, opposite = len2 * (float)Math.Sin(childAngle);
			float parentAngle = (float)Math.Atan2(targetY * adjacent - targetX * opposite, targetX * adjacent + targetY * opposite);
			float rotation = (parentAngle - offset) * radDeg - parentRotation;
			if (rotation > 180)
				rotation -= 360;
			else if (rotation < -180) //
				rotation += 360;
			parent.rotationIK = parentRotation + rotation * alpha;
			rotation = (childAngle + offset) * radDeg - childRotation;
			if (rotation > 180)
				rotation -= 360;
			else if (rotation < -180) //
				rotation += 360;
			child.rotationIK = childRotation + (rotation + parent.worldRotation - child.parent.worldRotation) * alpha;
		}
	}
}
