using System;
using Chernobyl.Mathematics.Collision;
using Chernobyl.Mathematics.Movement;
using Chernobyl.Mathematics.Vectors;

namespace Chernobyl.Mathematics.Geometry
{
    // TODO: Circle should derive from Shape instead of MatrixTransform. Do this after we've implemented Circles tests.

    /// <summary>
    /// A 2D circle that is composed of a center origin and a radius. The 
    /// <see cref="Circle"/> has collision capabilities and implements the 
    /// <see cref="ITransform"/> and <see cref="IShape"/> interfaces.
    /// </summary>
    public class Circle : MatrixTransform, ICollidable2D, IEquatable<Circle>
    {
        /// <summary>
        /// Constructor that sets the origin of this circle to (0.0, 0.0).
        /// </summary>
        /// <param name="radius">The radius of the circle.</param>
        public Circle(float radius) : this(0.0f, 0.0f, radius)
        {}

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="x">The center X coordinate of the circle.</param>
        /// /// <param name="y">The center Y coordinate of the circle.</param>
        /// <param name="radius">The distance from the origin of the circle to 
        /// the outside edge of the circle.</param>
        public Circle(float x, float y, float radius)
            : this(new Vector2(x, y), radius)
        { }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="origin">The center coordinate of the circle.</param>
        /// <param name="radius">The distance from the origin of the circle to 
        /// the outside edge of the circle.</param>
        public Circle(Vector2 origin, float radius)
        {
            Position = new Vector3(origin);
            Radius = radius;
        }

        /// <summary>
        /// An event that is raised when a collidable has started colliding with
        /// this collidable. When the collision has ended, OnCollisionEnded will
        /// be raised.
        /// </summary>
        public event EventHandler OnCollisionStarted;

        /// <summary>
        /// An event that is raised when the collision with a collidable has 
        /// ended. This will event will be raised after the invocation of 
        /// OnCollisionStarted
        /// </summary>
        public event EventHandler OnCollisionEnded;

        /// <summary>
        /// Tests for a collision between this circle and the circle passed in.
        /// </summary>
        /// <param name="circle">The collidable to test for collision against.</param>
        /// <returns>True if there was a collision, false if otherwise.</returns>
        public bool IsColliding(Circle circle)
        {
            // The two circles are colliding if the distance between the first 
            // circles origin and the origin of the second circle are less than 
            // the radius of the two circles combined. Normally, we would use the 
            // distance equation here but there is an optimization we can use 
            // called the "distance squared". With this equation we will also 
            // have to square the combined radii.
            float sumOfRadii = Radius + circle.Radius;
            Vector2 originToOriginVector = new Vector2(Position.X - circle.Position.X, Position.Y - circle.Position.Y);

            if (sumOfRadii * sumOfRadii > (originToOriginVector.X * originToOriginVector.X) + (originToOriginVector.Y * originToOriginVector.Y))
                return true;
            return false;
        }

        /// <summary>
        /// Tests for a collision between this circle and the Point2D passed in.
        /// </summary>
        /// <param name="point">The point to test for collision against.</param>
        /// <returns>True if there was a collision, false if otherwise.</returns>
        public bool IsColliding(Point2D point)
        {
            return point.IsColliding(this);
        }

        /// <summary>
        /// Tests for a collision between this circle and the rectangle passed in.
        /// </summary>
        /// <param name="rectangle">The rectangle to test for collision against.</param>
        /// <returns>True if there was a collision, false if otherwise.</returns>
        public bool IsColliding(Rectangle rectangle)
        {
            return rectangle.IsColliding(this);
        }

        /// <summary>
        /// Called when this collidable has started colliding with another 
        /// collidable. This Circle just invokes its OnCollision instance when 
        /// this method is invoked.
        /// </summary>
        /// <param name="collider">The object that was just hit.</param>
        public void HandleCollisionStarted(ICollidable collider)
        {
            if (OnCollisionStarted != null)
                OnCollisionStarted(this, EventArgs.Empty);
        }

        /// <summary>
        /// Called when this collidable has stopped colliding with another 
        /// collidable.
        /// </summary>
        /// <param name="collider">The object that was just hit.</param>
        public void HandleCollisionEnded(ICollidable collider)
        {
            if (OnCollisionEnded != null)
                OnCollisionEnded(this, EventArgs.Empty);
        }

        /// <summary>
        /// This method is invoked during the update of the
        /// <see cref="ITransform.WorldMatrix"/> right after the
        /// <see cref="ITransform.WorldMatrix"/> has been updated. This method
        /// ensures the radius has been calculatted from the current
        /// <see cref="ITransform.WorldMatrix"/>.
        /// </summary>
        /// <param name="world">The new value of the
        /// <see cref="ITransform.WorldMatrix"/>.</param>
        protected override void PostUpdate(ref Matrix4 world)
        {
            base.PostUpdate(ref world);

            // store the radius. Note that, we use the right vector here 
            // just because we can. In a circle, the length of the right and 
            // up vector will all be the same.
            _radiusCache = WorldMatrix.Right.Length;
        }

        /// <summary>
        /// Scales the transform along the X axis. Note that, scaling a circle 
        /// along the X axis also causes the same scale to be applied to the Y 
        /// axis because circles cannot have different X/Y scales.
        /// </summary>
        /// <param name="amount">The amount to scale in the X axis.</param>
        public override void ScaleX(float amount)
        {
            // circles cannot be scaled differently in the X or Y (otherwise it 
            // it is not a true circle). So if the user attempts to scale the X 
            // we are also going to scale the Y by the same amount.
            base.Scale(amount, amount);
        }

        /// <summary>
        /// Scales the transform in the Y axis. Note that, scaling a circle 
        /// along the Y axis also causes the same scale to be applied to the X 
        /// axis because circles cannot have different X/Y scales.
        /// </summary>
        /// <param name="amount">The amount to scale in the Y axis.</param>
        public override void ScaleY(float amount)
        {
            // circles cannot be scaled differently in the X or Y (otherwise it 
            // it is not a true circle). So if the user attempts to scale the Y 
            // we are also going to scale the X by the same amount.
            base.Scale(amount, amount);
        }

        /// <summary>
        /// A string that contains the center and radius of this 
        /// <see cref="Circle"/> in the form of {X=n, Y=n, Radius=n}, 
        /// where 'X' and 'Y' are the <see cref="ITransform.Position"/>'s 
        /// <see cref="Vector3.X"/> and <see cref="Vector3.Y"/> and 'n' is some 
        /// number. For example: {X=20, Y=20, Radius=100}.
        /// </summary>
        /// <returns>
        /// A <see cref="String"/> that represents this instance.
        /// </returns>
        public override string ToString()
        {
            return "{X=" + Position.X + ", Y=" + Position.Y + ", Radius=" + Radius + "}";
        }

        /// <summary>
        /// Determines whether the specified <see cref="Object"/> is equal to 
        /// this instance. In order for two <see cref="Circle"/>s to be equal
        /// they both need to have the same <see cref="ITransform.Position"/> 
        /// and <see cref="Radius"/>.
        /// </summary>
        /// <param name="obj">The <see cref="Object"/> to compare with this 
        /// instance.</param>
        /// <returns>True if the specified <see cref="Object"/> is equal to this
        /// instance; otherwise, false.
        /// </returns>
        public override bool Equals(object obj)
        {
            return Equals(obj as Circle);
        }

        /// <summary>
        /// Determines whether the specified <see cref="Circle"/> is equal to 
        /// this instance. In order for two <see cref="Circle"/>s to be equal
        /// they both need to have the same <see cref="ITransform.Position"/> 
        /// and <see cref="Radius"/>.
        /// </summary>
        /// <param name="circle">The <see cref="Circle"/> to compare with this 
        /// instance.</param>
        /// <returns>True if the specified <see cref="Circle"/> is equal to this
        /// instance; otherwise, false.
        /// </returns>
        public bool Equals(Circle circle)
        {
            return ReferenceEquals(this, circle) || 
                   (Position == circle.Position && 
                   Radius == circle.Radius);
        }

        /// <summary>
        /// Implements the equality (==) operator. In order for two 
        /// <see cref="Circle"/>s to be equal they both need to have the same 
        /// <see cref="ITransform.Position"/> and <see cref="Radius"/>.
        /// </summary>
        /// <param name="left">The instance to compare to the 
        /// <paramref name="right"/> instance.</param>
        /// <param name="right">The instance to compare to the 
        /// <paramref name="left"/> instance.</param>
        /// <returns>True if the two instances are equal, false if otherwise.</returns>
        public static bool operator ==(Circle left, Circle right)
        {
            return left.Equals(right);
        }

        /// <summary>
        /// Implements the not-equal (!=) operator. In order for two 
        /// <see cref="Circle"/>s to not be equal they both need to have 
        /// different <see cref="ITransform.Position"/> and <see cref="Radius"/>. 
        /// </summary>
        /// <param name="left">The instance to compare to the 
        /// <paramref name="right"/> instance.</param>
        /// <param name="right">The instance to compare to the 
        /// <paramref name="left"/> instance.</param>
        /// <returns>True if the two instances are NOT equal, false if otherwise.</returns>
        public static bool operator !=(Circle left, Circle right)
        {
            return !(left == right);
        }

        /// <summary>
        /// Returns a hash code for this instance.
        /// </summary>
        /// <returns>
        /// A hash code for this instance, suitable for use in hashing algorithms
        /// and data structures like a hash table. 
        /// </returns>
        public override int GetHashCode()
        {
            return Position.GetHashCode() ^ Radius.GetHashCode();
        }

        /// <summary>
        /// The distance from the origin of the circle to it's outer edge.
        /// </summary>
        public float Radius 
        { 
            get
            {
                // ensure the radius cache is up to date
                Update();
                return _radiusCache; 
            }
            set
            {
                if (value < 0)
                    throw new ArgumentException("The radius of the Circle cannot be negative. You specified: " + value, "value");

                // Grab the local matrix and set its column 0 (the first column, 
                // which holds the scale in the X axis) and column 1 (the second 
                // column, which holds the scale in the Y axis) to unit vector 
                // scaled by our new radius multiplied by two. We multiply be 
                // two because we assume the circle has a diameter of 1 by 
                // default, therefore, if we wanted to give the circle a radius 
                // of 1, we would need to scale the circle by 2 because that 
                // would that would make the circles diameter 2 with a radius 
                // of 1.
                float diameter = value * 2;
                Matrix4 local = LocalMatrix;

                Vector3 xAxis = Vector3.UnitX * diameter;
                local.M11 = xAxis.X;
                local.M21 = xAxis.Y;
                local.M31 = xAxis.Z;

                Vector3 yAxis = Vector3.UnitY * diameter;
                local.M12 = yAxis.X;
                local.M22 = yAxis.Y;
                local.M32 = yAxis.Z;

                SetTransformation(ref local);
            }
        }

        /// <summary>
        /// The largest distance between any two points on the circle and the
        /// distance that passes through the circles origin.
        /// </summary>
        public float Diameter
        {
            get { return Radius * 2; }
        }

        /// <summary>
        /// Returns the total area of the circle as PI * Radius ^ 2.
        /// </summary>
        public float Area
        {
            get { return (float)Math.PI * (Radius * Radius); }
        }

        /// <summary>
        /// Returns the length of the circles perimeter (the circumference) as 
        /// 2 * PI * Radius.
        /// </summary>
        public float Perimeter
        {
            get { return 2 * (float)Math.PI * Radius; }
        }

        /// <summary>
        /// The amount of 3D space this object consumes in cubic metres (m^3).
        /// If this object is 2D, then the value of this property is zero.
        /// This property will alway return 0 for the <see cref="Circle"/>.
        /// </summary>
        public float Volume
        {
            get { return 0; }
        }

        /// <summary>
        /// True if this <see cref="IShape"/> is convex, false if it is concave
        /// or has 0 <see cref="Dimensions"/> (such as a point). A
        /// <see cref="IShape"/> is convex if for every pair of points within
        /// the object, every point on the straight line segment that joins them
        /// is also within the object. A concave <see cref="IShape"/> is the
        /// opposite of this. This property will alway return true for the 
        /// <see cref="Circle"/>.
        /// </summary>
        public bool IsConvex
        {
            get { return true; }
        }

        /// <summary>
        /// The minimum number of coordinates needed to specify each point
        /// within this object. For example: a point has 0 dimensions, a
        /// line has 1 dimension, a circle or rectangle has 2 dimensions, a
        /// cube or sphere has 3 dimensions, and a moving cube or sphere has 4.
        /// This property will alway return 2 for the <see cref="Circle"/>.
        /// </summary>
        public uint Dimensions
        {
            get { return 2; }
        }

        /// <summary>
        /// The largest width of the geometric primitive. Always returns the
        /// <see cref="Diameter"/> of the circle.
        /// </summary>
        public float Width { get { return Diameter; } }

        /// <summary>
        /// The largest height of the geometric primitive. Always returns the
        /// <see cref="Diameter"/> of the circle.
        /// </summary>
        public float Height { get { return Diameter; } }

        /// <summary>
        /// The largest depth of the object in the object's Z axis. This class 
        /// will always return 0 for depth as it is a 2D object.
        /// </summary>
        public float Depth { get { return 0; } }

        /// <summary>
        /// The radius of this <see cref="Rectangle"/> held for speed of access.
        /// </summary>
        float _radiusCache;
    }
}