using System;
using System.Collections.Generic;
using Chernobyl.DesignPatterns.Extension;
using Chernobyl.Mathematics.Vectors;
using Chernobyl.Measures;
using Chernobyl.Values;

namespace Chernobyl.Mathematics.Movement
{
    /// <summary>
    /// A helper class to make it easier to implement ITransforms. You should
    /// never 'handle' the type <see cref="Transform"/> because not all
    /// transforms derive from <see cref="Transform"/>. Instead, work with
    /// <see cref="ITransform"/>.
    /// </summary>
    public abstract class Transform : Extension<ITransform>, ITransform
    {
        /// <summary>
        /// Constructor that creates a new Transform instance, sets the
        /// <see cref="LocalMatrix"/> equal to the identity matrix, and makes the
        /// <see cref="TransformChildren"/> list a <see cref="List{T}"/>
        /// instance.
        /// </summary>
        protected Transform() : this(null)
        {}

        /// <summary>
        /// Constructor that creates a new Transform instance and sets the
        /// <see cref="LocalMatrix"/>equal to the identity matrix.
        /// </summary>
        /// <param name="childList">The list to use for the
        /// <see cref="TransformChildren"/> list or null if the default
        /// <see cref="List{T}"/> should be used.</param>
        protected Transform(IList<ITransform> childList)
        {
            TransformChildren = childList ?? new List<ITransform>();
            Extensions = new List<IExtension>();
        }

        /// <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 abstract void TranslateX(float x);

        /// <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 abstract void TranslateY(float y);

        /// <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 abstract void TranslateZ(float 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 abstract void Translate(float x, float y);

        /// <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="amount">The amount to translate in the X and Y axis.</param>
        public void Translate(Vector2 amount)
        {
            Translate(amount.X, amount.Y);
        }

        /// <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 abstract void Translate(float x, float y, float z);

        /// <summary>
        /// Translates the transform in the X axis, Y axis and Z axis by
        /// specified amounts.
        /// </summary>
        /// <param name="amount">The amount to translate the transform in each
        /// of the three axis where Vector3.X is the X axis translation amount,
        /// Vector3.Y is the Y axis translation amount, and Vector3.Z is the
        /// Z axis translation amount.</param>
        public void Translate(Vector3 amount)
        {
            Translate(amount.X, amount.Y, amount.Z);
        }

        /// <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 abstract void Rotate(Vector3 vectorToRotateAround, Radian radian);

        /// <summary>
        /// Rotates this transform about the X axis a specified amount.
        /// </summary>
        /// <param name="amount">The amount to rotate by.</param>
        public abstract void Pitch(Radian amount);

        /// <summary>
        /// Rotates this transform about the Y axis a specified amount.
        /// </summary>
        /// <param name="amount">The amount to rotate by.</param>
        public abstract void Yaw(Radian amount);

        /// <summary>
        /// Rotates this transform about the Z axis a specified amount.
        /// </summary>
        /// <param name="amount">The amount to rotate by.</param>
        public abstract void Roll(Radian amount);

        /// <summary>
        /// Scales the transform along the X axis.
        /// </summary>
        /// <param name="amount">The amount to scale in the X axis.</param>
        public abstract void ScaleX(float amount);

        /// <summary>
        /// Scales the transform in the Y axis.
        /// </summary>
        /// <param name="amount">The amount to scale in the Y axis.</param>
        public abstract void ScaleY(float amount);

        /// <summary>
        /// Scales the transform in the Z axis.
        /// </summary>
        /// <param name="amount">The amount to scale in the Z axis.</param>
        public abstract void ScaleZ(float amount);

        /// <summary>
        /// Scales the transform uniformly over the X, Y, and Z axis.
        /// </summary>
        /// <param name="amount">The amount to scale in all axis.</param>
        public void Scale(float amount)
        {
            Scale(amount, amount, 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 abstract void Scale(float x, float y);

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

        /// <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 abstract void Scale(float x, float y, float z);

        /// <summary>
        /// Scales the transform uniformly over the X, Y, and Z axis.
        /// </summary>
        /// <param name="amount">The amount to scale in each axis where
        /// Vector3.X is the amount to scale in the X axis, Vector3.Y is the
        /// amount to scale in the Y axis, Vector3.Z is the amount to scale in
        /// the Z axis.</param>
        public void Scale(Vector3 amount)
        {
            Scale(amount.X, amount.Y, amount.Z);
        }

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

        /// <summary>
        /// Sets the <see cref="IsUpdateNeeded"/> needed flag to true.
        /// </summary>
        /// <param name="parent">The transform to make a parent of this
        /// transform.</param>
        protected override void AttachTo(ITransform parent)
        {
            IsUpdateNeeded = true;
        }

        /// <summary>
        /// Sets the <see cref="IsUpdateNeeded"/> needed flag to true.
        /// </summary>
        /// <param name="parent">The transform to separate from this transform.</param>
        protected override void DetachFrom(ITransform parent)
        {
            IsUpdateNeeded = true;
        }

        /// <summary>
        /// An event that is raised when the transform has been "dirtied" or
        /// when the position, orientation, and/or scale of the transform has
        /// been changed either due to an ancestor being changed or due to the
        /// transform itself being changed. This event will only be raised once
        /// when the transform is changed, subsequent changes to the transform
        /// or it's ancestors will not cause the event to be raised. If the
        /// transform is cleaned (typically done when the <see cref="WorldMatrix"/>
        /// is accessed) and then dirtied again, the event will be raised.
        /// </summary>
        public event EventHandler TransformDirtied;

        /// <summary>
        /// The parent to this transform. This property will be null if this is
        /// the root of the hierarchy.
        /// </summary>
        public ITransform TransformParent { get { return Extended; } set { Extended = value; } }

        /// <summary>
        /// The children of this transform who's position, orientation, scale,
        /// etc., are effected or offset by this transform.
        /// </summary>
        public IList<ITransform> TransformChildren { get; protected set; }

        /// <summary>
        /// This transforms position in the world. This property returns the
        /// World position (i.e. the position from <see cref="WorldMatrix"/>) but
        /// sets the Local position (i.e. the position from <see cref="LocalMatrix"/>.
        /// </summary>
        public virtual Vector3 Position
        {
            get { return WorldMatrix.Translation; }
            set
            {
                Matrix4 local = LocalMatrix;
                local.Row3 = new Vector4(value.X, value.Y, value.Z, local.Row3.W);
                SetTransformation(ref local);
            }
        }

        /// <summary>
        /// The up vector of this transform in the world, which is also the +Y
        /// vector or <see cref="Matrix4.Column1"/>.
        /// </summary>
        public virtual Vector3 Up { get { return WorldMatrix.Up; } }

        /// <summary>
        /// The vector that points straight ahead (in the world) for this
        /// transform, which is also the -Z vector or negative
        /// <see cref="Matrix4.Column2"/>.
        /// </summary>
        public virtual Vector3 Forward { get { return WorldMatrix.Forward; } }

        /// <summary>
        /// The vector that points to this transform's right in the world, which
        /// is also the +X vector or <see cref="Matrix4.Column0"/>.
        /// </summary>
        public virtual Vector3 Right { get { return WorldMatrix.Right; } }

        /// <summary>
        /// The amount of scale in the world X axis of the transform.
        /// </summary>
        public float XScale { get { return WorldMatrix.Column0.Xyz.Length; } }

        /// <summary>
        /// The amount of scale in the world Y axis of the transform.
        /// </summary>
        public float YScale { get { return WorldMatrix.Column1.Xyz.Length; } }

        /// <summary>
        /// The amount of scale in the world Z axis of the transform.
        /// </summary>
        public float ZScale { get { return WorldMatrix.Column2.Xyz.Length; } }

        /// <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 abstract Matrix4 LocalMatrix { get; protected set; }

        /// <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 abstract Matrix4 WorldMatrix { get; protected set; }

        /// <summary>
        /// Orders this transform so that it's world matrix represents it's
        /// local matrix relative to it's parent's world matrix.
        /// </summary>
        protected virtual void Update()
        {
            if (IsUpdateNeeded == true)
            {
                PreUpdate(new Values.LazyValue<Matrix4>(() =>
                {
                    Matrix4 world;
                    CalculateWorldMatrix(out world);
                    return world;
                }));

                Matrix4 worldMatrix;
                CalculateWorldMatrix(out worldMatrix);
                WorldMatrix = worldMatrix;

                IsUpdateNeeded = false;	// we are "clean" now..

                PostUpdate(ref worldMatrix);
            }
        }

        /// <summary>
        /// This method is invoked during the update of the
        /// <see cref="ITransform.WorldMatrix"/> right before the
        /// <see cref="ITransform.WorldMatrix"/> is actually updated. Typically
        /// you would override this method if you would like to modify the
        /// <see cref="ITransform.LocalMatrix"/> prior to the final calculation
        /// of the <see cref="ITransform.WorldMatrix"/>.
        /// </summary>
        /// <param name="world">The value of the <see cref="ITransform.WorldMatrix"/>.
        /// It is stored in a <see cref="LazyValue{T}"/> so that the calculation can be
        /// avoided if necessary. Don't call <see cref="LazyValue{T}.Value"/> unless
        /// required.</param>
        protected virtual void PreUpdate(Values.LazyValue<Matrix4> world) { /* no-op */ }

        /// <summary>
        /// This method is invoked during the update of the
        /// <see cref="ITransform.WorldMatrix"/> right after the
        /// <see cref="ITransform.WorldMatrix"/> has been updated. Typically you
        /// would override this method if you would like to update some other
        /// data based on the new value of the <see cref="WorldMatrix"/> whose
        /// value is passed to this method.
        /// </summary>
        /// <param name="world">The new value of the
        /// <see cref="ITransform.WorldMatrix"/>.</param>
        protected virtual void PostUpdate(ref Matrix4 world) { /* no-op */ }

        /// <summary>
        /// A helper method for derived types that calculates the current world
        /// matrix of this <see cref="ITransform"/>.
        /// </summary>
        /// <param name="result">The <see cref="Matrix4"/> that is to take the
        /// calculation of the world matrix.</param>
        void CalculateWorldMatrix(out Matrix4 result)
        {
            // if we have a parent: recompute our world matrix using our
            // local matrix and the world matrix of our parent
            if (TransformParent != null)
            {
                // In some cases, the parent may actively modify the children
                // transforms. This update may occur when the WorldMatrix of the
                // parent is accessed. If that is the case then we need to access
                // the parent's WorldMatrix before we access this instances
                // LocalMatrix so that the parent has a chance to modify the
                // child.
                Matrix4 parentWorld = TransformParent.WorldMatrix;
                result = LocalMatrix * parentWorld;
            }
            else  // if we don't have a parent: our local is our world
                result = LocalMatrix;
        }

        /// <summary>
        /// True if an update to this transform's world matrix is
        /// needed, false if otherwise. A transform will need to be
        /// updated if it's local matrix or an ancestors local matrix
        /// is updated.
        /// </summary>
        public virtual bool IsUpdateNeeded
        {
            get { return _isUpdateNeeded; }
            set
            {
                bool previousValue = _isUpdateNeeded;
                _isUpdateNeeded = value;

                // only tell our children and subscribers to the TransformDirtied
                // event if an update is needed and if they don't already know
                if (value == true && previousValue != true)
                {
                    if (TransformDirtied != null)
                        TransformDirtied(this, EventArgs.Empty);

                    // warn our children about this
                    foreach (ITransform child in TransformChildren)
                        child.IsUpdateNeeded = true;
                }
            }
        }

        /// <inheritdoc />
        public void Dispose() => SeparateParentChild(TransformParent, this);

        /// <summary>
        /// A helper method that takes one transform and makes it the parent of
        /// another. When this is done, the parent will "affect" or offset the
        /// transform of the child. If a previous parent is attached to child,
        /// that parent will first be separated from the child passed in.
        /// </summary>
        /// <param name="parent">The transform that is to become the parent of
        /// the child.</param>
        /// <param name="child">The transform that is to become the child of the
        /// parent.</param>
        public static void MakeParentChild(ITransform parent, ITransform child)
        {
            // make sure the child isn't already a child of the parent
            if (parent.TransformChildren.Contains(child) == false)
            {
                parent.TransformChildren.Add(child);

                // if the child has a parent, have it detach from that parent
                if (child.TransformParent != null)
                    child.TransformParent.TransformChildren.Remove(child);

                child.TransformParent = parent;
            }
        }

        /// <summary>
        /// A helper method that splits apart a parent/child relationship of two
        /// transforms. When this is done, the parent transform will no longer
        /// "affect" or offset the transform of the child. The child's parent is
        /// first checked to make sure it is the parent passed in. If it is, then
        /// the child's parent property is set to null. If not, the parent property
        /// on the child is left alone.
        /// </summary>
        /// <param name="parent">The parent to seperate from the child.</param>
        /// <param name="child">The child to seperate from the parent.</param>
        public static void SeparateParentChild(ITransform parent, ITransform child)
        {
            // ensure these two are actually parented before separating them
            if (child.TransformParent != null && child.TransformParent == parent)
            {
                parent.TransformChildren.Remove(child);
                child.TransformParent = null;
            }
        }

        /// <summary>
        /// Shallow copies the <paramref name="source"/> <see cref="ITransform"/>
        /// into the <paramref name="destination"/> <see cref="ITransform"/>.
        /// Note that, this method will re-parent the child <see cref="ITransform"/>s
        /// of the <paramref name="source"/> to the <paramref name="destination"/>;
        /// This is due to the fact that no <see cref="ITransform"/> can have
        /// two parents.
        /// </summary>
        /// <param name="destination">The <see cref="ITransform"/> that is to
        /// take the result of the copy.</param>
        /// <param name="source">The <see cref="ITransform"/> that is to be copied.</param>
        public static void ShallowCopy(ITransform destination, ITransform source)
        {
            Matrix4 sourceLocalMatrix = source.LocalMatrix;
            destination.SetTransformation(ref sourceLocalMatrix);
            destination.Extended = source.TransformParent;

            foreach (ITransform transformChild in source.TransformChildren)
                transformChild.Extended = destination;
        }


        /// <summary>
        /// The list of <see cref="IExtension"/> or
        /// <see cref="IExtension{TExtended}"/> instances that have
        /// attached themselves to this instance.
        /// </summary>
        public IList<IExtension> Extensions { get; protected set; }

        /// <summary>
        /// The backing field to <see cref="IsUpdateNeeded"/>.
        /// </summary>
        bool _isUpdateNeeded;
    }
}