use crate::{CheckersBitBoard, SquareCoordinate};
use std::fmt::{Display, Formatter};

#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
pub enum MoveDirection {
	ForwardLeft = 0,
	ForwardRight = 1,
	BackwardLeft = 2,
	BackwardRight = 3,
}

/// A checkers move
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
pub struct Move(u8);

impl Move {
	/// Create a new move
	///
	/// # Arguments
	///
	/// * `start` - The location of the piece that should move
	/// * `direction` - The direction the piece should move in
	/// * `jump` - Whether or not the piece should jump
	pub const fn new(start: usize, direction: MoveDirection, jump: bool) -> Self {
		Self(((start as u8) << 3) | ((direction as u8) << 1) | jump as u8)
	}

	/// The stating position of the move
	pub const fn start(self) -> u32 {
		((self.0 >> 3) & 0b11111) as u32
	}

	/// The direction the move goes in
	pub const fn direction(self) -> MoveDirection {
		match (self.0 >> 1) & 0b11 {
			0 => MoveDirection::ForwardLeft,
			1 => MoveDirection::ForwardRight,
			2 => MoveDirection::BackwardLeft,
			3 => MoveDirection::BackwardRight,
			_ => unreachable!(),
		}
	}

	/// Returns `true` if the move is a jump
	pub const fn is_jump(self) -> bool {
		(self.0 & 1) == 1
	}

	/// Calculates the value of the end position of the move
	pub const fn end_position(self) -> usize {
		let dest = match self.is_jump() {
			false => match self.direction() {
				MoveDirection::ForwardLeft => (self.start() + 7) % 32,
				MoveDirection::ForwardRight => (self.start() + 1) % 32,
				MoveDirection::BackwardLeft => self.start().wrapping_sub(1) % 32,
				MoveDirection::BackwardRight => self.start().wrapping_sub(7) % 32,
			},
			true => match self.direction() {
				MoveDirection::ForwardLeft => (self.start() + 14) % 32,
				MoveDirection::ForwardRight => (self.start() + 2) % 32,
				MoveDirection::BackwardLeft => self.start().wrapping_sub(2) % 32,
				MoveDirection::BackwardRight => self.start().wrapping_sub(14) % 32,
			},
		};
		dest as usize
	}

	/// Apply the move to a board. This does not mutate the original board,
	/// but instead returns a new one.
	///
	/// # Arguments
	///
	/// * `board` - The board to apply the move to
	///
	/// # Panics
	///
	/// Panics if the starting position of this move is greater than or equal to 32
	///
	/// # Safety
	///
	/// Applying an illegal move to the board is undefined behavior.
	/// This functions results in undefined behavior if:
	/// * The piece moves in a direction which would move it outside of the board
	/// * The starting position of this move doesn't contain a piece
	/// * The end position already contains a piece
	/// * A jump occurs where jumps are not allowed
	/// * A move is not a jump even though jumps are available
	pub const unsafe fn apply_to(self, board: CheckersBitBoard) -> CheckersBitBoard {
		match self.is_jump() {
			false => match self.direction() {
				MoveDirection::ForwardLeft => {
					board.move_piece_forward_left_unchecked(self.start() as usize)
				}
				MoveDirection::ForwardRight => {
					board.move_piece_forward_right_unchecked(self.start() as usize)
				}
				MoveDirection::BackwardLeft => {
					board.move_piece_backward_left_unchecked(self.start() as usize)
				}
				MoveDirection::BackwardRight => {
					board.move_piece_backward_right_unchecked(self.start() as usize)
				}
			},
			true => match self.direction() {
				MoveDirection::ForwardLeft => {
					board.jump_piece_forward_left_unchecked(self.start() as usize)
				}
				MoveDirection::ForwardRight => {
					board.jump_piece_forward_right_unchecked(self.start() as usize)
				}
				MoveDirection::BackwardLeft => {
					board.jump_piece_backward_left_unchecked(self.start() as usize)
				}
				MoveDirection::BackwardRight => {
					board.jump_piece_backward_right_unchecked(self.start() as usize)
				}
			},
		}
	}
}

impl Display for Move {
	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
		write!(
			f,
			"{}-{}",
			SquareCoordinate::from_value(self.start() as usize),
			SquareCoordinate::from_value(self.end_position())
		)
	}
}

#[cfg(test)]
mod tests {

	use super::*;
	use proptest::prelude::*;

	proptest! {
		#[test]
		fn new(start in 0usize..32, jump in proptest::bool::ANY) {
			let direction = MoveDirection::ForwardLeft;
			let move_test = Move::new(start, direction, jump);
			assert_eq!(move_test.start() as usize, start);
			assert_eq!(move_test.direction(), direction);
			assert_eq!(move_test.is_jump(), jump);

			let direction = MoveDirection::ForwardRight;
			let move_test = Move::new(start, direction, jump);
			assert_eq!(move_test.start() as usize, start);
			assert_eq!(move_test.direction(), direction);
			assert_eq!(move_test.is_jump(), jump);

			let direction = MoveDirection::BackwardLeft;
			let move_test = Move::new(start, direction, jump);
			assert_eq!(move_test.start() as usize, start);
			assert_eq!(move_test.direction(), direction);
			assert_eq!(move_test.is_jump(), jump);

			let direction = MoveDirection::BackwardRight;
			let move_test = Move::new(start, direction, jump);
			assert_eq!(move_test.start() as usize, start);
			assert_eq!(move_test.direction(), direction);
			assert_eq!(move_test.is_jump(), jump);
		}

		#[test]
		fn start(start in 0usize..32, jump in proptest::bool::ANY) {
			let direction = MoveDirection::ForwardLeft;
			let move_test = Move::new(start, direction, jump);
			assert_eq!(move_test.start(), start as u32);
		}

		#[test]
		fn direction(start in 0usize..32, jump in proptest::bool::ANY) {
			let direction = MoveDirection::ForwardLeft;
			let move_test = Move::new(start, direction, jump);
			assert_eq!(move_test.direction(), direction);

			let direction = MoveDirection::ForwardRight;
			let move_test = Move::new(start, direction, jump);
			assert_eq!(move_test.direction(), direction);

			let direction = MoveDirection::BackwardLeft;
			let move_test = Move::new(start, direction, jump);
			assert_eq!(move_test.direction(), direction);

			let direction = MoveDirection::BackwardRight;
			let move_test = Move::new(start, direction, jump);
			assert_eq!(move_test.direction(), direction);
		}

		#[test]
		fn is_jump(start in 0usize..32, jump in proptest::bool::ANY) {
			let direction = MoveDirection::ForwardLeft;
			let move_test = Move::new(start, direction, jump);
			assert_eq!(move_test.is_jump(), jump);
		}
	}

	#[test]
	fn end_position_forward_left_slide() {
		let direction = MoveDirection::ForwardLeft;
		let start = 8;
		let move_test = Move::new(start, direction, false);
		assert_eq!(move_test.end_position(), 15);
	}

	#[test]
	fn end_position_forward_right_slide() {
		let direction = MoveDirection::ForwardRight;
		let start = 26;
		let move_test = Move::new(start, direction, false);
		assert_eq!(move_test.end_position(), 27);
	}

	#[test]
	fn end_position_backward_right_slide() {
		let direction = MoveDirection::BackwardRight;
		let start = 2;
		let move_test = Move::new(start, direction, false);
		assert_eq!(move_test.end_position(), 27);
	}

	#[test]
	fn end_position_backward_left_slide() {
		let direction = MoveDirection::BackwardLeft;
		let start = 16;
		let move_test = Move::new(start, direction, false);
		assert_eq!(move_test.end_position(), 15);
	}

	#[test]
	fn end_position_forward_left_jump() {
		let direction = MoveDirection::ForwardLeft;
		let start = 8;
		let move_test = Move::new(start, direction, true);
		assert_eq!(move_test.end_position(), 22);
	}

	#[test]
	fn end_position_forward_right_jump() {
		let direction = MoveDirection::ForwardRight;
		let start = 26;
		let move_test = Move::new(start, direction, true);
		assert_eq!(move_test.end_position(), 28);
	}

	#[test]
	fn end_position_backward_right_jump() {
		let direction = MoveDirection::BackwardRight;
		let start = 2;
		let move_test = Move::new(start, direction, true);
		assert_eq!(move_test.end_position(), 20);
	}

	#[test]
	fn end_position_backward_left_jump() {
		let direction = MoveDirection::BackwardLeft;
		let start = 16;
		let move_test = Move::new(start, direction, true);
		assert_eq!(move_test.end_position(), 14);
	}
}