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

namespace Chernobyl.Mathematics.Geometry
{
    /// <summary>
    /// A 2D point with an X and a Y coordinate. Unlike a 2D vector 
    /// (<see cref="Vector2"/>), the <see cref="Point2D"/> has collision 
    /// capabilities and implements the <see cref="ITransform"/> and 
    /// <see cref="IShape"/> interfaces.
    /// </summary>
    public class Point2D : MatrixTransform, ICollidable2D, IEquatable<Point2D>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Point2D"/> class.
        /// </summary>
        public Point2D()
            : this(Vector2.Zero)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="Point2D"/> class.
        /// </summary>
        /// <param name="point">The (X, Y) coordinate of the point.</param>
        public Point2D(Vector2 point) : this(point.X, point.Y)
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="Point2D"/> class.
        /// </summary>
        /// <param name="x">The X coordinate of the point.</param>
        /// <param name="y">The Y coordinate of the point.</param>
        public Point2D(float x, float y)
        {
            X = x;
            Y = y;
        }

        /// <summary>
        /// Explicit conversion from a vector to a Point2D. Note that an implicit
        /// conversion from Point2D to Vector2 is NOT provided because data is
        /// lost in that conversion.
        /// </summary>
        /// <param name="vector">The vector to convert from.</param>
        /// <returns>The converted Point2D.</returns>
        public static explicit operator Point2D(Vector2 vector)
        {
            return new Point2D(vector);
        }

        /// <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 point and the point 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.X == X && point.Y == Y);
        }

        /// <summary>
        /// Tests for a collision between this point and the Circle passed in.
        /// </summary>
        /// <param name="circle">The Circle to test for collision against.</param>
        /// <returns>True if there was a collision, false if otherwise.</returns>
        public bool IsColliding(Circle circle)
        {
            // the point is inside the circle if the distance between point and
            // the origin of the circle is less than the radius of the circle.
            // 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 radius.
            Vector2 originToPointVector = new Vector2(circle.Position.X - X, circle.Position.Y - Y);
            if ((originToPointVector.X * originToPointVector.X) + (originToPointVector.Y * originToPointVector.Y) < circle.Radius * circle.Radius)
                return true;
            return false;
        }

        /// <summary>
        /// Tests for a collision between this point 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 point just invokes the OnCollisionStarted event.
        /// </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>
        /// A string that contains the points position <see cref="Point2D"/> in 
        /// the form of {X=n, Y=n}, where 'n' is some number. For example: 
        /// {X=20, Y=20}.
        /// </summary>
        /// <returns>
        /// A <see cref="String"/> that represents this instance.
        /// </returns>
        public override string ToString()
        {
            return "{X=" + X + ", Y=" + Y + "}";
        }

        /// <summary>
        /// Determines whether the specified <see cref="Object"/> is equal to 
        /// this instance. In order for two <see cref="Rectangle"/>s to be equal
        /// they both need to have the same <see cref="ITransform.Position"/>, 
        /// <see cref="Width"/>, and <see cref="Height"/>.
        /// </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 Point2D);
        }

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

        /// <summary>
        /// Implements the equality (==) operator. In order for two 
        /// <see cref="Point2D"/>s to be equal they both need to have the same 
        /// <see cref="ITransform.Position"/>. 
        /// </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 ==(Point2D left, Point2D right)
        {
            return left.Equals(right);
        }

        /// <summary>
        /// Implements the not-equal (!=) operator. In order for two 
        /// <see cref="Point2D"/>s to be not equal they both need to have 
        /// different <see cref="ITransform.Position"/>s. 
        /// </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 !=(Point2D left, Point2D 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();
        }

        /// <summary>
        /// The X coordinate of the point. 
        /// </summary>
        public float X 
        {
            get { return Position.X; }
            set { Position = new Vector3(value, Y, LocalMatrix.Translation.Z); }
        }

        /// <summary>
        /// The Y coordinate of the point.
        /// </summary>
        public float Y
        {
            get { return Position.Y; }
            set { Position = new Vector3(X, value, LocalMatrix.Translation.Z); }
        }

        /// <summary>
        /// The largest width of the object in the object's X axis. This class 
        /// will always return 0 for it's Width.
        /// </summary>
        public float Width { get { return 0; } }

        /// <summary>
        /// The largest height of the object in the object's Y axis. This class 
        /// will always return 0 for it's Height.
        /// </summary>
        public float Height { get { return 0; } }

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

        /// <summary>
        /// True if this <see cref="IShape"/> is convex, false if it is concave.
        /// 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. A Point2D always returns true.
        /// </summary>
        public bool IsConvex
        {
            get { return true; }
        }

        /// <summary>
        /// The amount of space taken up by an object on a flat plane in
        /// square metres (m^2). This property will always return 0 
        /// for the <see cref="Point2D"/>.
        /// </summary>
        public float Area
        {
            get { return 0; }
        }

        /// <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 always return 0 for the <see cref="Point2D"/>.
        /// </summary>
        public float Volume
        {
            get { return 0; }
        }

        /// <summary>
        /// The length of the path that surrounds a shape specified in metres (m).
        /// In the case of a closed curve such as a circle, this value represents
        /// the circumference of the object. This property will always return 0 
        /// for the <see cref="Point2D"/>.
        /// </summary>
        public float Perimeter
        {
            get { return 0; }
        }

        /// <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 always return 0 for the <see cref="Point2D"/>.
        /// </summary>
        public uint Dimensions
        {
            get { throw new NotImplementedException(); }
        }
    }
}