// Eryn Wells <eryn@erynwells.me>

use super::{move_generator_declaration, MoveGeneratorInternal, MoveSet};
use crate::{
    piece::{Color, Piece, PlacedPiece},
    MoveBuilder, Position,
};
use chessfriend_bitboard::BitBoard;

move_generator_declaration!(KnightMoveGenerator);

impl<'pos> MoveGeneratorInternal for KnightMoveGenerator<'pos> {
    fn piece(color: Color) -> Piece {
        Piece::knight(color)
    }

    fn move_set_for_piece(position: &Position, placed_piece: PlacedPiece) -> MoveSet {
        let opposing_pieces = position.bitboard_for_color(placed_piece.piece().color().other());
        let empty_squares = position.empty_squares();
        let knight_moves = BitBoard::knight_moves(placed_piece.square());

        let quiet_moves_bb = knight_moves & empty_squares;
        let capture_moves_bb = knight_moves & opposing_pieces;

        let quiet_moves = quiet_moves_bb.occupied_squares().map(|to_sq| {
            MoveBuilder::new(*placed_piece.piece(), placed_piece.square(), to_sq).build()
        });
        let capture_moves = capture_moves_bb.occupied_squares().map(|to_sq| {
            let captured_piece = position.piece_on_square(to_sq).unwrap();
            MoveBuilder::new(*placed_piece.piece(), placed_piece.square(), to_sq)
                .capturing(captured_piece)
                .build()
        });

        MoveSet::new(placed_piece)
            .quiet_moves(quiet_moves_bb, quiet_moves)
            .capture_moves(capture_moves_bb, capture_moves)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{piece, position, Move};
    use chessfriend_core::Square;
    use std::collections::HashSet;

    #[test]
    fn one_knight() {
        let pos = position![
            White Knight on E4,
        ];

        let generator = KnightMoveGenerator::new(&pos, Color::White);

        /*
        let bb = generator.bitboard();
        assert_eq!(
            bb,
            BitBoard::new(
                0b00000000_00000000_00000000_00111000_00101000_00111000_00000000_00000000
            )
        );
        */

        let expected_moves = [
            MoveBuilder::new(piece!(White Knight), Square::E4, Square::C3).build(),
            MoveBuilder::new(piece!(White Knight), Square::E4, Square::D2).build(),
            MoveBuilder::new(piece!(White Knight), Square::E4, Square::F2).build(),
            MoveBuilder::new(piece!(White Knight), Square::E4, Square::G3).build(),
            MoveBuilder::new(piece!(White Knight), Square::E4, Square::C5).build(),
            MoveBuilder::new(piece!(White Knight), Square::E4, Square::D6).build(),
            MoveBuilder::new(piece!(White Knight), Square::E4, Square::G5).build(),
            MoveBuilder::new(piece!(White Knight), Square::E4, Square::F6).build(),
        ];

        let mut generated_moves: HashSet<Move> = generator.iter().cloned().collect();

        for ex_move in expected_moves {
            assert!(
                generated_moves.remove(&ex_move),
                "{:#?} was not generated",
                &ex_move
            );
        }

        assert!(
            generated_moves.is_empty(),
            "Moves unexpectedly present: {:#?}",
            generated_moves
        );
    }
}