using Shogi.BackEnd.Domains.ValueObjects;
using Shogi.BackEnd.Domains.ValueObjects.Movement;
using Shogi.BackEnd.Domains.ValueObjects.Pieces;
using System.Linq;
using System.Numerics;

namespace UnitTests;

public class RookShould
{
	public class MoveSet
	{
		private readonly Rook rook1;
		private readonly Rook rook2;

		public MoveSet()
		{
			rook1 = new Rook(WhichPlayer.Player1);
			rook2 = new Rook(WhichPlayer.Player2);
		}

		[Fact]
		public void Player1_HasCorrectMoveSet()
		{
			var moveSet = rook1.MoveSet;
			Assert.Equal(4, moveSet.Count);
			Assert.Contains(new Path(Direction.Forward, Distance.MultiStep), moveSet);
			Assert.Contains(new Path(Direction.Left, Distance.MultiStep), moveSet);
			Assert.Contains(new Path(Direction.Right, Distance.MultiStep), moveSet);
			Assert.Contains(new Path(Direction.Backward, Distance.MultiStep), moveSet);
		}

		[Fact]
		public void Player1_Promoted_HasCorrectMoveSet()
		{
			// Arrange
			rook1.Promote();
			Assert.True(rook1.IsPromoted);

			// Assert
			var moveSet = rook1.MoveSet;
			Assert.Equal(8, moveSet.Count);
			Assert.Contains(new Path(Direction.Forward, Distance.MultiStep), moveSet);
			Assert.Contains(new Path(Direction.Left, Distance.MultiStep), moveSet);
			Assert.Contains(new Path(Direction.Right, Distance.MultiStep), moveSet);
			Assert.Contains(new Path(Direction.Backward, Distance.MultiStep), moveSet);
			Assert.Contains(new Path(Direction.ForwardLeft, Distance.OneStep), moveSet);
			Assert.Contains(new Path(Direction.BackwardLeft, Distance.OneStep), moveSet);
			Assert.Contains(new Path(Direction.ForwardRight, Distance.OneStep), moveSet);
			Assert.Contains(new Path(Direction.BackwardRight, Distance.OneStep), moveSet);
		}

		[Fact]
		public void Player2_HasCorrectMoveSet()
		{
			var moveSet = rook2.MoveSet;
			Assert.Equal(4, moveSet.Count);
			Assert.Contains(new Path(Direction.Forward, Distance.MultiStep), moveSet);
			Assert.Contains(new Path(Direction.Left, Distance.MultiStep), moveSet);
			Assert.Contains(new Path(Direction.Right, Distance.MultiStep), moveSet);
			Assert.Contains(new Path(Direction.Backward, Distance.MultiStep), moveSet);
		}

		[Fact]
		public void Player2_Promoted_HasCorrectMoveSet()
		{
			// Arrange
			rook2.Promote();
			Assert.True(rook2.IsPromoted);

			// Assert
			var moveSet = rook2.MoveSet;
			Assert.Equal(8, moveSet.Count);
			Assert.Contains(new Path(Direction.Forward, Distance.MultiStep), moveSet);
			Assert.Contains(new Path(Direction.Left, Distance.MultiStep), moveSet);
			Assert.Contains(new Path(Direction.Right, Distance.MultiStep), moveSet);
			Assert.Contains(new Path(Direction.Backward, Distance.MultiStep), moveSet);
			Assert.Contains(new Path(Direction.ForwardLeft, Distance.OneStep), moveSet);
			Assert.Contains(new Path(Direction.BackwardLeft, Distance.OneStep), moveSet);
			Assert.Contains(new Path(Direction.ForwardRight, Distance.OneStep), moveSet);
			Assert.Contains(new Path(Direction.BackwardRight, Distance.OneStep), moveSet);
		}
	}

	private readonly Rook rookPlayer1;

	public RookShould()
	{
		rookPlayer1 = new Rook(WhichPlayer.Player1);
	}

	[Fact]
	public void Promote()
	{
		Assert.False(rookPlayer1.IsPromoted);
		Assert.True(rookPlayer1.CanPromote);
		rookPlayer1.Promote();
		Assert.True(rookPlayer1.IsPromoted);
		Assert.False(rookPlayer1.CanPromote);
	}

	[Fact]
	public void GetStepsFromStartToEnd_Player1NotPromoted_LateralMove()
	{
		Vector2 start = new(0, 0);
		Vector2 end = new(0, 5);

		var steps = rookPlayer1.GetPathFromStartToEnd(start, end).ToList();

		Assert.False(rookPlayer1.IsPromoted);
		Assert.Equal(5, steps.Count);
		Assert.Contains(new Vector2(0, 1), steps);
		Assert.Contains(new Vector2(0, 2), steps);
		Assert.Contains(new Vector2(0, 3), steps);
		Assert.Contains(new Vector2(0, 4), steps);
		Assert.Contains(new Vector2(0, 5), steps);
	}

	[Fact]
	public void GetStepsFromStartToEnd_Player1NotPromoted_DiagonalMove()
	{
		Vector2 start = new(0, 0);
		Vector2 end = new(1, 1);

		var steps = rookPlayer1.GetPathFromStartToEnd(start, end).ToList();

		Assert.False(rookPlayer1.IsPromoted);
		Assert.Empty(steps);
	}

	[Fact]
	public void GetStepsFromStartToEnd_Player1Promoted_LateralMove()
	{
		Vector2 start = new(0, 0);
		Vector2 end = new(0, 5);
		rookPlayer1.Promote();

		var steps = rookPlayer1.GetPathFromStartToEnd(start, end).ToList();

		Assert.True(rookPlayer1.IsPromoted);
		Assert.Equal(5, steps.Count);
		Assert.Contains(new Vector2(0, 1), steps);
		Assert.Contains(new Vector2(0, 2), steps);
		Assert.Contains(new Vector2(0, 3), steps);
		Assert.Contains(new Vector2(0, 4), steps);
		Assert.Contains(new Vector2(0, 5), steps);
	}

	[Fact]
	public void GetStepsFromStartToEnd_Player1Promoted_DiagonalMove()
	{
		Vector2 start = new(0, 0);
		Vector2 end = new(1, 1);
		rookPlayer1.Promote();

		var steps = rookPlayer1.GetPathFromStartToEnd(start, end).ToList();

		Assert.True(rookPlayer1.IsPromoted);
		Assert.Single(steps);
		Assert.Contains(new Vector2(1, 1), steps);
	}

	[Fact]
	public void GetStepsFromStartToEnd_Player2NotPromoted_LateralMove()
	{
		Vector2 start = new(0, 0);
		Vector2 end = new(0, 5);

		var steps = rookPlayer1.GetPathFromStartToEnd(start, end).ToList();

		Assert.False(rookPlayer1.IsPromoted);
		Assert.Equal(5, steps.Count);
		Assert.Contains(new Vector2(0, 1), steps);
		Assert.Contains(new Vector2(0, 2), steps);
		Assert.Contains(new Vector2(0, 3), steps);
		Assert.Contains(new Vector2(0, 4), steps);
		Assert.Contains(new Vector2(0, 5), steps);
	}

	[Fact]
	public void GetStepsFromStartToEnd_Player2NotPromoted_DiagonalMove()
	{
		Vector2 start = new(0, 0);
		Vector2 end = new(1, 1);

		var steps = rookPlayer1.GetPathFromStartToEnd(start, end).ToList();

		Assert.False(rookPlayer1.IsPromoted);
		Assert.Empty(steps);
	}

	[Fact]
	public void GetStepsFromStartToEnd_Player2Promoted_LateralMove()
	{
		Vector2 start = new(0, 0);
		Vector2 end = new(0, 5);
		rookPlayer1.Promote();

		var steps = rookPlayer1.GetPathFromStartToEnd(start, end).ToList();

		Assert.True(rookPlayer1.IsPromoted);
		Assert.Equal(5, steps.Count);
		Assert.Contains(new Vector2(0, 1), steps);
		Assert.Contains(new Vector2(0, 2), steps);
		Assert.Contains(new Vector2(0, 3), steps);
		Assert.Contains(new Vector2(0, 4), steps);
		Assert.Contains(new Vector2(0, 5), steps);
	}

	[Fact]
	public void GetStepsFromStartToEnd_Player2Promoted_DiagonalMove()
	{
		Vector2 start = new(0, 0);
		Vector2 end = new(1, 1);
		rookPlayer1.Promote();

		var steps = rookPlayer1.GetPathFromStartToEnd(start, end).ToList();

		Assert.True(rookPlayer1.IsPromoted);
		Assert.Single(steps);
		Assert.Contains(new Vector2(1, 1), steps);
	}
}