namespace Squish
{
    /// <summary>
    /// An object which contains a two-dimensional grid of values.
    /// </summary>
    /// <typeparam name="T">The type of values.</typeparam>
    public class Grid<T> 
        : IEnumerable<T>
    {
        #region Constructors
        /// <summary>
        /// An object which contains a two-dimensional grid of values.
        /// </summary>
        /// <param name="width">The width.</param>
        /// <param name="height">The height.</param>
        public Grid(int width, int height)
        {
            if (width < 0) width = 0;   // Having a width or height of 0 won't be usable,
            if (height < 0) height = 0; // but at least the value ranges would be "expected"

            _values = new T[height][];
            for (int i = 0; i < height; i++)
                _values[i] = new T[width];

            Width = width;
            Height = height;
        }
        #endregion
        #region Indexers
        /// <summary>
        /// Gets or sets a value.
        /// </summary>
        /// <param name="x">The X coordinate.</param>
        /// <param name="y">The Y coordinate.</param>
        /// <returns>The value.</returns>
        public T this[int x, int y]
        {
            get
            {
                return _values[y][x];
            }
            set
            {
                _values[y][x] = value;
            }
        }
        #endregion

        // Variables
        private readonly T[][] _values;

        // Properties
        #region Width
        /// <summary>
        /// Gets a value which indicates the width.
        /// </summary>
        public int Width
        {
            get;
            private set;
        }
        #endregion
        #region Height
        /// <summary>
        /// Gets a value which indicates the height.
        /// </summary>
        public int Height
        {
            get;
            private set;
        }
        #endregion

        // Methods
        #region Transpose
        /// <summary>
        /// Returns a new object which is the transpose copy of this grid.
        /// </summary>
        /// <returns>The grid.</returns>
        public Grid<T> Transpose()
        {
            Grid<T> result = new Grid<T>(Height, Width);
            for (int y = 0; y < Height; y++)
                for (int x = 0; x < Width; x++)
                    result._values[x][y] = _values[y][x];
            return result;
        }
        #endregion
        #region Flip
        /// <summary>
        /// Returns a new object which is a horizontal or vertical copy of this grid.
        /// </summary>
        /// <param name="horizontal">Whether to perform a horizontal flip.</param>
        /// <param name="vertical">Whether to perform a vertical flip.</param>
        /// <returns>The grid.</returns>
        public Grid<T> Flip(bool horizontal, bool vertical)
        {
            Grid<T> result = new Grid<T>(Width, Height);
            if (horizontal && vertical)
            {
                for (int y = 0; y < Height; y++)
                    for (int x = 0; x < Width; x++)
                        result._values[y][x] = _values[Height - y - 1][Width - x - 1];
                return result;
            }
            if (horizontal)
            {
                for (int y = 0; y < Height; y++)
                    for (int x = 0; x < Width; x++)
                        result._values[y][x] = _values[y][Width - x - 1];
                return result;
            }
            if (vertical)
            {
                for (int y = 0; y < Height; y++)
                    for (int x = 0; x < Width; x++)
                        result._values[y][x] = _values[Height - y - 1][x];
                return result;
            }
            for (int y = 0; y < Height; y++)
                for (int x = 0; x < Width; x++)
                    result._values[y][x] = _values[y][x];
            return result;
        }
        #endregion
        #region Rotate
        /// <summary>
        /// Returns a new object which is the rotation copy of this grid.
        /// </summary>
        /// <param name="clockwise">Whether to rotate clockwise or anti-clockwise.</param>
        /// <returns>The grid.</returns>
        public Grid<T> Rotate(bool clockwise)
        {
            Grid<T> result = new Grid<T>(Height, Width);
            if (clockwise)
            {
                for (int y = 0; y < Height; y++)
                    for (int x = 0; x < Width; x++)
                        result._values[x][y] = _values[Height - y - 1][x];
            }
            else
            {
                for (int y = 0; y < Height; y++)
                    for (int x = 0; x < Width; x++)
                        result._values[x][y] = _values[y][Width - x - 1];
            }
            return result;
        }
        #endregion

        #region Copy
        /// <summary>
        /// Returns a new object which is a copy of the grid.
        /// </summary>
        /// <returns>The grid.</returns>
        public Grid<T> Copy()
        {
            Grid<T> result = new Grid<T>(Width, Height);
            for (int y = 0; y < Height; y++)
                for (int x = 0; x < Width; x++)
                    result._values[y][x] = _values[y][x];
            return result;
        }
        #endregion
        #region Slice
        /// <summary>
        /// Returns a new object which is a subregion of the grid.
        /// </summary>
        /// <param name="region">The region.</param>
        /// <returns>The grid.</returns>
        public Grid<T> Slice(Rectangle region)
        {
            region = Rectangle.Intersect(region, new Rectangle(0, 0, Width, Height));

            Grid<T> result = new Grid<T>(region.Width, region.Height);
            for (int y = 0; y < region.Height; y++)
                for (int x = 0; x < region.Width; x++)
                    result._values[y][x] = _values[region.Y + y][region.X + x];
            return result;
        }
        
        /// <summary>
        /// Returns a new object which is a subregion of the grid.
        /// </summary>
        /// <param name="x">The X coordinate.</param>
        /// <param name="y">The Y coordinate.</param>
        /// <param name="width">The width.</param>
        /// <param name="height">The height.</param>
        /// <returns>The grid.</returns>
        public Grid<T> Slice(int x, int y, int width, int height)
        {
            return Slice(new Rectangle(x, y, width, height));
        }
        #endregion

        #region GetEnumerator
        /// <summary>
        /// Enumerates the elements of the grid.
        /// </summary>
        /// <returns>The values.</returns>
        public IEnumerator<T> GetEnumerator()
        {
            for (int y = 0; y < Height; y++)
                for (int x = 0; x < Width; x++)
                    yield return _values[y][x];
        }

        /// <summary>
        /// Enumerates the elements of the grid.
        /// </summary>
        /// <returns>The value.</returns>
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
        #endregion
    }
}