// Based on code from github.com/go-gl/mathgl:
// Copyright 2014 The go-gl Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package quat

import (
	"zworld/plugin/math"
	"zworld/plugin/math/mat4"
	"zworld/plugin/math/vec3"
)

// RotationOrder is the order in which rotations will be transformed for the
// purposes of AnglesToQuat.
type RotationOrder int

// The RotationOrder constants represent a series of rotations along the given
// axes for the use of AnglesToQuat.
const (
	XYX RotationOrder = iota
	XYZ
	XZX
	XZY
	YXY
	YXZ
	YZY
	YZX
	ZYZ
	ZYX
	ZXZ
	ZXY
)

// T represents a Quaternion, which is an extension of the imaginary numbers;
// there's all sorts of interesting theory behind it. In 3D graphics we mostly
// use it as a cheap way of representing rotation since quaternions are cheaper
// to multiply by, and easier to interpolate than matrices.
//
// A Quaternion has two parts: W, the so-called scalar component, and "V", the
// vector component. The vector component is considered to be the part in 3D
// space, while W (loosely interpreted) is its 4D coordinate.
type T struct {
	W float32
	V vec3.T
}

// Ident returns the quaternion identity: W=1; V=(0,0,0).
//
// As with all identities, multiplying any quaternion by this will yield the same
// quaternion you started with.
func Ident() T {
	return T{1., vec3.New(0, 0, 0)}
}

// Rotate creates an angle from an axis and an angle relative to that axis.
//
// This is cheaper than HomogRotate3D.
func Rotate(angle float32, axis vec3.T) T {
	// angle = (float32(math.Pi) * angle) / 180.0

	c, s := math.Cos(angle/2), math.Sin(angle/2)

	return T{c, axis.Scaled(s)}
}

// X is a convenient alias for q.V[0]
func (q T) X() float32 {
	return q.V.X
}

// Y is a convenient alias for q.V[1]
func (q T) Y() float32 {
	return q.V.Y
}

// Z is a convenient alias for q.V[2]
func (q T) Z() float32 {
	return q.V.X
}

// Add adds two quaternions. It's no more complicated than
// adding their W and V components.
func (q1 T) Add(q2 T) T {
	return T{q1.W + q2.W, q1.V.Add(q2.V)}
}

// Sub subtracts two quaternions. It's no more complicated than
// subtracting their W and V components.
func (q1 T) Sub(q2 T) T {
	return T{q1.W - q2.W, q1.V.Sub(q2.V)}
}

// Mul multiplies two quaternions. This can be seen as a rotation. Note that
// Multiplication is NOT commutative, meaning q1.Mul(q2) does not necessarily
// equal q2.Mul(q1).
func (q1 T) Mul(q2 T) T {
	return T{q1.W*q2.W - vec3.Dot(q1.V, q2.V), vec3.Cross(q1.V, q2.V).Add(q2.V.Scaled(q1.W)).Add(q1.V.Scaled(q2.W))}
}

// Scale every element of the quaternion by some constant factor.
func (q1 T) Scale(c float32) T {
	return T{q1.W * c, vec3.New(q1.V.X*c, q1.V.Y*c, q1.V.Z*c)}
}

// Conjugate returns the conjugate of a quaternion. Equivalent to
// Quat{q1.W, q1.V.Mul(-1)}.
func (q1 T) Conjugate() T {
	return T{q1.W, q1.V.Scaled(-1)}
}

// Len gives the Length of the quaternion, also known as its Norm. This is the
// same thing as the Len of a Vec4.
func (q1 T) Len() float32 {
	return math.Sqrt(q1.W*q1.W + vec3.Dot(q1.V, q1.V))
}

// Norm is an alias for Len() since both are very common terms.
func (q1 T) Norm() float32 {
	return q1.Len()
}

// Normalize the quaternion, returning its versor (unit quaternion).
//
// This is the same as normalizing it as a Vec4.
func (q1 T) Normalize() T {
	length := q1.Len()

	if math.Equal(1, length) {
		return q1
	}
	if length == 0 {
		return Ident()
	}
	if length == math.InfPos {
		length = math.MaxValue
	}

	return T{q1.W * 1 / length, q1.V.Scaled(1 / length)}
}

// Inverse of a quaternion. The inverse is equivalent
// to the conjugate divided by the square of the length.
//
// This method computes the square norm by directly adding the sum
// of the squares of all terms instead of actually squaring q1.Len(),
// both for performance and precision.
func (q1 T) Inverse() T {
	return q1.Conjugate().Scale(1 / q1.Dot(q1))
}

// Rotate a vector by the rotation this quaternion represents.
// This will result in a 3D vector. Strictly speaking, this is
// equivalent to q1.v.q* where the "."" is quaternion multiplication and v is interpreted
// as a quaternion with W 0 and V v. In code:
// q1.Mul(Quat{0,v}).Mul(q1.Conjugate()), and
// then retrieving the imaginary (vector) part.
//
// In practice, we hand-compute this in the general case and simplify
// to save a few operations.
func (q1 T) Rotate(v vec3.T) vec3.T {
	cross := vec3.Cross(q1.V, v)
	// v + 2q_w * (q_v x v) + 2q_v x (q_v x v)
	return v.Add(cross.Scaled(2 * q1.W)).Add(vec3.Cross(q1.V.Scaled(2), cross))
}

// Mat4 returns the homogeneous 3D rotation matrix corresponding to the
// quaternion.
func (q1 T) Mat4() mat4.T {
	w, x, y, z := q1.W, q1.V.X, q1.V.Y, q1.V.Z
	return mat4.T{
		1 - 2*y*y - 2*z*z, 2*x*y + 2*w*z, 2*x*z - 2*w*y, 0,
		2*x*y - 2*w*z, 1 - 2*x*x - 2*z*z, 2*y*z + 2*w*x, 0,
		2*x*z + 2*w*y, 2*y*z - 2*w*x, 1 - 2*x*x - 2*y*y, 0,
		0, 0, 0, 1,
	}
}

// Dot product between two quaternions, equivalent to if this was a Vec4.
func (q1 T) Dot(q2 T) float32 {
	return q1.W*q2.W + vec3.Dot(q1.V, q2.V)
}

// ApproxEqual returns whether the quaternions are approximately equal, as if
// FloatEqual was called on each matching element
func (q1 T) ApproxEqual(q2 T) bool {
	return math.Equal(q1.W, q2.W) && q1.V.ApproxEqual(q2.V)
}

// OrientationEqual returns whether the quaternions represents the same orientation
//
// Different values can represent the same orientation (q == -q) because quaternions avoid singularities
// and discontinuities involved with rotation in 3 dimensions by adding extra dimensions
func (q1 T) OrientationEqual(q2 T) bool {
	return q1.OrientationEqualThreshold(q2, math.Epsilon)
}

// OrientationEqualThreshold returns whether the quaternions represents the same orientation with a given tolerence
func (q1 T) OrientationEqualThreshold(q2 T, epsilon float32) bool {
	return math.Abs(q1.Normalize().Dot(q2.Normalize())) > 1-math.Epsilon
}

// Slerp is *S*pherical *L*inear Int*erp*olation, a method of interpolating
// between two quaternions. This always takes the straightest path on the sphere between
// the two quaternions, and maintains constant velocity.
//
// However, it's expensive and Slerp(q1,q2) is not the same as Slerp(q2,q1)
func Slerp(q1, q2 T, amount float32) T {
	q1, q2 = q1.Normalize(), q2.Normalize()
	dot := q1.Dot(q2)

	// If the inputs are too close for comfort, linearly interpolate and normalize the result.
	if dot > 0.9995 {
		return Nlerp(q1, q2, amount)
	}

	// This is here for precision errors, I'm perfectly aware that *technically* the dot is bound [-1,1], but since Acos will freak out if it's not (even if it's just a liiiiitle bit over due to normal error) we need to clamp it
	dot = math.Clamp(dot, -1, 1)

	theta := math.Acos(dot) * amount
	c, s := math.Cos(theta), math.Sin(theta)
	rel := q2.Sub(q1.Scale(dot)).Normalize()

	return q1.Scale(c).Add(rel.Scale(s))
}

// Lerp is a *L*inear Int*erp*olation between two Quaternions, cheap and simple.
//
// Not excessively useful, but uses can be found.
func Lerp(q1, q2 T, amount float32) T {
	return q1.Add(q2.Sub(q1).Scale(amount))
}

// Nlerp is a *Normalized* *L*inear Int*erp*olation between two Quaternions. Cheaper than Slerp
// and usually just as good. This is literally Lerp with Normalize() called on it.
//
// Unlike Slerp, constant velocity isn't maintained, but it's much faster and
// Nlerp(q1,q2) and Nlerp(q2,q1) return the same path. You should probably
// use this more often unless you're suffering from choppiness due to the
// non-constant velocity problem.
func Nlerp(q1, q2 T, amount float32) T {
	return Lerp(q1, q2, amount).Normalize()
}

// FromAngles performs a rotation in the specified order. If the order is not
// a valid RotationOrder, this function will panic
//
// The rotation "order" is more of an axis descriptor. For instance XZX would
// tell the function to interpret angle1 as a rotation about the X axis, angle2 about
// the Z axis, and angle3 about the X axis again.
//
// Based off the code for the Matlab function "angle2quat", though this implementation
// only supports 3 single angles as opposed to multiple angles.
func FromAngles(angle1, angle2, angle3 float32, order RotationOrder) T {
	var s [3]float32
	var c [3]float32

	s[0], c[0] = math.Sincos(angle1 / 2)
	s[1], c[1] = math.Sincos(angle2 / 2)
	s[2], c[2] = math.Sincos(angle3 / 2)

	ret := T{}
	switch order {
	case ZYX:
		ret.W = c[0]*c[1]*c[2] + s[0]*s[1]*s[2]
		ret.V = vec3.T{
			X: c[0]*c[1]*s[2] - s[0]*s[1]*c[2],
			Y: c[0]*s[1]*c[2] + s[0]*c[1]*s[2],
			Z: s[0]*c[1]*c[2] - c[0]*s[1]*s[2],
		}
	case ZYZ:
		ret.W = c[0]*c[1]*c[2] - s[0]*c[1]*s[2]
		ret.V = vec3.T{
			X: c[0]*s[1]*s[2] - s[0]*s[1]*c[2],
			Y: c[0]*s[1]*c[2] + s[0]*s[1]*s[2],
			Z: s[0]*c[1]*c[2] + c[0]*c[1]*s[2],
		}
	case ZXY:
		ret.W = c[0]*c[1]*c[2] - s[0]*s[1]*s[2]
		ret.V = vec3.T{
			X: c[0]*s[1]*c[2] - s[0]*c[1]*s[2],
			Y: c[0]*c[1]*s[2] + s[0]*s[1]*c[2],
			Z: c[0]*s[1]*s[2] + s[0]*c[1]*c[2],
		}
	case ZXZ:
		ret.W = c[0]*c[1]*c[2] - s[0]*c[1]*s[2]
		ret.V = vec3.T{
			X: c[0]*s[1]*c[2] + s[0]*s[1]*s[2],
			Y: s[0]*s[1]*c[2] - c[0]*s[1]*s[2],
			Z: c[0]*c[1]*s[2] + s[0]*c[1]*c[2],
		}
	case YXZ:
		ret.W = c[0]*c[1]*c[2] + s[0]*s[1]*s[2]
		ret.V = vec3.T{
			X: c[0]*s[1]*c[2] + s[0]*c[1]*s[2],
			Y: s[0]*c[1]*c[2] - c[0]*s[1]*s[2],
			Z: c[0]*c[1]*s[2] - s[0]*s[1]*c[2],
		}
	case YXY:
		ret.W = c[0]*c[1]*c[2] - s[0]*c[1]*s[2]
		ret.V = vec3.T{
			X: c[0]*s[1]*c[2] + s[0]*s[1]*s[2],
			Y: s[0]*c[1]*c[2] + c[0]*c[1]*s[2],
			Z: c[0]*s[1]*s[2] - s[0]*s[1]*c[2],
		}
	case YZX:
		ret.W = c[0]*c[1]*c[2] - s[0]*s[1]*s[2]
		ret.V = vec3.T{
			X: c[0]*c[1]*s[2] + s[0]*s[1]*c[2],
			Y: c[0]*s[1]*s[2] + s[0]*c[1]*c[2],
			Z: c[0]*s[1]*c[2] - s[0]*c[1]*s[2],
		}
	case YZY:
		ret.W = c[0]*c[1]*c[2] - s[0]*c[1]*s[2]
		ret.V = vec3.T{
			X: s[0]*s[1]*c[2] - c[0]*s[1]*s[2],
			Y: c[0]*c[1]*s[2] + s[0]*c[1]*c[2],
			Z: c[0]*s[1]*c[2] + s[0]*s[1]*s[2],
		}
	case XYZ:
		ret.W = c[0]*c[1]*c[2] - s[0]*s[1]*s[2]
		ret.V = vec3.T{
			X: c[0]*s[1]*s[2] + s[0]*c[1]*c[2],
			Y: c[0]*s[1]*c[2] - s[0]*c[1]*s[2],
			Z: c[0]*c[1]*s[2] + s[0]*s[1]*c[2],
		}
	case XYX:
		ret.W = c[0]*c[1]*c[2] - s[0]*c[1]*s[2]
		ret.V = vec3.T{
			X: c[0]*c[1]*s[2] + s[0]*c[1]*c[2],
			Y: c[0]*s[1]*c[2] + s[0]*s[1]*s[2],
			Z: s[0]*s[1]*c[2] - c[0]*s[1]*s[2],
		}
	case XZY:
		ret.W = c[0]*c[1]*c[2] + s[0]*s[1]*s[2]
		ret.V = vec3.T{
			X: s[0]*c[1]*c[2] - c[0]*s[1]*s[2],
			Y: c[0]*c[1]*s[2] - s[0]*s[1]*c[2],
			Z: c[0]*s[1]*c[2] + s[0]*c[1]*s[2],
		}
	case XZX:
		ret.W = c[0]*c[1]*c[2] - s[0]*c[1]*s[2]
		ret.V = vec3.T{
			X: c[0]*c[1]*s[2] + s[0]*c[1]*c[2],
			Y: c[0]*s[1]*s[2] - s[0]*s[1]*c[2],
			Z: c[0]*s[1]*c[2] + s[0]*s[1]*s[2],
		}
	default:
		panic("Unsupported rotation order")
	}
	return ret
}

// FromMat4 converts a pure rotation matrix into a quaternion
func FromMat4(m mat4.T) T {
	// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm

	if tr := m[0] + m[5] + m[10]; tr > 0 {
		s := 0.5 / math.Sqrt(tr+1.0)
		return T{
			0.25 / s,
			vec3.T{
				X: (m[6] - m[9]) * s,
				Y: (m[8] - m[2]) * s,
				Z: (m[1] - m[4]) * s,
			},
		}
	}

	if (m[0] > m[5]) && (m[0] > m[10]) {
		s := 2.0 * math.Sqrt(1.0+m[0]-m[5]-m[10])
		return T{
			(m[6] - m[9]) / s,
			vec3.T{
				X: 0.25 * s,
				Y: (m[4] + m[1]) / s,
				Z: (m[8] + m[2]) / s,
			},
		}
	}

	if m[5] > m[10] {
		s := 2.0 * math.Sqrt(1.0+m[5]-m[0]-m[10])
		return T{
			(m[8] - m[2]) / s,
			vec3.T{
				X: (m[4] + m[1]) / s,
				Y: 0.25 * s,
				Z: (m[9] + m[6]) / s,
			},
		}

	}

	s := 2.0 * math.Sqrt(1.0+m[10]-m[0]-m[5])
	return T{
		(m[1] - m[4]) / s,
		vec3.T{
			X: (m[8] + m[2]) / s,
			Y: (m[9] + m[6]) / s,
			Z: 0.25 * s,
		},
	}
}

// LookAtV creates a rotation from an eye vector to a center vector
//
// It assumes the front of the rotated object at Z- and up at Y+
func LookAtV(eye, center, up vec3.T) T {
	// http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-17-quaternions/#I_need_an_equivalent_of_gluLookAt__How_do_I_orient_an_object_towards_a_point__
	// https://bitbucket.org/sinbad/ogre/src/d2ef494c4a2f5d6e2f0f17d3bfb9fd936d5423bb/OgreMain/src/OgreCamera.cpp?at=default#cl-161

	direction := center.Sub(eye).Normalized()

	// Find the rotation between the front of the object (that we assume towards Z-,
	// but this depends on your model) and the desired direction
	rotDir := BetweenVectors(vec3.UnitZN, direction)

	// Recompute up so that it's perpendicular to the direction
	// You can skip that part if you really want to force up
	//right := direction.Cross(up)
	//up = right.Cross(direction)

	// Because of the 1rst rotation, the up is probably completely screwed up.
	// Find the rotation between the "up" of the rotated object, and the desired up
	upCur := rotDir.Rotate(vec3.Zero)
	rotUp := BetweenVectors(upCur, up)

	rotTarget := rotUp.Mul(rotDir) // remember, in reverse order.
	return rotTarget.Inverse()     // camera rotation should be inversed!
}

// BetweenVectors calculates the rotation between two vectors
func BetweenVectors(start, dest vec3.T) T {
	// http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-17-quaternions/#I_need_an_equivalent_of_gluLookAt__How_do_I_orient_an_object_towards_a_point__
	// https://github.com/g-truc/glm/blob/0.9.5/glm/gtx/quaternion.inl#L225
	// https://bitbucket.org/sinbad/ogre/src/d2ef494c4a2f5d6e2f0f17d3bfb9fd936d5423bb/OgreMain/include/OgreVector3.h?at=default#cl-654

	start = start.Normalized()
	dest = dest.Normalized()
	epsilon := float32(0.001)

	cosTheta := vec3.Dot(start, dest)
	if cosTheta < -1.0+epsilon {
		// special case when vectors in opposite directions:
		// there is no "ideal" rotation axis
		// So guess one; any will do as long as it's perpendicular to start
		axis := vec3.Cross(vec3.UnitX, start)
		if vec3.Dot(axis, axis) < epsilon {
			// bad luck, they were parallel, try again!
			axis = vec3.Cross(vec3.UnitY, start)
		}

		return Rotate(math.Pi, axis.Normalized())
	}

	axis := vec3.Cross(start, dest)
	s := float32(math.Sqrt(float32(1.0+cosTheta) * 2.0))

	return T{
		s * 0.5,
		axis.Scaled(1.0 / s),
	}
}

func (q T) ToAngles(order RotationOrder) vec3.T {
	// this function was adapted from a Go port of Three.js math, github.com/tengge1/go-three-math
	// Copyright 2017-2020 The ShadowEditor Authors. All rights reserved.
	// Use of e source code is governed by a MIT-style
	// license that can be found in the LICENSE file.

	// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
	te := q.Mat4()
	m11, m12, m13 := te[0], te[4], te[8]
	m21, m22, m23 := te[1], te[5], te[9]
	m31, m32, m33 := te[2], te[6], te[10]

	e := vec3.Zero
	switch order {
	default:
		panic("unsupported rotation order")
	case XYZ:
		e.Y = math.Asin(math.Clamp(m13, -1, 1))

		if math.Abs(m13) < 0.9999999 {
			e.X = math.Atan2(-m23, m33)
			e.Z = math.Atan2(-m12, m11)
		} else {
			e.X = math.Atan2(m32, m22)
			e.Z = 0
		}
	case YXZ:
		e.X = math.Asin(-math.Clamp(m23, -1, 1))

		if math.Abs(m23) < 0.9999999 {
			e.Y = math.Atan2(m13, m33)
			e.Z = math.Atan2(m21, m22)
		} else {
			e.Y = math.Atan2(-m31, m11)
			e.Z = 0
		}
	case ZXY:
		e.X = math.Asin(math.Clamp(m32, -1, 1))

		if math.Abs(m32) < 0.9999999 {
			e.Y = math.Atan2(-m31, m33)
			e.Z = math.Atan2(-m12, m22)
		} else {
			e.Y = 0
			e.Z = math.Atan2(m21, m11)
		}
	case ZYX:
		e.Y = math.Asin(-math.Clamp(m31, -1, 1))

		if math.Abs(m31) < 0.9999999 {
			e.X = math.Atan2(m32, m33)
			e.Z = math.Atan2(m21, m11)
		} else {
			e.X = 0
			e.Z = math.Atan2(-m12, m22)
		}
	case YZX:
		e.Z = math.Asin(math.Clamp(m21, -1, 1))

		if math.Abs(m21) < 0.9999999 {
			e.X = math.Atan2(-m23, m22)
			e.Y = math.Atan2(-m31, m11)
		} else {
			e.X = 0
			e.Y = math.Atan2(m13, m33)
		}
	case XZY:
		e.Z = math.Asin(-math.Clamp(m12, -1, 1))

		if math.Abs(m12) < 0.9999999 {
			e.X = math.Atan2(m32, m22)
			e.Y = math.Atan2(m13, m11)
		} else {
			e.X = math.Atan2(-m23, m33)
			e.Y = 0
		}
	}

	return e
}

func (q T) Euler() vec3.T {
	// convert radians to degrees
	return q.ToAngles(YXZ).Scaled(180.0 / math.Pi)
}

func Euler(x, y, z float32) T {
	return FromAngles(math.DegToRad(y), math.DegToRad(x), math.DegToRad(z), YXZ)
}