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(int size) //changed - added parameter
        {
            int countSteps = 0;

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


            FillTiles();

            ShuffleTiles();

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

            else
            {
                StartGame(size); //changed added argument
                return;
            }

            countSteps = SwapTiles();

            Console.WriteLine($"It took {countSteps} moves to solve the puzzle");


        }

        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 > 0 && flattedList[j].value > 0 && flattedList[i].value > flattedList[j].value))
                    {
                        inv_count++;
                    }
                }
            }
            return inv_count;


        }

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

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

            int pos = GetRowNumberBelow(IndexZeroPos());

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




            else 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 == 0)

                    {

                        Console.Write($"{"",3} ");


                    }
                    else
                    {
                        Console.BackgroundColor = Tiles[i, j].color;

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

                        Console.ResetColor();

                    }





                }
                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 int SwapTiles()
        {
            int count = 0;
            int y = IndexZeroPos() % Size;
            int x = IndexZeroPos() / Size;
            var IsSorted = ArrSorted();



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


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



                    Tiles[x, y] = Tiles[x, y + 1];
                    Tiles[x, (y + 1)] = new Tile(0);
                    count++;

                    y += 1;
                    IsSorted = ArrSorted();

                    Console.Clear();

                    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;
                    count++;

                    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;
                    count++;

                    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] = new Tile(0);
                    count++;


                    x += 1;

                    IsSorted = ArrSorted();
                    printBoard();

                }

            }


            return count++;






        }




    }






}