using Chernobyl.Mathematics.Vectors;

namespace Chernobyl.Mathematics.Movement
{
    /// <summary>
    /// A transformation that removes the scale that was applied by previous 
    /// ancestors in a transformation hierarchy. For example, lets say you have
    /// two sprites. You want the child sprite to be attached to the parent sprite
    /// so that the child sprite will "follow" the parent sprite as it moves. You
    /// also want to scale the parent sprite but don't want the child to be affected
    /// by this scaling. To do this, you would place a RemoveScaleTransform between
    /// the parent and the child like so:
    /// 
    /// Parent
    ///     |
    ///     |---- RemoveScaleTransform
    ///             |
    ///             |------ Child
    /// 
    /// In code:
    /// <code>
    /// RemoveScaleTransform rst = new RemoveScaleTransform();
    /// parentSprite.AttachTo(rst);
    /// rst.AttachTo(childSprite);
    /// </code>
    /// 
    /// Note that, a scale can still be applied to the RemoveScaleTransform and   
    /// that scale WILL be applied to descendant transforms in the transform 
    /// hierarchy.
    /// </summary>
    public class RemoveScaleTransform : MatrixTransform
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="RemoveScaleTransform"/> 
        /// class that removes scale from all axis of a transform.
        /// </summary>
        public RemoveScaleTransform() : this(Axis.All)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="RemoveScaleTransform"/> class.
        /// </summary>
        /// <param name="axisToRemoveScaleFrom">The axis of the transform hierarchy whose 
        /// scale should be removed. For example, if you want to remove scale from 
        /// only the X axis then you would specify <see cref="Axis.X"/>. If you 
        /// would like to remove scale from the Y and Z axis only, then you would 
        /// specify <see cref="Axis.Y"/> and <see cref="Axis.Z"/> like so:
        /// <code>
        /// RemoveScaleTransform rms = new RemoveScaleTransform(Axis.Y | Axis.Z);
        /// </code>
        /// </param>
        public RemoveScaleTransform(Axis axisToRemoveScaleFrom)
            : this(axisToRemoveScaleFrom, DefaultKeepScaleAffectedPosition)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="RemoveScaleTransform"/> class.
        /// </summary>
        /// <param name="axisToRemoveScaleFrom">The axis of the transform hierarchy whose 
        /// scale should be removed. For example, if you want to remove scale from 
        /// only the X axis then you would specify <see cref="Axis.X"/>. If you 
        /// would like to remove scale from the Y and Z axis only, then you would 
        /// specify <see cref="Axis.Y"/> and <see cref="Axis.Z"/> like so:
        /// <code>
        /// RemoveScaleTransform rms = new RemoveScaleTransform(Axis.Y | Axis.Z);
        /// </code>
        /// </param>
        /// <param name="keepScaleAffectedPosition">
        /// True if the position of this transform should remain unaffected by 
        /// the removal of the scale from it's ancestors, false if otherwise. 
        /// Setting this property to true can help in cases where you want the 
        /// scaled ancestors to not affect the scale of a child but want the 
        /// child's position to be made relative to the scale of the ancestors.
        /// By default, the value of this property is set by the 
        /// static field <see cref="DefaultKeepScaleAffectedPosition"/>.
        /// 
        /// Performance warning: if this value is true, an additional matrix  
        /// multiplication has to be done in order to find the position affected 
        /// by the scale. This may introduce a small (perhaps insignificant)  
        /// performance degradation.</param>
        public RemoveScaleTransform(Axis axisToRemoveScaleFrom, bool keepScaleAffectedPosition)
        {
            AxisToRemoveScaleFrom = axisToRemoveScaleFrom;
            KeepScaleAffectedPosition = keepScaleAffectedPosition;
        }

        /// <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 override void Update()
        {
            if (IsUpdateNeeded == true)
            {
                // if we have a parent: recompute our world matrix using our 
                // local matrix and the world matrix of our parent
                if (TransformParent != null)
                {
                    if(AxisToRemoveScaleFrom != Axis.None)
                    {
                        // now we need to take the parent's transformation matrix and
                        // remove the scale from it. After we have done that, we can
                        // use the parent's scale-less matrix like we normally would.
                        Matrix4 parentsWorldMatrix = TransformParent.WorldMatrix;

                        // normalize each axis of the parent's world matrix to remove
                        // the scale...

                        // X axis
                        if ((AxisToRemoveScaleFrom & Axis.X) == Axis.X && parentsWorldMatrix.Row0 != Vector4.Zero)
                            Vector4.Normalize(ref parentsWorldMatrix.Row0, out parentsWorldMatrix.Row0);

                        // Y axis
                        if ((AxisToRemoveScaleFrom & Axis.Y) == Axis.Y && parentsWorldMatrix.Row1 != Vector4.Zero)
                            Vector4.Normalize(ref parentsWorldMatrix.Row1, out parentsWorldMatrix.Row1);

                        // Z axis
                        if ((AxisToRemoveScaleFrom & Axis.Z) == Axis.Z && parentsWorldMatrix.Row2 != Vector4.Zero)
                            Vector4.Normalize(ref parentsWorldMatrix.Row2, out parentsWorldMatrix.Row2);

                        // if necessary, find the "normal" position or the resulting 
                        // position of this transform had the scale not been removed 
                        // from the ancestor transforms
                        if (KeepScaleAffectedPosition == true)
                        {
                            Matrix4 normalWorldMatrix = LocalMatrix * TransformParent.WorldMatrix;
                            Matrix4 deScaledWorldMatrix = LocalMatrix * parentsWorldMatrix;

                            WorldMatrix = new Matrix4(  deScaledWorldMatrix.Row0, deScaledWorldMatrix.Row1, 
                                                        deScaledWorldMatrix.Row2, normalWorldMatrix.Row3);
                        }
                        else
                            WorldMatrix = LocalMatrix * parentsWorldMatrix;
                    }
                    else
                        WorldMatrix = LocalMatrix * TransformParent.WorldMatrix;
                }
                else  // if we don't have a parent: our local is our world
                    WorldMatrix = LocalMatrix;

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

        /// <summary>
        /// The axis of the transform hierarchy whose 
        /// scale should be removed. For example, if you want to remove scale from 
        /// only the X axis then you would specify <see cref="Axis.X"/>. If you 
        /// would like to remove scale from the Y and Z axis only, then you would 
        /// specify <see cref="Axis.Y"/> and <see cref="Axis.Z"/> like so:
        /// <code>
        /// RemoveScaleTransform rms = new RemoveScaleTransform(Axis.Y | Axis.Z);
        /// </code>
        /// </summary>
        /// <value>By default, this value is <see cref="Axis.All"/>.</value>
        public Axis AxisToRemoveScaleFrom { get; set; }

        /// <summary>
        /// True if the position of this transform should remain unaffected by 
        /// the removal of the scale from it's ancestors, false if otherwise. 
        /// Setting this property to true can help in cases where you want the 
        /// scaled ancestors to not affect the scale of a child but want the 
        /// child's position to be made relative to the scale of the ancestors.
        /// 
        /// Performance warning: if this value is true, an additional matrix  
        /// multiplication has to be done in order to find the position affected 
        /// by the scale. This may introduce a small (perhaps insignificant)  
        /// performance degradation.
        /// </summary>
        /// <value>By default, the value of this property is set by the 
        /// static field <see cref="DefaultKeepScaleAffectedPosition"/>.</value>
        public bool KeepScaleAffectedPosition { get; set; }

        /// <summary>
        /// The default value of the <see cref="KeepScaleAffectedPosition"/> 
        /// property.
        /// </summary>
        public static bool DefaultKeepScaleAffectedPosition = false;
    }
}