using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace N_Puzzle
{
    public class Board
    {
        public Tile[,] Tiles { get; private set; }
        private int Size { get; set; } // represent a perfect square


        public void StartGame()
        {
            Console.Write("Enter size of Board: ");
            Size = Convert.ToInt32(Console.ReadLine()); //Size -stores the size of user
            Tiles = new Tile[Size, Size];


            FillTiles();

            ShuffleTiles();

            if(IsSolvable() == true)
            {
                printBoard();
            }

            else
            {
                StartGame();
            }

            SwapTiles();


        }

        private void FillTiles()
        {

            Tile k = new Tile(0);
            int temp = 0;

            for (int i = 0; i < Size; i++) //row
            {
                for (int j = 0; j < Size; j++) //column
                {
                    Tiles[i, j] = k;
                    temp++;

                    k = new Tile(temp);







                }



            }
        }

        private void ShuffleTiles()
        {
            Random r = new Random();
            int n = Tiles.GetLength(1);


            for (int i = Tiles.Length - 1; i > 0; i--)
            {

                int i0 = i / n;
                int i1 = i % n;
                int j = r.Next(i + 1);
                int j0 = j / n;
                int j1 = j % n;
                Tile temp = Tiles[i0, i1];
                Tiles[i0, i1] = Tiles[j0, j1];
                Tiles[j0, j1] = temp;




            }


        }

        private int GetInvCount()
        {


            //List<int> flattedList = new List<int> { 1, 20, 6, 4, 5 };
            var flattedList = Tiles.OfType<Tile>().ToList();
            int inv_count = 0;

            for (int i = 0; i < flattedList.Count - 1; i++)
            {
                for (int j = i + 1; j < flattedList.Count; j++)
                {
                    if (flattedList[i].value > flattedList[j].value)
                    {
                        inv_count++;
                    }
                }
            }
            return inv_count + 1;


        }

        private int GetRowNumberBelow(int EmptyTilePosition)
        {
            var row = EmptyTilePosition / Size;
            return Size - row;
        }

        private bool IsSolvable()
        {
            int numberOfInversions = GetInvCount();

            if(Size % 2 != 0)
            {
                return (numberOfInversions % 2 == 0);
            }

            int pos = GetRowNumberBelow(IndexZeroPos());
            if(pos % 2 != 0)
            {
                return (numberOfInversions % 2 == 0);
            }

            else
            {
                return (numberOfInversions % 2 != 0);
            }

        }



        private void printBoard()
        {
            int len = (Size * Size).ToString().Length; //calculates the length of the string representation of that maximum value, saves it in "len"
            for (int i = 0; i < Size; i++)
            {
                for (int j = 0; j < Size; j++)
                {
                    if (Tiles[i, j].value == Size * Size)
                    {
                        Console.Write(" ".ToString().PadRight(len) + " | ");



                    }
                    else
                    {
                        Console.Write(Tiles[i, j].value.ToString().PadRight(len) + " | ");


                    }



                    //Console.Write($"{Tiles[i, j].value,4} ");

                }
                Console.WriteLine();

            }


        }



        private bool ArrSorted()
        {
            var flattedList = Tiles.OfType<Tile>().ToList();
            var result = flattedList.OrderByDescending(x => x.value != 0).ThenBy(x => x.value).SequenceEqual(flattedList);

            return result;
        }



        private int IndexZeroPos()
        {
            var flattedlist = Tiles.OfType<Tile>().ToList();

            int index = flattedlist.FindIndex(x => x.value == 0);

            return index;

        }

        private void SwapTiles()
        {
            int y = IndexZeroPos() % Size;
            int x = IndexZeroPos() / Size;
            var IsSorted = ArrSorted();

            while(IsSorted != true)
            {
                ConsoleKeyInfo info = Console.ReadKey();
                Console.WriteLine();

                if (info.Key == ConsoleKey.RightArrow)
                {
                    if (y >= (Size - 1))
                    {
                        continue;
                    }


                    Tile temp = Tiles[x, y];
                    Tiles[x, y] = Tiles[x, (y + 1)];
                    Tiles[x, (y + 1)] = temp;
                    if (IsSorted != ArrSorted())
                    {
                        break;
                    }
                    else
                    {
                        y = IndexZeroPos() % Size;
                        x = IndexZeroPos() / Size;
                        printBoard();
                    }
                }

                if (info.Key == ConsoleKey.LeftArrow)
                {
                    if (y <= 0)
                    {
                        continue;
                    }
                    Tile temp = Tiles[x, y];
                    Tiles[x, y] = Tiles[x, (y - 1)];
                    Tiles[x, (y - 1)] = temp;

                    if (IsSorted != ArrSorted())
                    {
                        break;
                    }
                    else
                    {
                        y = IndexZeroPos() % Size;
                        x = IndexZeroPos() / Size;
                        printBoard();
                    }
                }

                if (info.Key == ConsoleKey.UpArrow)
                {
                    if (x <= 0)
                    {
                        continue;
                    }

                    Tile temp = Tiles[x, y];
                    Tiles[x, y] = Tiles[(x - 1), y];
                    Tiles[(x - 1), y] = temp;

                    if (IsSorted != ArrSorted())
                    {
                        break;
                    }
                    else
                    {
                        y = IndexZeroPos() % Size;
                        x = IndexZeroPos() / Size;
                        printBoard();
                    }
                }

                if (info.Key == ConsoleKey.DownArrow)
                {
                    if (x >= (Size - 1))
                    {
                        continue;
                    }


                    Tile temp = Tiles[x, y];
                    Tiles[x, y] = Tiles[(x + 1), y];
                    Tiles[(x + 1), y] = temp;


                    if (IsSorted != ArrSorted())
                    {
                        break;
                    }
                    else
                    {
                        y = IndexZeroPos() % Size;
                        x = IndexZeroPos() / Size;
                        printBoard();
                    }
                }

            }
        }



        }







    }