using FluentAssertions;
using FluentAssertions.Execution;
using System.Linq;
using Xunit;
using Xunit.Abstractions;

namespace Shogi.Domain.UnitTests
{
	public class ShogiShould
	{
		private readonly ITestOutputHelper output;
		public ShogiShould(ITestOutputHelper output)
		{
			this.output = output;
		}

		//[Fact]
		//public void InitializeBoardStateWithMoves()
		//{
		//	var moves = new[]
		//	{
  //        // P1 Pawn
  //      new Move("A3", "A4")
		//	};
		//	var shogi = new Shogi(moves);
		//	shogi.Board["A3"].Should().BeNull();
		//	shogi.Board["A4"].WhichPiece.Should().Be(WhichPiece.Pawn);
		//}

		//[Fact]
		//public void AllowValidMoves_AfterCheck()
		//{
		//	// Arrange
		//	var moves = new[]
		//	{
  //        // P1 Pawn
  //        new Move("C3", "C4"),
  //        // P2 Pawn
  //        new Move("G7", "G6"),
  //        // P1 Bishop puts P2 in check
  //        new Move("B2", "G7"),
		//	};
		//	var shogi = new Shogi(moves);
		//	shogi.InCheck.Should().Be(WhichPlayer.Player2);

		//	// Act - P2 is able to un-check theirself.
		//	/// P2 King moves out of check
		//	var moveSuccess = shogi.Move(new Move("E9", "E8"));

		//	// Assert
		//	using var _ = new AssertionScope();
		//	moveSuccess.Should().BeTrue();
		//	shogi.InCheck.Should().BeNull();
		//}

		//[Fact]
		//public void PreventInvalidMoves_MoveFromEmptyPosition()
		//{
		//	// Arrange
		//	var shogi = new Shogi();
		//	shogi.Board["D5"].Should().BeNull();

		//	// Act
		//	var moveSuccess = shogi.Move(new Move("D5", "D6"));

		//	// Assert
		//	moveSuccess.Should().BeFalse();
		//	shogi.Board["D5"].Should().BeNull();
		//	shogi.Board["D6"].Should().BeNull();
		//}

		//[Fact]
		//public void PreventInvalidMoves_MoveToCurrentPosition()
		//{
		//	// Arrange
		//	var shogi = new Shogi();

		//	// Act - P1 "moves" pawn to the position it already exists at.
		//	var moveSuccess = shogi.Move(new Move("A3", "A3"));

		//	// Assert
		//	moveSuccess.Should().BeFalse();
		//	shogi.Board["A3"].WhichPiece.Should().Be(WhichPiece.Pawn);
		//	shogi.Player1Hand.Should().BeEmpty();
		//	shogi.Player2Hand.Should().BeEmpty();
		//}

		//[Fact]
		//public void PreventInvalidMoves_MoveSet()
		//{
		//	// Arrange
		//	var shogi = new Shogi();

		//	// Act - Move Lance illegally
		//	var moveSuccess = shogi.Move(new Move("A1", "D5"));

		//	// Assert
		//	moveSuccess.Should().BeFalse();
		//	shogi.Board["A1"].WhichPiece.Should().Be(WhichPiece.Lance);
		//	shogi.Board["A5"].Should().BeNull();
		//	shogi.Player1Hand.Should().BeEmpty();
		//	shogi.Player2Hand.Should().BeEmpty();
		//}

		//[Fact]
		//public void PreventInvalidMoves_Ownership()
		//{
		//	// Arrange
		//	var shogi = new Shogi();
		//	shogi.WhoseTurn.Should().Be(WhichPlayer.Player1);
		//	shogi.Board["A7"].Owner.Should().Be(WhichPlayer.Player2);

		//	// Act - Move Player2 Pawn when it is Player1 turn.
		//	var moveSuccess = shogi.Move(new Move("A7", "A6"));

		//	// Assert
		//	moveSuccess.Should().BeFalse();
		//	shogi.Board["A7"].WhichPiece.Should().Be(WhichPiece.Pawn);
		//	shogi.Board["A6"].Should().BeNull();
		//}

		//[Fact]
		//public void PreventInvalidMoves_MoveThroughAllies()
		//{
		//	// Arrange
		//	var shogi = new Shogi();

		//	// Act - Move P1 Lance through P1 Pawn.
		//	var moveSuccess = shogi.Move(new Move("A1", "A5"));

		//	// Assert
		//	moveSuccess.Should().BeFalse();
		//	shogi.Board["A1"].WhichPiece.Should().Be(WhichPiece.Lance);
		//	shogi.Board["A3"].WhichPiece.Should().Be(WhichPiece.Pawn);
		//	shogi.Board["A5"].Should().BeNull();
		//}

		//[Fact]
		//public void PreventInvalidMoves_CaptureAlly()
		//{
		//	// Arrange
		//	var shogi = new Shogi();

		//	// Act - P1 Knight tries to capture P1 Pawn.
		//	var moveSuccess = shogi.Move(new Move("B1", "C3"));

		//	// Arrange
		//	moveSuccess.Should().BeFalse();
		//	shogi.Board["B1"].WhichPiece.Should().Be(WhichPiece.Knight);
		//	shogi.Board["C3"].WhichPiece.Should().Be(WhichPiece.Pawn);
		//	shogi.Player1Hand.Should().BeEmpty();
		//	shogi.Player2Hand.Should().BeEmpty();
		//}

		//[Fact]
		//public void PreventInvalidMoves_Check()
		//{
		//	// Arrange
		//	var moves = new[]
		//	{
  //        // P1 Pawn
  //        new Move("C3", "C4"),
  //        // P2 Pawn
  //        new Move("G7", "G6"),
  //        // P1 Bishop puts P2 in check
  //        new Move("B2", "G7")
		//	};
		//	var shogi = new Shogi(moves);
		//	shogi.InCheck.Should().Be(WhichPlayer.Player2);

		//	// Act - P2 moves Lance while in check.
		//	var moveSuccess = shogi.Move(new Move("I9", "I8"));

		//	// Assert
		//	moveSuccess.Should().BeFalse();
		//	shogi.InCheck.Should().Be(WhichPlayer.Player2);
		//	shogi.Board["I9"].WhichPiece.Should().Be(WhichPiece.Lance);
		//	shogi.Board["I8"].Should().BeNull();
		//}

		//[Fact]
		//public void PreventInvalidDrops_MoveSet()
		//{
		//	// Arrange
		//	var moves = new[]
		//	{
  //        // P1 Pawn
  //        new Move("C3", "C4"),
  //        // P2 Pawn
  //        new Move("I7", "I6"),
  //        // P1 Bishop takes P2 Pawn.
  //        new Move("B2", "G7"),
  //        // P2 Gold, block check from P1 Bishop.
  //        new Move("F9", "F8"),
  //        // P1 Bishop takes P2 Bishop, promotes so it can capture P2 Knight and P2 Lance
  //        new Move("G7", "H8", true),
  //        // P2 Pawn again
  //        new Move("I6", "I5"),
  //        // P1 Bishop takes P2 Knight
  //        new Move("H8", "H9"),
  //        // P2 Pawn again
  //        new Move("I5", "I4"),
  //        // P1 Bishop takes P2 Lance
  //        new Move("H9", "I9"),
  //        // P2 Pawn captures P1 Pawn
  //        new Move("I4", "I3")
		//		};
		//	var shogi = new Shogi(moves);
		//	shogi.Player1Hand.Count.Should().Be(4);
		//	shogi.Player1Hand.Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Knight);
		//	shogi.Player1Hand.Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Lance);
		//	shogi.Player1Hand.Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Pawn);
		//	shogi.Player1Hand.Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Bishop);
		//	shogi.WhoseTurn.Should().Be(WhichPlayer.Player1);

		//	// Act | Assert - Illegally placing Knight from the hand in farthest row.
		//	shogi.Board["H9"].Should().BeNull();
		//	var dropSuccess = shogi.Move(new Move(WhichPiece.Knight, "H9"));
		//	dropSuccess.Should().BeFalse();
		//	shogi.Board["H9"].Should().BeNull();
		//	shogi.Player1Hand.Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Knight);

		//	// Act | Assert - Illegally placing Knight from the hand in second farthest row.
		//	shogi.Board["H8"].Should().BeNull();
		//	dropSuccess = shogi.Move(new Move(WhichPiece.Knight, "H8"));
		//	dropSuccess.Should().BeFalse();
		//	shogi.Board["H8"].Should().BeNull();
		//	shogi.Player1Hand.Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Knight);

		//	// Act | Assert - Illegally place Lance from the hand.
		//	shogi.Board["H9"].Should().BeNull();
		//	dropSuccess = shogi.Move(new Move(WhichPiece.Knight, "H9"));
		//	dropSuccess.Should().BeFalse();
		//	shogi.Board["H9"].Should().BeNull();
		//	shogi.Player1Hand.Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Lance);

		//	// Act | Assert - Illegally place Pawn from the hand.
		//	shogi.Board["H9"].Should().BeNull();
		//	dropSuccess = shogi.Move(new Move(WhichPiece.Pawn, "H9"));
		//	dropSuccess.Should().BeFalse();
		//	shogi.Board["H9"].Should().BeNull();
		//	shogi.Player1Hand.Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Pawn);

		//	// Act | Assert - Illegally place Pawn from the hand in a row which already has an unpromoted Pawn.
		//	// TODO
		//}

		//[Fact]
		//public void PreventInvalidDrop_Check()
		//{
		//	// Arrange
		//	var moves = new[]
		//	{
  //        // P1 Pawn
  //        new Move("C3", "C4"),
  //        // P2 Pawn
  //        new Move("G7", "G6"),
  //        // P1 Pawn, arbitrary move.
  //        new Move("A3", "A4"),
  //        // P2 Bishop takes P1 Bishop
  //        new Move("H8", "B2"),
  //        // P1 Silver takes P2 Bishop
  //        new Move("C1", "B2"),
  //        // P2 Pawn, arbtrary move
  //        new Move("A7", "A6"),
  //        // P1 drop Bishop, place P2 in check
  //        new Move(WhichPiece.Bishop, "G7")
		//	};
		//	var shogi = new Shogi(moves);
		//	shogi.InCheck.Should().Be(WhichPlayer.Player2);
		//	shogi.Player2Hand.Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Bishop);
		//	shogi.Board["E5"].Should().BeNull();

		//	// Act - P2 places a Bishop while in check.
		//	var dropSuccess = shogi.Move(new Move(WhichPiece.Bishop, "E5"));

		//	// Assert
		//	dropSuccess.Should().BeFalse();
		//	shogi.Board["E5"].Should().BeNull();
		//	shogi.InCheck.Should().Be(WhichPlayer.Player2);
		//	shogi.Player2Hand.Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Bishop);
		//}

		//[Fact]
		//public void PreventInvalidDrop_Capture()
		//{
		//	// Arrange
		//	var moves = new[]
		//	{
  //      // P1 Pawn
  //      new Move("C3", "C4"),
  //      // P2 Pawn
  //      new Move("G7", "G6"),
  //      // P1 Bishop capture P2 Bishop
  //      new Move("B2", "H8"),
  //      // P2 Pawn
  //      new Move("G6", "G5")
		//	};
		//	var shogi = new Shogi(moves);
		//	using (new AssertionScope())
		//	{
		//		shogi.Player1Hand.Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Bishop);
		//		shogi.Board["I9"].Should().NotBeNull();
		//		shogi.Board["I9"].WhichPiece.Should().Be(WhichPiece.Lance);
		//		shogi.Board["I9"].Owner.Should().Be(WhichPlayer.Player2);
		//	}

		//	// Act - P1 tries to place a piece where an opponent's piece resides.
		//	var dropSuccess = shogi.Move(new Move(WhichPiece.Bishop, "I9"));

		//	// Assert
		//	using (new AssertionScope())
		//	{
		//		dropSuccess.Should().BeFalse();
		//		shogi.Player1Hand.Should().ContainSingle(_ => _.WhichPiece == WhichPiece.Bishop);
		//		shogi.Board["I9"].Should().NotBeNull();
		//		shogi.Board["I9"].WhichPiece.Should().Be(WhichPiece.Lance);
		//		shogi.Board["I9"].Owner.Should().Be(WhichPlayer.Player2);
		//	}
		//}

		//[Fact]
		//public void Check()
		//{
		//	// Arrange
		//	var moves = new[]
		//	{
  //      // P1 Pawn
  //      new Move("C3", "C4"),
  //      // P2 Pawn
  //      new Move("G7", "G6"),
		//	};
		//	var shogi = new Shogi(moves);

		//	// Act - P1 Bishop, check
		//	shogi.Move(new Move("B2", "G7"));

		//	// Assert
		//	shogi.InCheck.Should().Be(WhichPlayer.Player2);
		//}

		//[Fact]
		//public void Promote()
		//{
		//	// Arrange
		//	var moves = new[]
		//	{
  //      // P1 Pawn
  //      new Move("C3", "C4" ),
  //      // P2 Pawn
  //      new Move("G7", "G6" )
		//	};
		//	var shogi = new Shogi(moves);

		//	// Act - P1 moves across promote threshold.
		//	var moveSuccess = shogi.Move(new Move("B2", "G7", true));

		//	// Assert
		//	using (new AssertionScope())
		//	{
		//		moveSuccess.Should().BeTrue();
		//		shogi.Board["B2"].Should().BeNull();
		//		shogi.Board["G7"].Should().NotBeNull();
		//		shogi.Board["G7"].WhichPiece.Should().Be(WhichPiece.Bishop);
		//		shogi.Board["G7"].Owner.Should().Be(WhichPlayer.Player1);
		//		shogi.Board["G7"].IsPromoted.Should().BeTrue();
		//	}
		//}

		//[Fact]
		//public void CheckMate()
		//{
		//	// Arrange
		//	var moves = new[]
		//	{
  //        // P1 Rook
  //        new Move("H2", "E2"),
  //        // P2 Gold
  //        new Move("F9", "G8"),
  //        // P1 Pawn
  //        new Move("E3", "E4"),
  //        // P2 other Gold
  //        new Move("D9", "C8"),
  //        // P1 same Pawn
  //        new Move("E4", "E5"),
  //        // P2 Pawn
  //        new Move("E7", "E6"),
  //        // P1 Pawn takes P2 Pawn
  //        new Move("E5", "E6"),
  //        // P2 King
  //        new Move("E9", "E8"),
  //        // P1 Pawn promotes, threatens P2 King
  //        new Move("E6", "E7", true),
  //        // P2 King retreat
  //        new Move("E8", "E9"),
		//		};
		//	var shogi = new Shogi(moves);
		//	output.WriteLine(shogi.PrintStateAsAscii());

		//	// Act - P1 Pawn wins by checkmate.
		//	var moveSuccess = shogi.Move(new Move("E7", "E8"));
		//	output.WriteLine(shogi.PrintStateAsAscii());

		//	// Assert - checkmate
		//	moveSuccess.Should().BeTrue();
		//	shogi.IsCheckmate.Should().BeTrue();
		//	shogi.InCheck.Should().Be(WhichPlayer.Player2);
		//}

		//[Fact]
		//public void Capture()
		//{
		//	// Arrange
		//	var moves = new[]
		//	{
		//			new Move("C3", "C4"),
		//			new Move("G7", "G6")
		//		};
		//	var shogi = new Shogi(moves);

		//	// Act - P1 Bishop captures P2 Bishop
		//	var moveSuccess = shogi.Move(new Move("B2", "H8"));

		//	// Assert
		//	moveSuccess.Should().BeTrue();
		//	shogi.Board["B2"].Should().BeNull();
		//	shogi.Board["H8"].WhichPiece.Should().Be(WhichPiece.Bishop);
		//	shogi.Board["H8"].Owner.Should().Be(WhichPlayer.Player1);
		//	shogi.Board.Values
		//		.Where(p => p != null)
		//		.Should().ContainSingle(piece => piece.WhichPiece == WhichPiece.Bishop);

		//	shogi.Player1Hand
		//		.Should()
		//		.ContainSingle(p => p.WhichPiece == WhichPiece.Bishop && p.Owner == WhichPlayer.Player1);
		//}
	}
}