using System;

namespace RidR
{
    /// <summary>
    /// Represents an ordered pair of integer x- and y-coordinates that defines a point in a two-dimensional plane.
    /// </summary>
    public struct Position
    {
        /// <summary>
        /// Gets a value indicating whether this Point is empty.
        /// </summary>
        public bool IsEmpty
        {
            get { return X == 0 && Y == 0; }
        }
        /// <summary>
        /// Gets or sets the x-coordinate of this point.
        /// </summary>
        public int X
        { get; set; }
        /// <summary>
        /// Gets or sets the y-coordiante of this point.
        /// </summary>
        public int Y
        { get; set; }

        /// <summary>
        /// Initializes a new instance of the Position class with the specified coordinates.
        /// </summary>
        /// <param name="x">The x coordinate for this position</param>
        /// <param name="y">The y coordinate for this position</param>
        public Position(int x, int y)
            : this()
        {
            X = x;
            Y = y;
        }

        /// <summary>
        /// Initializes a new instance of the Position class with the specified position.
        /// </summary>
        /// <param name="p">The position to copy</param>
        public Position(Position p)
            : this()
        {
            X = p.X;
            Y = p.Y;
        }

        /// <summary>
        /// Specifies whether this Position contains the same coordinates as the specified Object. 
        /// </summary>
        /// <param name="obj">The Object to test</param>
        public override bool Equals(object obj)
        {
            return obj is Position && this == (Position)obj;
        }

        /// <summary>
        /// Returns a hash code for this Position.
        /// </summary>
        public override int GetHashCode()
        {
            return X ^ Y;
        }

        /// <summary>
        /// The Manhatten distance between two Position instances.
        /// </summary>
        /// <param name="a">The first position</param>
        /// <param name="b">The second position</param>
        public static int ManhattenDistance(Position a, Position b)
        {
            return Math.Abs(a.X - b.X) + Math.Abs(a.Y - b.Y);
        }

        /// <summary>
        /// The distance between two Position instances.
        /// </summary>
        /// <param name="a">The first position</param>
        /// <param name="b">The second position</param>
        public static float Distance(Position a, Position b)
        {
            return (float)Math.Sqrt((a.X - b.X) * (a.X - b.X) + (a.Y - b.Y) * (a.Y - b.Y));
        }

        /// <summary>
        /// Converts this Position to a human-readable string
        /// </summary>
        public override string ToString()
        {
            return X + " " + Y;
        }

        #region Operators

        /// <summary>
        /// Compares two Position objects. The result specifies whether the values of the X and Y 
        /// properties of the two Positions objects are equal.
        /// </summary>
        /// <param name="lhs">A Position to compare</param>
        /// <param name="rhs">A Position to compare</param>
        public static bool operator ==(Position lhs, Position rhs)
        {
            return lhs.X == rhs.X && lhs.Y == rhs.Y;
        }

        /// <summary>
        /// Compares two Position objects. The result specifies whether the values of the X and Y 
        /// properties of the two Positions objects are unequal.
        /// </summary>
        /// <param name="lhs">A Position to compare</param>
        /// <param name="rhs">A Position to compare</param>
        public static bool operator !=(Position lhs, Position rhs)
        {
            return !(lhs == rhs);
        }

        /// <summary>
        /// Translates a Position with another Position
        /// </summary>
        /// <param name="lhs">The position to translate</param>
        /// <param name="rhs">The position to add</param>
        public static Position operator +(Position lhs, Position rhs)
        {
            return new Position(lhs.X + rhs.X, lhs.Y + rhs.Y);
        }

        /// <summary>
        /// Translates a Position with the negative of another Position
        /// </summary>
        /// <param name="lhs">The position to translate</param>
        /// <param name="rhs">The position to subtract</param>
        public static Position operator -(Position lhs, Position rhs)
        {
            return new Position(lhs.X - rhs.X, lhs.Y - rhs.Y);
        }

        /// <summary>
        /// Scales this position as a vector.
        /// </summary>
        /// <param name="scalar">The scalar value</param>
        /// <param name="p">The position to scale</param>
        public static Position operator *(int scalar, Position p)
        {
            return p * scalar;
        }

        /// <summary>
        /// Scales this position as a vector.
        /// </summary>
        /// <param name="p">The position to scale</param>
        /// <param name="scalar">The scalar value</param>
        public static Position operator *(Position p, int scalar)
        {
            return new Position(p.X * scalar, p.Y * scalar);
        }

        /// <summary>
        /// Scales the position as a vector with an inverted scalar.
        /// </summary>
        /// <param name="p">The position to scale</param>
        /// <param name="devider">The scalar to invert</param>
        public static Position operator /(Position p, int devider)
        {
            return new Position(p.X / devider, p.Y / devider);
        }

        /// <summary>
        /// Returns the negative of this position
        /// </summary>
        /// <param name="p">The current position</param>
        public static Position operator -(Position p)
        {
            return new Position(-p.X, -p.Y);
        }

        #endregion
    }
}