namespace GameOfLife
{
    /* Реализуйте игру в жизнь на прямоугольном конечном поле.

     На каждом ходе клетка меняет свое состояние по таким правилам:
     1. Если у нее менее 2 живых соседей или более трех живых — она становится мертвой (false).
     2. Если ровно 3 живых соседа, то клетка становится живой (true)
     3. Если ровно 2 живых соседа, то клетка сохраняет своё состояние.

     У каждой неграничной клетки есть 8 соседей (в том числе по диагонали)

    Работу над игрой постройте итеративно в стиле TDD:
        1. Сначала напишите какой-нибудь простейший тест в соседнем файле GameTest.cs. Тест должен быть красным.
        То есть должен проверять ещё нереализованное требование.
        2. Только потом напшишите простейшую реализацию, которая делает тест зеленым.
        Не старайтесь реализовать всю логику, просто сделайте тест зеленым как можно быстрее.
        3. Повторяйте процесс, пока ещё можете придумать новые красные тесты.

     На каждый шаг (тест и реализация) у вас должно уходить не более 5 минут.
     Если вы не успели поднять тест за 5 минут — удалите этот тест и придумайте тест попроще.
     Засекайте время таймером на телефоне.

     После каждого шага (тест или реализация) меняйте активного человека за клавиатурой.

     Начните с простейших тестов.

     Проект настроен так, что при каждой сборке запускаются все тесты и отчет выводится на консоль
    */
    public class Game
    {
        public static bool[,] NextStep(bool[,] field)
        {
            var a = new char[field.GetLength(0), field.GetLength(1)];
            for (var i = 0; i < a.GetLength(0); i++)
                for (var j = 0; j < a.GetLength(1); j++)
                    a[i, j] = field[i, j];

                    for (var i = 0; i < a.GetLength(0); i++)
                for (var j = 0; j < a.GetLength(1); j++)
                {
                    var temp = new bool[3,3];
                    if (i == 0 || j == 0 || i == a.GetLength(0) - 1 || j == a.GetLength(1) - 1)
                    {
                        temp = GetUnic(i, j, a);
                    }
                    else
                    {
                        temp = new bool[,]{{a[i-1 , j-1], a[i, j-1], a[i + 1, j-1]},
                        {a[i - 1, j], a[i , j], a[i + 1, j]},
                        {a[i - 1 , j+1], a[i, j+1], a[i + 1, j+1]}
                        };
                    }
                    a[i,j] = Check(a);
                }
            return a;
        }

        private static bool[,] GetUnic(int i, int j, bool[,] a)
        {
            if (i == 0 && j == 0)
                return new bool[,]{{false, false, false},
                            {false, a[i , j], a[i + 1, j]},
                            {false, a[i, j+1], a[i + 1, j+1]}
                            };
            if (i == 0 && j == a.GetLength(1) - 1)
                return new bool[,]{{false, false, false},
                            {a[i - 1, j], a[i , j], false},
                            {a[i - 1 , j+1], a[i, j+1], false}
                        };
            if (i == a.GetLength(0) - 1 && j == 0)
                return new bool[,]{{false, a[i, j-1], a[i + 1, j-1]},
                            {false, a[i , j], a[i + 1, j]},
                            {false, false, false}
                            };
            if (i == a.GetLength(0) - 1 && j == a.GetLength(1) - 1)
                return new bool[,]{{a[i-1 , j-1], a[i, j-1], false},
                        {a[i - 1, j], a[i , j],false},
                        {false, false, false}
                        };
            if (i == a.GetLength(0) - 1)
                return new bool[,]{{a[i-1 , j-1], a[i, j-1], false},
                        {a[i - 1, j], a[i , j], false},
                        {a[i - 1 , j+1], a[i, j+1], false}
                        };
            if(i == 0)
                return new bool[,]{{false, a[i, j-1], a[i + 1, j-1]},
                        {false, a[i , j], a[i + 1, j]},
                        {false, a[i, j+1], a[i + 1, j+1]}
                        };
            if(j == 0)
                return new bool[,]{{false, false, false},
                        {a[i - 1, j], a[i , j], a[i + 1, j]},
                        {a[i - 1 , j+1], a[i, j+1], a[i + 1, j+1]}
                        };
            if(j == a.GetLength(1) - 1)
                return new bool[,]{{a[i-1 , j-1], a[i, j-1], a[i + 1, j-1]},
                        {a[i - 1, j], a[i , j], a[i + 1, j]},
                        {false, false, false}
                        };
            return null;
        }
        public static bool Check(bool[,] field)
        {
            var result = 0;
            for (var i = 0; i < 3; i++)
                for (var j = 0; j < 3; j++)
                    if (field[i, j] && (i != j || j != 1))
                        result += 1;
            if (result == 2)
                return field[1, 1];
            if (result == 3)
                return true;
            return false;
        }
    }
}