use crate::{piece::PlacedPiece, Move};
use chessfriend_bitboard::BitBoard;

#[derive(Clone, Debug, Eq, PartialEq)]
struct BitBoardSet {
    quiet: BitBoard,
    captures: BitBoard,
}

#[derive(Clone, Debug, Eq, PartialEq)]
struct MoveListSet {
    quiet: Vec<Move>,
    captures: Vec<Move>,
}

impl MoveListSet {
    pub fn contains(&self, mv: &Move) -> bool {
        self.quiet.contains(mv) || self.captures.contains(mv)
    }
}

/// A set of moves for a piece on the board.
#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct MoveSet {
    piece: PlacedPiece,
    bitboards: BitBoardSet,
    move_lists: MoveListSet,
}

impl MoveSet {
    pub(super) fn new(piece: PlacedPiece) -> MoveSet {
        MoveSet {
            piece,
            bitboards: BitBoardSet {
                quiet: BitBoard::empty(),
                captures: BitBoard::empty(),
            },
            move_lists: MoveListSet {
                quiet: Vec::new(),
                captures: Vec::new(),
            },
        }
    }

    pub(super) fn quiet_moves(
        mut self,
        bitboard: BitBoard,
        move_list: impl Iterator<Item = Move>,
    ) -> MoveSet {
        self.bitboards.quiet = bitboard;
        self.move_lists.quiet = move_list.collect();

        self
    }

    pub(super) fn capture_moves(
        mut self,
        bitboard: BitBoard,
        move_list: impl Iterator<Item = Move>,
    ) -> MoveSet {
        self.bitboards.captures = bitboard;
        self.move_lists.captures = move_list.collect();

        self
    }

    /// Return a BitBoard representing all possible moves.
    pub(super) fn bitboard(&self) -> BitBoard {
        self.bitboards.captures | self.bitboards.quiet
    }

    pub(super) fn moves(&self) -> impl Iterator<Item = &Move> {
        self.move_lists
            .captures
            .iter()
            .chain(self.move_lists.quiet.iter())
    }
}