using System;
using Chernobyl.Mathematics.Geometry;
using Chernobyl.Mathematics.Vectors;
using Chernobyl.Values;

namespace Chernobyl.Mathematics.Movement
{
    /// <summary>
    /// An <see cref="ITransform"/> that does not move outside a boundary
    /// specified by <see cref="Cage"/>.
    /// </summary>
    public class CagedTransform2D : MatrixTransform
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="CagedTransform2D"/> class.
        /// </summary>
        /// <param name="cage">The <see cref="Rectangle"/> that this 
        /// <see cref="ITransform"/> is not allowed to move outside of.</param>
        /// <exception cref="ArgumentNullException">Thrown if 
        /// <paramref name="cage"/> is null.</exception>
        public CagedTransform2D(Rectangle cage)
        {
            BorderDistance = DefaultBorderDistance;
            Cage = cage;
        }

        /// <summary>
        /// The <see cref="Rectangle"/> that this <see cref="ITransform"/> is 
        /// not allowed to move outside of.
        /// </summary>
        public Rectangle Cage
        {
            get { return _cage; }
            private set
            {
                if(value == null)
                    throw new ArgumentNullException("value", "CagedTransform2D.Cage " + 
                    "cannot be null. Please specify a valid Rectangle.");

                _cage = value;
                _cage.TransformDirtied += CageTransformDirtied;
            }
        }


        /// <summary>
        /// The default value of the property <see cref="BorderDistance"/> which
        /// is ".0001f".
        /// </summary>
        public const float DefaultBorderDistance = .0001f;

        /// <summary>
        /// The distance this <see cref="ITransform"/> places between itself and
        /// the edges of the <see cref="Cage"/>. The default value of this
        /// property is given by <see cref="DefaultBorderDistance"/>.
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException">Thrown if client code
        /// attempts to set a value on this property that is less than or equal 
        /// to 0.</exception>
        public float BorderDistance
        {
            get { return _borderDistance; }
            set
            {
                if(value <= 0)
                    throw new ArgumentOutOfRangeException("value", value, 
                        "The CagedTransform2D.BorderDistance cannot be zero.");

                _borderDistance = value;
                IsUpdateNeeded = true;
            }
        }

        /// <summary>
        /// This method is invoked during the update of the
        /// <see cref="ITransform.WorldMatrix"/> right before the
        /// <see cref="ITransform.WorldMatrix"/> is actually updated. This
        /// method ensures the <see cref="ITransform.LocalMatrix"/> is enclosed
        /// within the <see cref="Cage"/>.
        /// </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 override void PreUpdate(Values.LazyValue<Matrix4> world)
        {
            base.PreUpdate(world);

            // Found out where we are in the world.
            Vector2 worldPosition = world.Value.Translation.Xy;

            // Now calculate how far outside of the cage we have moved (if
            // any).
            float leftDistance = Cage.LeftSide - worldPosition.X;   // Positive value if outside the cage.
            float rightDistance = Cage.RightSide - worldPosition.X; // Negative value if outside the cage.
            float bottomDistance = Cage.Bottom - worldPosition.Y;   // Positive value if outside the cage.
            float topDistance = Cage.Top - worldPosition.Y;         // Negative value if outside the cage.

            // Move the local position so that we are back in the cage, if 
            // necessary.
            Matrix4 local = LocalMatrix;
            Vector2 localPosition = local.Translation.Xy;

            if (leftDistance > 0)
                localPosition.X += (leftDistance + BorderDistance);
            else if (rightDistance < 0)
                localPosition.X += (rightDistance - BorderDistance);

            if (bottomDistance > 0)
                localPosition.Y += (bottomDistance + BorderDistance);
            else if (topDistance < 0)
                localPosition.Y += (topDistance - BorderDistance);

            local.Row3.X = localPosition.X;
            local.Row3.Y = localPosition.Y;
            SetTransformation(ref local);
        }

        /// <summary>
        /// An event handler that is invoked when the <see cref="Cage"/> instance's
        /// <see cref="ITransform.TransformDirtied"/> event has been invoked.
        /// This method ensures that, if the <see cref="Cage"/> moves, this
        /// <see cref="ITransform"/> will stay inside it.
        /// </summary>
        /// <param name="sender">The instance that generated the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the
        /// event data.</param>
        void CageTransformDirtied(object sender, EventArgs e)
        {
            IsUpdateNeeded = true;
        }

        /// <summary>
        /// The backing field to <see cref="Cage"/>.
        /// </summary>
        Rectangle _cage;

        /// <summary>
        /// The backing field to <see cref="BorderDistance"/>.
        /// </summary>
        float _borderDistance;
    }
}