using System;
using System.Collections.Generic;
using System.Linq;
using Coord2D = System.Tuple<int, int>;

namespace Chernobyl
{
    /// <summary>
    /// Holds utility code for arrays.
    /// </summary>
    /// <typeparam name="T">The type of the array that is being worked with.</typeparam>
    public static class Array<T>
    {
        /// <summary>
        /// A static array instance that contains no elements. The MSDN
        /// guidelines state that null arrays should be avoided and empty arrays
        /// should be used in their place
        /// (http://msdn.microsoft.com/en-us/library/k2604h5s.aspx).
        /// </summary>
        public static readonly T[] Empty = new T[0];
    }

    /// <summary>
    /// Extension and utility methods for 2D arrays.
    /// </summary>
    public static class Array2D
    {
        /// <summary>
        /// Returns the X axis of the vector.
        /// </summary>
        public static int X(this Coord2D v) => v.Item1;

        /// <summary>
        /// Returns the Y axis of the vector.
        /// </summary>
        public static int Y(this Coord2D v) => v.Item2;

        /// <summary>
        /// Converts a reference tuple coordinate to a value tuple coordinate.
        /// </summary>
        public static (int x, int y) ToValueTuple(this Coord2D v) => (v.X(), v.Y());

        /// <summary>
        /// Converts a value tuple coordinate to a reference tuple coordinate.
        /// </summary>
        public static Coord2D ToValueTuple(this (int x, int y) v) => Tuple.Create(v.x, v.y);

        /// <summary>
        /// Attempts to get the value at the specified 2D array coordinate.
        /// </summary>
        /// <typeparam name="T">The type of the array 2D.</typeparam>
        /// <param name="array2D">A 2D array whose values are in column/row order. i.e. array2D[1][2]
        /// is the value in column 1, row 2.</param>
        /// <param name="cell">The location of the value.</param>
        /// <param name="value">The instance that is to take the value.</param>
        /// <returns>False if the value could not be retrieved, true if otherwise.</returns>
        public static bool TryGet<T>(this T[][] array2D, Coord2D cell, out T value)
        {
            var result = false;
            value = default;

            if(array2D.Bounds2D(cell))
            {
                value = array2D[cell.X()][cell.Y()];
                result = true;
            }

            return result;
        }

        /// <summary>
        /// Returns true if <paramref name="cell"/> is inside <paramref name="array2D"/>, false if
        /// otherwise.
        /// </summary>
        public static bool Bounds2D<T>(this T[][] array2D, Coord2D cell)
        {
            var result = false;

            if (0 <= cell.X() && cell.X() < array2D.Length)
            {
                var column = array2D[cell.X()];
                if (0 <= cell.Y() && cell.Y() < column.Length)
                    result = true;
            }

            return result;
        }

        static Coord2D Add(Coord2D a, Coord2D b) => Tuple.Create(a.Item1 + b.Item1, a.Item2 + b.Item2);

        /// <summary>
        /// Calculates the coordinates above <paramref name="point"/>.
        /// </summary>
        public static Coord2D GetNorthCoordinates(this Coord2D point) => Add(point, new Coord2D(0, 1));

        /// <summary>
        /// Calculates the coordinates above and to the right of <paramref name="point"/>.
        /// </summary>
        public static Coord2D GetNorthEastCoordinates(this Coord2D point) => Add(point, new Coord2D(1, 1));

        /// <summary>
        /// Calculates the coordinates right of <paramref name="point"/>.
        /// </summary>
        public static Coord2D GetEastCoordinates(this Coord2D point) => Add(point, new Coord2D(1, 0));

        /// <summary>
        /// Calculates the coordinates right and below <paramref name="point"/>.
        /// </summary>
        public static Coord2D GetSouthEastCoordinates(this Coord2D point) => Add(point, new Coord2D(1, -1));

        /// <summary>
        /// Calculates the coordinates below <paramref name="point"/>.
        /// </summary>
        public static Coord2D GetSouthCoordinates(this Coord2D point) => Add(point, new Coord2D(0, -1));

        /// <summary>
        /// Calculates the coordinates right and left <paramref name="point"/>.
        /// </summary>
        public static Coord2D GetSouthWestCoordinates(this Coord2D point) => Add(point, new Coord2D(-1, -1));

        /// <summary>
        /// Calculates the coordinates left <paramref name="point"/>.
        /// </summary>
        public static Coord2D GetWestCoordinates(this Coord2D point) => Add(point, new Coord2D(-1, 0));

        /// <summary>
        /// Calculates the coordinates right and above <paramref name="point"/>.
        /// </summary>
        public static Coord2D GetNorthWestCoordinates(this Coord2D point) => Add(point, new Coord2D(-1, 1));

        /// <summary>
        /// Attempts to retrieve the <paramref name="value"/> at the point <paramref name="relativeTo"/>.
        /// </summary>
        public static bool TryGetNorth<T>(this T[][] array2D, Coord2D relativeTo, out T value) =>
            array2D.TryGet(relativeTo.GetNorthCoordinates(), out value);

        /// <summary>
        /// Attempts to retrieve the <paramref name="value"/> at the point <paramref name="relativeTo"/>.
        /// </summary>
        public static bool TryGetNorthEast<T>(this T[][] array2D, Coord2D relativeTo, out T value) =>
            array2D.TryGet(relativeTo.GetNorthEastCoordinates(), out value);

        /// <summary>
        /// Attempts to retrieve the <paramref name="value"/> at the point <paramref name="relativeTo"/>.
        /// </summary>
        public static bool TryGetEast<T>(this T[][] array2D, Coord2D relativeTo, out T value) =>
            array2D.TryGet(relativeTo.GetEastCoordinates(), out value);

        /// <summary>
        /// Attempts to retrieve the <paramref name="value"/> at the point <paramref name="relativeTo"/>.
        /// </summary>
        public static bool TryGetSouthEast<T>(this T[][] array2D, Coord2D relativeTo, out T value) =>
            array2D.TryGet(relativeTo.GetSouthEastCoordinates(), out value);

        /// <summary>
        /// Attempts to retrieve the <paramref name="value"/> at the point <paramref name="relativeTo"/>.
        /// </summary>
        public static bool TryGetSouth<T>(this T[][] array2D, Coord2D relativeTo, out T value) =>
            array2D.TryGet(relativeTo.GetSouthCoordinates(), out value);

        /// <summary>
        /// Attempts to retrieve the <paramref name="value"/> at the point <paramref name="relativeTo"/>.
        /// </summary>
        public static bool TryGetSouthWest<T>(this T[][] array2D, Coord2D relativeTo, out T value) =>
            array2D.TryGet(relativeTo.GetSouthWestCoordinates(), out value);

        /// <summary>
        /// Attempts to retrieve the <paramref name="value"/> at the point <paramref name="relativeTo"/>.
        /// </summary>
        public static bool TryGetWest<T>(this T[][] array2D, Coord2D relativeTo, out T value) =>
            array2D.TryGet(relativeTo.GetWestCoordinates(), out value);

        /// <summary>
        /// Attempts to retrieve the <paramref name="value"/> at the point <paramref name="relativeTo"/>.
        /// </summary>
        public static bool TryGetNorthWest<T>(this T[][] array2D, Coord2D relativeTo, out T value) =>
            array2D.TryGet(relativeTo.GetNorthWestCoordinates(), out value);

        /// <summary>
        /// Returns the 4 cardinal neighbor values from the 2D array starting from the north and
        /// going clockwise. If any of the neighbors are non-existent, default(T) will be returned
        /// in their place.
        /// </summary>
        public static IEnumerable<T> TryGetCardinalNeighbors<T>(this T[][] array2D, Coord2D relativeTo)
        {
            array2D.TryGetNorth(relativeTo, out var result);
            yield return result;
            array2D.TryGetEast(relativeTo, out result);
            yield return result;
            array2D.TryGetSouth(relativeTo, out result);
            yield return result;
            array2D.TryGetWest(relativeTo, out result);
            yield return result;
        }

        /// <summary>
        /// Returns the cardinal neighbor values from the 2D array starting from the north and
        /// going clockwise. If any of the neighbors are non-existent, they will not be returned.
        /// </summary>
        public static IEnumerable<T> GetCardinalNeighbors<T>(this T[][] array2D, Coord2D point) =>
            array2D.TryGetCardinalNeighbors(point).Where(g => g != null).ToArray();

        /// <summary>
        /// Returns the width of the 2D array assuming that the outer array holds the columns
        /// (i.e. array2D[0] is column 0).
        /// </summary>
        public static int Width<T>(this T[][] array2D) => array2D.Length;

        /// <summary>
        /// Returns the height of the 2D array assuming that the outer array holds the columns
        /// (i.e. array2D[0] is column 0) and that all columns are of equal length.
        /// </summary>
        public static int Height<T>(this T[][] array2D) => array2D.Length > 0 ? array2D[0].Length : 0;

        /// <summary>
        /// Returns all the values in the 2D array, returning the entirety of a column (array2D[X])
        /// before moving to the next (array2D[X + 1]), always starting at 0 and moving up.
        /// </summary>
        public static IEnumerable<T> As1D<T>(this T[][] array2D) => array2D.SelectMany(column => column);

        /// <summary>
        /// Projects each element of a 2D array into a new form.
        /// </summary>
        public static TResult[][] Select2D<TSource, TResult>(this TSource[][] array2D, Func<TSource, TResult> selector) =>
            array2D.Select(a2D => a2D.Select(selector).ToArray()).ToArray();
    }
}