using PathFinding;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Numerics;

namespace Gameboard.ShogiUI.BoardState
{
  public class Array2D<T> : IPlanarCollection<T>, IEnumerable<T>
  {
    /// <returns>False to stop iterating.</returns>
    public delegate void ForEachDelegate(T element, int x, int y);
    private readonly T[] array;
    private readonly int width;
    private readonly int height;

    public Array2D(int width, int height)
    {
      this.width = width;
      this.height = height;
      array = new T[width * height];
    }

    public T this[int x, int y]
    {
      get => array[y * width + x];
      set => array[y * width + x] = value;
    }
    public T this[float x, float y]
    {
      get => array[(int)y * width + (int)x];
      set => array[(int)y * width + (int)x] = value;
    }

    public int GetLength(int dimension) => dimension switch
    {
      0 => width,
      1 => height,
      _ => throw new IndexOutOfRangeException()
    };

    public void ForEach(ForEachDelegate callback)
    {
      for (var x = 0; x < width; x++)
      {
        for (var y = 0; y < height; y++)
        {
          callback(this[x, y], x, y);
        }
      }
    }

    public void ForEachNotNull(ForEachDelegate callback)
    {
      for (var x = 0; x < width; x++)
      {
        for (var y = 0; y < height; y++)
        {
          if (this[x, y] != null)
            callback(this[x, y], x, y);
        }
      }
    }

    public Vector2? IndexOf(Predicate<T> predicate)
    {
      for (var x = 0; x < width; x++)
        for (var y = 0; y < height; y++)
        {
          if (this[x, y] != null && predicate(this[x, y]))
          {
            return new Vector2(x, y);
          }
        }
      return null;
    }

    public IEnumerator<T> GetEnumerator()
    {
      foreach (var item in array) yield return item;
    }

    IEnumerator IEnumerable.GetEnumerator() => array.GetEnumerator();
  }
}