// TODO: Castling checking
        public void VlidateMove(IFigure figure, IBoard board, Move move)
        {
            Position from = move.From;
            Position to = move.To;

            bool condition = (
                ((from.Col + 1) == to.Col) ||
                ((from.Col - 1) == to.Col) ||
                ((from.Row + 1) == to.Row) ||
                ((from.Row - 1) == to.Row) ||
                (((from.Row + 1) == to.Row) && ((from.Col + 1) == to.Col)) ||
                (((from.Row - 1) == to.Row) && ((from.Col + 1) == to.Col)) ||
                (((from.Row - 1) == to.Row) && ((from.Col - 1) == to.Col)) ||
                (((from.Row + 1) == to.Row) && ((from.Col - 1) == to.Col))
                );

            if (condition)
            {
                return;
            }
            else
            {
                throw new InvalidOperationException("King cannot move this way!");
            }
        }

 public KingSurvivalEngine(IRenderer renderer, IInputProvider inputProvider,IBoard board, IWinningConditions winningConditions)
 {
     this.renderer = renderer;
     this.provider = inputProvider;
     this.winningConditions = winningConditions;
     this.board = board;
 }

 public Move GetNextFigureMove(IPlayer player,IBoard board)
 {
     Console.Write("{0} is next ", player.Name);
     var command = Console.ReadLine();
     Move move = player.Move(command,board);
     return move;
 }

        protected void AddBoardToOutput(IBoard board, TagHelperOutput output, bool editable = false) {
            if (board == null) { throw new ArgumentNullException(nameof(board)); }
            if (output == null) { throw new ArgumentNullException(nameof(output)); }

            int counter = 0;
            output.Content.AppendEncoded($"{NewLine}{Indent}<table>{NewLine}");
            for (int row = 0; row < board.Size; row++) {

                output.Content.AppendEncoded($"{Indent}{Indent}<tr>{NewLine}");
                output.Content.AppendEncoded($"{Indent}{Indent}{Indent}");
                for (int col = 0; col < board.Size; col++) {
                    output.Content.AppendEncoded($"<td>");
                    if (!editable) {
                        output.Content.AppendEncoded($"{board[row, col]}");
                    }
                    else {
                        output.Content.AppendEncoded($"<input type=\"text\" value=\"{board[row,col]}\" name=\"board[{counter}]\" style=\"width:100%;\" maxlength=\"1\" />");
                    }
                    output.Content.AppendEncoded($"</td>");

                    counter++;
                }
                output.Content.AppendEncoded($"{NewLine}{Indent}{Indent}</tr>{NewLine}");
            }
            output.Content.AppendEncoded($"{Indent}</table>{NewLine}");
        }

        public override Move Move(string command,IBoard board)
        {
            int[] deltaRed = { -1, +1, +1, -1 }; //UR, DR, DL, UL

            int[] deltaColona = { +1, +1, -1, -1 };
            int indexOfChange = -1;

            if (command.Length != 3)
            {
                //TODO:Change the exception to custom exception
                throw new ArgumentOutOfRangeException("The command should contain three symbols");
            }

            switch (command)
            {
                case "adr":
                case "bdr":
                case "cdr":
                case "ddr":
                    { indexOfChange = 1; }
                    break;
                case "adl":
                case "bdl":
                case "cdl":
                case "ddl":
                    { indexOfChange = 2; }
                    break;
                default:
                    //TODO:change the exception to custom exception
                    throw new ArgumentOutOfRangeException("The command is not correct");
            }
            int pawnIndex = -1;
            switch (command[0])
            {
                case 'a':
                case 'A':
                    { pawnIndex = 0; }
                    break;
                case 'b':
                case 'B':
                    { pawnIndex = 1; }
                    break;
                case 'c':
                case 'C':
                    { pawnIndex = 2; }
                    break;
                case 'd':
                case 'D':
                    { pawnIndex = 3; }
                    break;
            }
            var fig = this.Figures;
            var oldPosition = board.GetFigurePosition(this.Figures[pawnIndex]);
            int pawnNewRow = oldPosition.Row + deltaRed[indexOfChange];
            int pawnNewColum = oldPosition.Col + deltaColona[indexOfChange];
            var newPosition = new Position(pawnNewRow, pawnNewColum);
            //Position.CheckIfValid(newPosition, GlobalErrorMessages.PositionNotValidMessage);
               // this.Figures[pawnIndex].Position = newPosition;
            return new Move(oldPosition, newPosition);
        }

        private void PrintBoardBorder(int startRow, int startCol, IBoard board)
        {
            Console.BackgroundColor = ConsoleColor.DarkBlue;

            int horizontalBoardSymbolTopRow = (Console.BufferWidth / 2) - ((board.Size / 2) * BoardCellSymbolsCount) - 2;
            int totalBoardCols = board.Size * Renderer.BoardCellSymbolsCount;
            var totalCols = totalBoardCols + (2 * Renderer.BorderSize);
            int startBoardCol = ((Console.BufferHeight / 2) - totalCols / 2) + (BoardCellSymbolsCount / 2) + Renderer.BorderSize;
            this.PrintBoardSide(startRow, startRow + Renderer.BorderSize, startCol, startCol + totalCols);
            this.PrintHorizontalSymbols(startBoardCol, totalBoardCols, horizontalBoardSymbolTopRow, board, Renderer.HorizontalBoardFirstSymbol);

            int horizontalBoardSymbolBottomRow = (Console.BufferWidth / 2) + ((board.Size / 2) * BoardCellSymbolsCount) + 1;
            var bottomStartRow = (Console.BufferHeight / 2) + (board.Size / 2 * Renderer.BoardCellSymbolsCount);
            this.PrintBoardSide(bottomStartRow, bottomStartRow + Renderer.BorderSize, startCol, startCol + totalCols);
            this.PrintHorizontalSymbols(startBoardCol, totalBoardCols, horizontalBoardSymbolBottomRow, board, Renderer.HorizontalBoardFirstSymbol);

            int totalBoardRows = board.Size * BoardCellSymbolsCount;
            int varticalBoardSymbolLeftCol = (Console.BufferHeight / 2) - ((board.Size / 2) * BoardCellSymbolsCount) - 2;
            var totalRows = (board.Size * Renderer.BoardCellSymbolsCount) + Renderer.BorderSize;
            int startBoardRow = ((Console.BufferHeight / 2) - totalCols / 2) + (BoardCellSymbolsCount / 2) + Renderer.BorderSize;
            this.PrintBoardSide(startRow, startRow + totalRows, startCol, startCol + Renderer.BorderSize);
            this.PrintVerticalSymbols(startBoardRow, totalBoardRows, varticalBoardSymbolLeftCol, board, Renderer.VerticalBoardFirstSymbol);

            var rigthBorderStartCol = Console.BufferWidth / 2 + (board.Size * Renderer.BoardCellSymbolsCount / 2);
            int varticalBoardSymbolRigthCol = (Console.BufferHeight / 2) + ((board.Size / 2) * BoardCellSymbolsCount) + 1;
            this.PrintBoardSide(startRow, startRow + totalRows, rigthBorderStartCol, rigthBorderStartCol + Renderer.BorderSize);
            this.PrintVerticalSymbols(startBoardRow, totalBoardRows, varticalBoardSymbolRigthCol, board, Renderer.VerticalBoardFirstSymbol);
        }

        public void DrawBoard(IBoard board)
        {
            StringBuilder result = new StringBuilder();

            // Append the numbers row first
            for (int i = 0; i < board.NumbersRow.Length; i++)
            {
                result.AppendFormat("{0, -2}", board.NumbersRow[i]);
            }

            result.AppendLine();

            // Append the rest of the rows
            for (int row = 0; row < board.Gamefield.GetLength(0); row++)
            {
                for (int col = 0; col < board.Gamefield.GetLength(1); col++)
                {
                    result.AppendFormat("{0, -2}", board.Gamefield[row, col]);
                }

                result.AppendLine();
            }

            Console.WriteLine(result.ToString());
        }

        public override Move Move(string command,IBoard board)
        {
            int[] deltaRed = { -1, +1, +1, -1 }; //UR, DR, DL, UL

            int[] deltaColona = { +1, +1, -1, -1 };
            int indexOfChange = -1;

            if (command.Length != 3)
            {
                //TODO:change the exception to custom exception
                throw new ArgumentOutOfRangeException("The command should contain three symbols");
            }

            var oldPosition = board.GetFigurePosition(this.Figures[0]);

            switch (command)
            {
                case "kur": { indexOfChange = 0; } break;
                case "kdr": { indexOfChange = 1; } break;
                case "kdl": { indexOfChange = 2; } break;
                case "kul": { indexOfChange = 3; } break;
                default:
                    //TODO:change the exception to custom exception
                    throw new ArgumentOutOfRangeException("The command is not correct");

            }
            int newRow = oldPosition.Row + deltaRed[indexOfChange];
            int newColumn = oldPosition.Col + deltaColona[indexOfChange];
            var newPosition = new Position(newRow, newColumn);
            //Position.CheckIfValid(newPosition, GlobalErrorMessages.PositionNotValidMessage);
              //  this.Figures[0].Position = newPosition;
            return new Move(oldPosition, newPosition);
        }

 public void Move(char player, IBoard board)
 {
     var freeSpaces = board.GetFreeSpaces();
     Random rnd = new Random();
     int r = rnd.Next(freeSpaces.Length);
     board.SetSpace(player, (int)Char.GetNumericValue(freeSpaces[r]));
 }

        private bool CheckIfCheck(IBoard gameBoard, Position kingPosition, IDictionary<Position, IFigure> defenderFigures)
        {
            var defenderFiguresPositions = defenderFigures.Keys;
            var counter = 0;

            foreach (var position in defenderFiguresPositions)
            {
                var figure = defenderFigures[position];
                var availableMovements = figure.Move(this.strategy);

                try
                {
                    var tryMove = new Move(position, kingPosition);
                    this.CheckValidMove(figure, availableMovements, tryMove);
                }
                catch (Exception ex)
                {
                    counter++;
                }
            }
            if (counter == defenderFigures.Count)
            {
                return false;
            }

            return true;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ShapeI"/> class.
        /// </summary>
        /// <param name="board">The board being used.</param>
        public ShapeI(IBoard board)
            : base(board)
        {
            // Initialize blocks
            blocks = new Block[] {
                new Block (board, Color.Cyan),
                new Block (board, Color.Cyan),
                new Block (board, Color.Cyan),
                new Block (board, Color.Cyan)
            };

            // Set block positions
            setBlockPositions();

            // Set rotations
            rotationOffset = new Point[][]
            {
                new Point[] { new Point(-2, -2), new Point(2, 2) },
                new Point[] { new Point(-1, -1), new Point(1, 1) },
                new Point[] { new Point(0, 0), new Point(0, 0) },
                new Point[] { new Point(1, 1), new Point(-1, -1) }
            };

            // 0 = no rotation
            // 1 = 90 degree rotation counterclockwise
            currentRotation = 0;

            length = blocks.Length;
        }

        public void VlidateMove(IFigure figure, IBoard board, Move move)
        {
            Position from = move.From;
            Position to = move.To;

            if (from.Row != to.Row && from.Col != to.Col)
            {
                throw new InvalidOperationException("Rook cannot move this way!");
            }

            if (to.Col > from.Col)
            {
                this.RightChecker(board, from, to);
                return;
            }
            else if (to.Col < from.Col)
            {
                this.LeftChecker(board, from, to);
                return;
            }
            else if (to.Row > from.Row)
            {
                this.TopChecker(board, from, to);
                return;
            }
            else if (to.Row < from.Row)
            {
                this.DownChecker(board, from, to);
                return;
            }
            else
            {
                throw new InvalidOperationException("Rook cannot move this way!");
            }
        }

        /// <summary>
        /// Clears all empty cells and moves all balloons on the column to rows greater than their current one if there are vacant indexes.
        /// </summary>
        /// <param name="board">The board object of the game.</param>
        private void ClearEmptyCells(IBoard board)
        {
            int row;
            int col;

            Queue<IBalloon> baloonsToPop = new Queue<IBalloon>();
            for (col = board.Cols - 1; col >= 0; col--)
            {
                for (row = board.Rows - 1; row >= 0; row--)
                {
                    if (board[row, col] != Balloon.Default)
                    {
                        baloonsToPop.Enqueue(board[row, col]);
                        board[row, col] = Balloon.Default;
                    }
                }

                row = board.Rows - 1;
                while (baloonsToPop.Count > 0)
                {
                    board[row, col] = baloonsToPop.Dequeue();
                    row--;
                }

                baloonsToPop.Clear();
            }
        }

        public void ValidateMove(IFigure figure, IBoard board, Move move)
        {
            var rowDistance = Math.Abs(move.From.Row - move.To.Row);
            var colDistance = Math.Abs(move.From.Col - move.To.Col);

            if (rowDistance != colDistance)
            {
                throw new InvalidOperationException(string.Format(GlobalConstants.ExceptionMessege, figure.Type));
            }

            int rowDirection = move.From.Row > move.To.Row ? -1 : 1;
            int colDirection = move.From.Col > move.To.Col ? -1 : 1;

            var row = move.From.Row;
            var col = move.From.Col;

            var endRow = move.To.Row + (rowDirection * (-1));
            var endCol = move.To.Col + (colDirection * (-1));

            while (row != endRow && col != endCol)
            {
                row += rowDirection;
                col += colDirection;

                if (board.SeeFigureOnPosition(row, col) != null)
                {
                    throw new InvalidOperationException(string.Format(GlobalConstants.ExceptionMessege, figure.Type));
                }
            }

            base.ValidateMove(figure, board, move);
        }

        public void AddFigureToBoard(IPlayer firstPlayser, IPlayer secondPlayer, IBoard board, string fen)
        {
            var splitedFen = fen.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
            var index = 0;

            for (int row = splitedFen.Length - 1; row >= 0; row--)
            {
                var currentRow = this.MakeRow(splitedFen[row]);

                for (int col = 0; col < currentRow.Length; col++)
                {
                    if (currentRow[col] == Pown)
                    {
                        var pawn = new Pawn(secondPlayer.Color);
                        secondPlayer.AddFigure(pawn);
                        var position = new Position(index + 1, (char)(col + 'a'));
                        board.AddFigure(pawn, position);
                    }
                    else if (currentRow[col] == King)
                    {
                        var figureInstance = new King(firstPlayser.Color);
                        firstPlayser.AddFigure(figureInstance);
                        var position = new Position(index + 1, (char)(col + 'a'));
                        board.AddFigure(figureInstance, position);
                    }
                }

                index++;
            }
        }

        public void RenderBoard(IBoard board)
        {
            int counter = 0;
            int startRow = (Console.BufferHeight / 2) - ((board.Size / 2) * BoardCellSymbolsCount);
            int startCol = (Console.BufferWidth / 2) - ((board.Size / 2) * BoardCellSymbolsCount);

            this.PrintBoardBorder(startRow - Renderer.BorderSize, startCol - Renderer.BorderSize, board);

            for (int row = 0; row < board.Size; row++)
            {
                for (int col = 0; col < board.Size; col++)
                {
                    int printRow = startRow + (row * BoardCellSymbolsCount);
                    int printCol = startCol + (col * BoardCellSymbolsCount);
                    ConsoleColor color = counter % 2 == 0 ? Renderer.DarkBoardCells : Renderer.LigthBoardCells;
                    var figure = board.SeeFigureOnPosition(row, col);
                    this.PrintCell(printRow, printCol, color, figure);
                    counter++;
                }

                counter++;
            }

            Console.BackgroundColor = ConsoleColor.Black;
            Console.WriteLine();
        }

        protected internal override IEnumerable<IMove> GetStrategyAvailableMoves(IBoard board, ITurn turn, IGameRuleStrategyContext context)
        {
            if (this.NeedToMovePiece(board, turn.Player))
                yield break;

            var playerName = turn.Player;
            var dice = this.GetAvailableDice(turn.Dice).OrderByDescending(x => x.Value).ToList();
            var firstPiece = false;
            for (var i = (board.Lanes.Count * 3) / 4; i < board.Lanes.Count; i++)
            {
                var lane = board.Lanes[i];
                if (lane.Count == 0 || lane[0].Player != playerName)
                    continue;

                foreach (var die in dice)
                {
                    if (i + die.Value == board.Lanes.Count ||
                        (i + die.Value > board.Lanes.Count && !firstPiece))
                    {
                        yield return new DefaultMove(board.Lanes[i], i, die);
                        firstPiece = true;
                    }
                }

                firstPiece = true;
            }
        }

        public void RenderBoard(IBoard board)
        {
            this.PrintHorizontalNumbers();
            for (int row = 0; row < board.NumberOfRows; row++)
            {
                Console.Write(row + "| ");
                for (int column = 0; column < board.NumberOfColumns; column++)
                {
                    Position position = new Position(row, column);
                    var figure = board.GetFigureAtPosition(position);

                    if (figure != null)
                    {
                        Console.Write(figure.DisplayName + " ");
                    }
                    else
                    {
                        this.PrintCell(position);
                    }
                }

                Console.Write("|");
                Console.WriteLine();
            }

            this.PrintHorizontalLines();
        }

 public PostsViewModel(IShell shell, IBoard board, string boardId, IList<PostViewModel> threadPosts, IEnumerable<PostViewModel> posts) {
     Posts = new ObservableCollection<PostViewModel>(posts.Select(CreatePostViewModel));
     BoardId = boardId;
     Board = board;
     ThreadPosts = threadPosts;
     Shell = shell;
 }

 // コンストラクタ
 public ThreadProxy(int threadNumber, string title, int latestMessageNumber, IBoard board)
 {
     m_Id = threadNumber;
     m_Title = title;
     m_LatestMessageNumber = latestMessageNumber;
     m_Board = board;
 }