using System.Collections.Generic;
using Chernobyl.Creation;
using Chernobyl.Mathematics.Vectors;
using Chernobyl.Measures;

namespace Chernobyl.Mathematics.Movement
{
    /// <summary>
    /// A transform that uses matrices to represent the transformations.
    /// </summary>
    public class MatrixTransform : Transform
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="MatrixTransform"/> class
        /// that uses <see cref="Matrix4.Identity"/> for the initial value of the
        /// <see cref="LocalMatrix"/> and the default value for the
        /// <see cref="ITransform.TransformChildren"/> list.
        /// </summary>
        public MatrixTransform()
            : this(ref Matrix4.Identity)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="MatrixTransform"/> class
        /// the default value for the <see cref="ITransform.TransformChildren"/>
        /// list.
        /// </summary>
        /// <param name="localMatrix">The initial value of the
        /// <see cref="LocalMatrix"/>.</param>
        public MatrixTransform(ref Matrix4 localMatrix)
            : this(ref localMatrix, null)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="MatrixTransform"/> class
        /// that uses <see cref="Matrix4.Identity"/> for the initial value of the
        /// <see cref="LocalMatrix"/>.
        /// </summary>
        /// <param name="childList">The list to use for the
        /// <see cref="ITransform.TransformChildren"/> list or null if the default
        /// <see cref="List{T}"/> should be used.</param>
        public MatrixTransform(IList<ITransform> childList)
            : this(ref Matrix4.Identity, childList)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="MatrixTransform"/> class.
        /// </summary>
        /// <param name="localMatrix">The initial value of the
        /// <see cref="LocalMatrix"/>.</param>
        /// <param name="childList">The list to use for the
        /// <see cref="ITransform.TransformChildren"/> list or null if the default
        /// <see cref="List{T}"/> should be used.</param>
        public MatrixTransform(ref Matrix4 localMatrix, IList<ITransform> childList)
            : base(childList)
        {
            _worldMatrix = _localMatrix = localMatrix;
        }

        /// <summary>
        /// Translates the transform in the X axis by a specified amount.
        /// </summary>
        /// <param name="x">The amount to translate in the X.</param>
        public override void TranslateX(float x)
        {
            Translate(x, 0.0f, 0.0f);
        }

        /// <summary>
        /// Translates the transform in the Y axis by a specified amount.
        /// </summary>
        /// <param name="y">The amount to translate in the Y.</param>
        public override void TranslateY(float y)
        {
            Translate(0.0f, y, 0.0f);
        }

        /// <summary>
        /// Translates the transform in the Z axis by a specified amount.
        /// </summary>
        /// <param name="z">The amount to translate in the Z.</param>
        public override void TranslateZ(float z)
        {
            Translate(0.0f, 0.0f, z);
        }

        /// <summary>
        /// Translates the transform in the X and Y axis by a specified amount.
        /// This method is useful for transforms that exist in 2D world.
        /// </summary>
        /// <param name="x">The amount to translate in the X.</param>
        /// <param name="y">The amount to translate in the Y.</param>
        public override void Translate(float x, float y)
        {
            Translate(x, y, 0.0f);
        }

        /// <summary>
        /// Translates the transform in the X axis, Y axis
        /// and Z axis by specified amounts.
        /// </summary>
        /// <param name="x">The amount to translate in the X.</param>
        /// <param name="y">The amount to translate in the Y.</param>
        /// <param name="z">The amount to translate in the Z.</param>
        public override void Translate(float x, float y, float z)
        {
            Matrix4 translation;
            Matrix4.CreateTranslation(x, y, z, out translation);
            LocalMatrix *= translation;
        }

        /// <summary>
        /// Rotates this transform around a vector by a specified amount.
        /// </summary>
        /// <param name="vectorToRotateAround">The vector to rotate around.</param>
        /// <param name="radian">The amount to rotate around the vector.</param>
        public override void Rotate(Vector3 vectorToRotateAround, Radian radian)
        {
            Matrix4 rotation; Matrix4.Rotate(out rotation, vectorToRotateAround, radian);
            LocalMatrix *= rotation;
        }

        /// <summary>
        /// Rotates this transform about the X axis a specified amount.
        /// </summary>
        /// <param name="amount">The amount to rotate by.</param>
        public override void Pitch(Radian amount)
        {
            Matrix4 rotation; Matrix4.RotateX(out rotation, amount);
            LocalMatrix *= rotation;
        }

        /// <summary>
        /// Rotates this transform about the Y axis a specified amount.
        /// </summary>
        /// <param name="amount">The amount to rotate by.</param>
        public override void Yaw(Radian amount)
        {
            Matrix4 rotation; Matrix4.RotateY(out rotation, amount);
            LocalMatrix *= rotation;
        }

        /// <summary>
        /// Rotates this transform about the Z axis a specified amount.
        /// </summary>
        /// <param name="amount">The amount to rotate by.</param>
        public override void Roll(Radian amount)
        {
            Matrix4 rotation; Matrix4.RotateZ(out rotation, amount);
            LocalMatrix *= rotation;
        }

        /// <summary>
        /// Scales the transform along the X axis.
        /// </summary>
        /// <param name="amount">The amount to scale in the X axis.</param>
        public override void ScaleX(float amount)
        {
            LocalMatrix *= Matrix4.Scale(amount, 1, 1);
        }

        /// <summary>
        /// Scales the transform in the Y axis.
        /// </summary>
        /// <param name="amount">The amount to scale in the Y axis.</param>
        public override void ScaleY(float amount)
        {
            LocalMatrix *= Matrix4.Scale(1, amount, 1);
        }

        /// <summary>
        /// Scales the transform in the Z axis.
        /// </summary>
        /// <param name="amount">The amount to scale in the Z axis.</param>
        public override void ScaleZ(float amount)
        {
            LocalMatrix *= Matrix4.Scale(1, 1, amount);
        }

        /// <summary>
        /// Scales the transform in the X and Y axis. This is useful if the
        /// transform exists in a 2D world.
        /// </summary>
        /// <param name="x">The amount to scale in the X axis.</param>
        /// <param name="y">The amount to scale in the Y axis.</param>
        public override void Scale(float x, float y)
        {
            LocalMatrix *= Matrix4.Scale(x, y, 1);
        }

        /// <summary>
        /// Scales the transform uniformly over the X, Y, and Z axis.
        /// </summary>
        /// <param name="x">The amount to scale in the X axis.</param>
        /// <param name="y">The amount to scale in the Y axis.</param>
        /// <param name="z">The amount to scale in the Z axis.</param>
        public override void Scale(float x, float y, float z)
        {
            LocalMatrix *= Matrix4.Scale(x, y, z);
        }

        /// <summary>
        /// Sets the internal local transformation to the matrix passed in.
        /// </summary>
        /// <param name="matrix4">The matrix to set the internal local
        /// transformation to.</param>
        public override void SetTransformation(ref Matrix4 matrix4)
        {
            LocalMatrix = matrix4;
        }

        /// <summary>
        /// Gets/sets this transforms local matrix. The local matrix
        /// is the matrix that has been "untouched" by the parents,
        /// grandparents, etc., of this transform. In other words,
        /// it is not relative to any other transform.
        /// </summary>
        public override Matrix4 LocalMatrix
        {
            get
            {
                return _localMatrix;
            }
            protected set
            {
                _localMatrix = value;
                IsUpdateNeeded = true;
            }
        }

        /// <summary>
        /// Gets/sets this transform's world matrix. The world matrix
        /// is the position and orientation relative to the parent of
        /// this transform.
        /// </summary>
        public override Matrix4 WorldMatrix
        {
            get
            {
                // ensure that the world matrix is up to date.
                Update();

                return _worldMatrix;
            }
            protected set { _worldMatrix = value; }
        }

        /// <summary>
        /// Basic <see cref="IFactory{T}"/> for creating <see cref="MatrixTransform"/> types.
        /// </summary>
        public class Factory : DefaultConstructorFactory<MatrixTransform>
        {}

        /// <summary>
        /// The backing field of the property LocalMatrix.
        /// </summary>
        Matrix4 _localMatrix;

        /// <summary>
        /// The backing field of the property WorldMatrix.
        /// </summary>
        Matrix4 _worldMatrix;
    }
}