using System;
using Chernobyl.Mathematics.Vectors;

namespace Chernobyl.Mathematics.Measures
{
    /// <summary>
    /// A type that is used to contain the location of a cell in a 2D grid.
    /// </summary>
    public struct RowColumn
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="RowColumn"/> struct.
        /// </summary>
        /// <param name="row">The X index location where -N is the left most 
        /// cell and N is the right most.</param>
        /// <param name="column">The Y index location where -N is the bottom most
        /// cell and N is the top most.</param>
        public RowColumn(int row, int column)
        {
            _row = row;
            _column = column;
        }

        /// <summary>
        /// The X index location where -N is the left most cell and N is the
        /// right most.
        /// </summary>
        public int Row { get { return _row; } }

        /// <summary>
        /// The Y index location where -N is the bottom most cell and N is the
        /// top most.
        /// </summary>
        public int Column { get { return _column; } }

        /// <summary>
        /// Returns the center point of this cell based on the size of a single
        /// cell within a uniform grid.
        /// </summary>
        /// <param name="cellSize">The width (<see cref="Vector2.X"/>) and height
        /// (<see cref="Vector2.Y"/>) of a single cell in the uniform grid.</param>
        /// <returns>The center position of the cell.</returns>
        /// <exception cref="ArgumentOutOfRangeException">Thrown if either width
        /// (<see cref="Vector2.X"/>) or height (<see cref="Vector2.Y"/>) of a 
        /// <paramref name="cellSize"/> are less than or equal to zero.</exception>
        public Vector2 GetCenter(Vector2 cellSize)
        {
            if (cellSize.X <= 0)
                throw new ArgumentOutOfRangeException("cellSize", cellSize.X,
                    "The width of the cell cannot be less than or equal to 0.");
            if (cellSize.Y <= 0)
                throw new ArgumentOutOfRangeException("cellSize", cellSize.Y,
                    "The height of the cell cannot be less than or equal to 0.");

            float halfWidth = cellSize.X * .5f;
            float halfHeight = cellSize.Y * .5f;
            return new Vector2(cellSize.Y * (Column + 1.0f) - halfHeight,
                               cellSize.X * (Row + 1.0f) - halfWidth);
        }

        /// <summary>
        /// Returns the index location of a cell based on a (X, Y) position and 
        /// the size of each cell in a uniform grid.
        /// </summary>
        /// <param name="cellSize">The width (<see cref="Vector2.X"/>) and height
        /// (<see cref="Vector2.Y"/>) of a single cell in the uniform grid.</param>
        /// <param name="position">A point that intersects the cell to retrieve.</param>
        /// <returns>The index location of the cell which touches
        /// <paramref name="position"/>.</returns>
        /// <exception cref="ArgumentOutOfRangeException">Thrown if either width
        /// (<see cref="Vector2.X"/>) or height (<see cref="Vector2.Y"/>) of a 
        /// <paramref name="cellSize"/> are less than or equal to zero.</exception>
        public static RowColumn FromPosition(Vector2 cellSize, Vector2 position)
        {
            if(cellSize.X <= 0)
                throw new ArgumentOutOfRangeException("cellSize", cellSize.X,
                    "The width of the cell cannot be less than or equal to 0.");
            if(cellSize.Y <= 0)
                throw new ArgumentOutOfRangeException("cellSize", cellSize.Y,
                    "The height of the cell cannot be less than or equal to 0.");

            return new RowColumn((int)(position.Y / cellSize.Y),
                                 (int)(position.X / cellSize.X));
        }

        /// <summary>
        /// Checks if two <see cref="RowColumn"/> are equal to each other.
        /// </summary>
        /// <param name="left">The left side of the operation.</param>
        /// <param name="right">The right side of the operation.</param>
        /// <returns>True if the two are equal, false if otherwise.</returns>
        public static bool operator ==(RowColumn left, RowColumn right)
        {
            return left.Equals(right);
        }

        /// <summary>
        /// Checks if two <see cref="RowColumn"/> are equal to each other.
        /// </summary>
        /// <param name="left">The left side of the operation.</param>
        /// <param name="right">The right side of the operation.</param>
        /// <returns>True if the two are different, false if otherwise.</returns>
        public static bool operator !=(RowColumn left, RowColumn right)
        {
            return !(left == right);
        }

        /// <summary>
        /// Gets the hash code of the Radian.
        /// </summary>
        /// <returns>The hash code of the number.</returns>
        public override int GetHashCode()
        {
            return Row.GetHashCode() ^ Column.GetHashCode();
        }

        /// <summary>
        /// Indicates whether the current object is equal to another object of 
        /// the same type.
        /// </summary>
        /// <param name="other">An object to compare with this object.</param>
        /// <returns>True if the current object is equal to the 
        /// <paramref name="other"/> parameter; otherwise, false.
        /// </returns>
        public bool Equals(RowColumn other)
        {
            return (Row == other.Row && Column == other.Column);
        }

        /// <summary>
        /// Checks this <see cref="RowColumn"/> for equality with object passed in.
        /// </summary>
        /// <param name="obj">The object to compare to.</param>
        /// <returns>True if the object is equal to this <see cref="RowColumn"/>,
        /// false if otherwise.</returns>
        public override bool Equals(object obj)
        {
            return (obj is RowColumn && Equals((RowColumn)obj));
        }

        /// <summary>
        /// Returns a <see cref="String"/> that represents this instance in the
        /// form: "(Row, Column)".
        /// </summary>
        /// <returns>A <see cref="String"/> that represents this instance.</returns>
        public override string ToString()
        {
            return String.Format("({0}, {1})", Row, Column);
        }

        /// <summary>
        /// The backing field to <see cref="Row"/>.
        /// </summary>
        int _row;

        /// <summary>
        /// The backing field to <see cref="Column"/>.
        /// </summary>
        int _column;
    }
}