using Shogi.Domain.ValueObjects;
using System.Text;

namespace Shogi.Domain;

/// <summary>
/// Facilitates Shogi board state transitions, cognisant of Shogi rules.
/// The board is always from Player1's perspective.
/// [0,0] is the lower-left position, [8,8] is the higher-right position
/// </summary>
public sealed class ShogiBoard
{
  private readonly StandardRules rules;

  public ShogiBoard(string name, BoardState initialState, string player1, string? player2 = null)
  {
    Name = name;
    Player1 = player1;
    Player2 = player2;
    BoardState = initialState;
    rules = new StandardRules(BoardState);
  }

  public BoardState BoardState { get; }
  public string Name { get; }

  /// <summary>
  /// Move a piece from a board position to another board position, potentially capturing an opponents piece. Respects all rules of the game.
  /// </summary>
  /// <remarks>
  /// The strategy involves simulating a move on a throw-away board state that can be used to 
  /// validate legal vs illegal moves without having to worry about reverting board state.
  /// </remarks>
  /// <exception cref="InvalidOperationException"></exception>
  public void Move(string from, string to, bool isPromotion)
  {
    var simulationState = new BoardState(BoardState);
    var simulation = new StandardRules(simulationState);
    var moveResult = simulation.Move(from, to, isPromotion);
    if (!moveResult.Success)
    {
      throw new InvalidOperationException(moveResult.Reason);
    }

    // If already in check, assert the move that resulted in check no longer results in check.
    if (BoardState.InCheck == BoardState.WhoseTurn
      && simulation.IsOpposingKingThreatenedByPosition(BoardState.PreviousMoveTo))
    {
      throw new InvalidOperationException("Unable to move because you are still in check.");
    }

    var otherPlayer = BoardState.WhoseTurn == WhichPlayer.Player1 ? WhichPlayer.Player2 : WhichPlayer.Player1;
    if (simulation.IsPlayerInCheckAfterMove())
    {
      throw new InvalidOperationException("Illegal move. This move places you in check.");
    }

    _ = rules.Move(from, to, isPromotion);
    if (rules.IsOpponentInCheckAfterMove())
    {
      BoardState.InCheck = otherPlayer;
      if (rules.IsOpponentInCheckMate())
      {
        BoardState.IsCheckmate = true;
      }
    }
    else
    {
      BoardState.InCheck = null;
    }
    BoardState.WhoseTurn = otherPlayer;
  }

  public void Move(WhichPiece pieceInHand, string to)
  {
    var index = BoardState.ActivePlayerHand.FindIndex(p => p.WhichPiece == pieceInHand);
    if (index == -1)
    {
      throw new InvalidOperationException($"{pieceInHand} does not exist in the hand.");
    }

    if (BoardState[to] != null)
    {
      throw new InvalidOperationException("Illegal placement of piece from the hand. Destination is not empty.");
    }

    var toVector = Notation.FromBoardNotation(to);
    switch (pieceInHand)
    {
      case WhichPiece.Knight:
        {
          // Knight cannot be placed onto the farthest two ranks from the hand.
          if (BoardState.WhoseTurn == WhichPlayer.Player1 && toVector.Y > 6
            || BoardState.WhoseTurn == WhichPlayer.Player2 && toVector.Y < 2)
          {
            throw new InvalidOperationException("Illegal move. Knight has no valid moves after placement.");
          }
          break;
        }
      case WhichPiece.Lance:
      case WhichPiece.Pawn:
        {
          // Lance and Pawn cannot be placed onto the farthest rank from the hand.
          if (BoardState.WhoseTurn == WhichPlayer.Player1 && toVector.Y == 8
            || BoardState.WhoseTurn == WhichPlayer.Player2 && toVector.Y == 0)
          {
            throw new InvalidOperationException($"Illegal move. {pieceInHand} has no valid moves after placement.");
          }
          break;
        }
    }

    var tempBoard = new BoardState(BoardState);
    var simulation = new StandardRules(tempBoard);
    var moveResult = simulation.Move(pieceInHand, to);
    if (!moveResult.Success)
    {
      throw new InvalidOperationException(moveResult.Reason);
    }

    var otherPlayer = tempBoard.WhoseTurn == WhichPlayer.Player1 ? WhichPlayer.Player2 : WhichPlayer.Player1;
    if (BoardState.InCheck == BoardState.WhoseTurn)
    {
      //if (simulation.IsPlayerInCheckAfterMove(boardState.PreviousMoveTo, toVector, boardState.WhoseTurn))
      //{
      //	throw new InvalidOperationException("Illegal move. You're still in check!");
      //}
    }

    var kingPosition = otherPlayer == WhichPlayer.Player1 ? tempBoard.Player1KingPosition : tempBoard.Player2KingPosition;
    //if (simulation.IsPlayerInCheckAfterMove(toVector, kingPosition, otherPlayer))
    //{

    //}

    //rules.Move(from, to, isPromotion);
    //if (rules.IsPlayerInCheckAfterMove(fromVector, toVector, otherPlayer))
    //{
    //	board.InCheck = otherPlayer;
    //	board.IsCheckmate = rules.EvaluateCheckmate();
    //}
    //else
    //{
    //	board.InCheck = null;
    //}
    BoardState.WhoseTurn = otherPlayer;
  }

  /// <summary>
  /// Prints a ASCII representation of the board for debugging board state.
  /// </summary>
  /// <returns></returns>
  public string ToStringStateAsAscii()
  {
    var builder = new StringBuilder();
    builder.Append("                    ");
    builder.Append("Player 2(.)");
    builder.AppendLine();
    for (var rank = 8; rank >= 0; rank--)
    {
      // Horizontal line
      builder.Append("     - ");
      for (var file = 0; file < 8; file++) builder.Append("- - ");
      builder.Append("- -");

      // Print Rank ruler.
      builder.AppendLine();
      builder.Append($"{rank + 1}  ");

      // Print pieces.
      builder.Append("  |");
      for (var x = 0; x < 9; x++)
      {
        var piece = BoardState[x, rank];
        if (piece == null)
        {
          builder.Append("   ");
        }
        else
        {
          builder.AppendFormat("{0}", ToAscii(piece));
        }
        builder.Append('|');
      }
      builder.AppendLine();
    }

    // Horizontal line
    builder.Append("     - ");
    for (var x = 0; x < 8; x++) builder.Append("- - ");
    builder.Append("- -");
    builder.AppendLine();
    builder.Append("                    ");
    builder.Append("Player 1");

    builder.AppendLine();
    builder.AppendLine();
    // Print File ruler.
    builder.Append("     ");
    builder.Append("  A   B   C   D   E   F   G   H   I  ");

    return builder.ToString();
  }

  /// <summary>
  /// 
  /// </summary>
  /// <param name="piece"></param>
  /// <returns>
  /// A string with three characters. 
  /// The first character indicates promotion status. 
  /// The second character indicates piece. 
  /// The third character indicates ownership.
  /// </returns>
  private static string ToAscii(Piece piece)
  {
    var builder = new StringBuilder();
    if (piece.IsPromoted) builder.Append('^');
    else builder.Append(' ');

    var name = piece.WhichPiece switch
    {
      WhichPiece.King => "K",
      WhichPiece.GoldGeneral => "G",
      WhichPiece.SilverGeneral => "S",
      WhichPiece.Bishop => "B",
      WhichPiece.Rook => "R",
      WhichPiece.Knight => "k",
      WhichPiece.Lance => "L",
      WhichPiece.Pawn => "P",
      _ => throw new ArgumentException($"Unknown value for {nameof(WhichPiece)}."),
    };
    builder.Append(name);

    if (piece.Owner == WhichPlayer.Player2) builder.Append('.');
    else builder.Append(' ');

    return builder.ToString();
  }
}