//! Move representation.

use crate::array_vec::*;
use crate::bitboard::*;
use crate::board::*;
use crate::position::*;
use crate::san::*;
use crate::uci::*;

use std::iter::ExactSizeIterator;
use std::iter::FusedIterator;

/// A legal move.
#[must_use]
#[derive(Clone, Copy)]
pub struct Move<'l> {
    position: &'l Position,
    raw: RawMove,
}

impl<'l> Move<'l> {
    pub(crate) unsafe fn new_unchecked(position: &'l Position, raw: RawMove) -> Self {
        Self { position, raw }
    }

    /// Returns the position after playing the move.
    ///
    /// This sets the en passant square after a double pawn advance, even when there is no pawn to
    /// capture or when capturing is not legal.
    pub fn make(self) -> Position {
        let mut position = self.position.clone();
        unsafe { position.play_unchecked(self.raw) };
        position
    }

    /// Returns the position the move is played on.
    #[inline]
    pub fn position(self) -> &'l Position {
        self.position
    }

    /// Returns the type of piece that moves.
    #[inline]
    pub fn role(self) -> Role {
        self.raw.role()
    }

    /// Returns the origin square of the move.
    #[inline]
    pub fn from(self) -> Square {
        self.raw.from()
    }

    /// Returns the target square of the move.
    #[inline]
    pub fn to(self) -> Square {
        self.raw.to()
    }

    /// Returns the type of piece that the pawn is promoted to, if the move is a promotion.
    #[inline]
    pub fn promotion(self) -> Option<Role> {
        self.raw.promotion()
    }

    /// Returns `true` if the move is a capture.
    #[inline]
    pub fn is_capture(self) -> bool {
        let setup = self.position.as_setup();
        self.raw.kind == MoveType::EnPassant
            || !((setup.p_b_q | setup.n_b_k | setup.r_q_k) & self.to().bitboard()).is_empty()
    }

    /// Returns the type of piece that is captured, if the move is a capture.
    #[inline]
    pub fn captured(self) -> Option<Role> {
        match self.raw.kind {
            MoveType::EnPassant => Some(Role::Pawn),
            _ => self.position.as_setup().get_role(self.raw.to),
        }
    }

    /// Returns the UCI notation of the move.
    #[inline]
    pub fn to_uci(self) -> UciMove {
        self.raw.uci()
    }

    /// Returns the standard algebraic notation of the move.
    pub fn to_san(self) -> San {
        struct MoveGenImpl<const ROLE: u8> {
            to: Bitboard,
            candidates: Bitboard,
        }
        impl<const ROLE: u8> MoveGenImpl<ROLE> {
            #[inline]
            fn new(to: Square) -> Self {
                Self {
                    to: to.bitboard(),
                    candidates: Bitboard::new(),
                }
            }
        }
        impl<const ROLE: u8> MoveGen for MoveGenImpl<ROLE> {
            #[inline]
            fn roles(&self, role: Role) -> bool {
                role as u8 == ROLE
            }
            #[inline]
            fn to(&self) -> Bitboard {
                self.to
            }
            #[inline]
            fn is_check(&mut self) {}
            #[inline]
            fn en_passant_is_legal(&mut self) {}
            #[inline]
            fn extend<I>(&mut self, iter: I)
            where
                I: Iterator<Item = RawMove> + ExactSizeIterator,
            {
                iter.for_each(|raw| {
                    debug_assert!(raw.role() as u8 == ROLE);
                    debug_assert!(self.to.contains(raw.to()));
                    self.candidates.insert(raw.from);
                });
            }
        }
        San {
            inner: match self.raw.kind {
                MoveType::CastleShort => SanInner::Castle(CastlingSide::Short),
                MoveType::CastleLong => SanInner::Castle(CastlingSide::Long),
                MoveType::PawnAdvance
                | MoveType::PawnAdvancePromotion
                | MoveType::PawnDoubleAdvance => SanInner::Normal {
                    role: Role::Pawn,
                    file: None,
                    rank: None,
                    capture: false,
                    target: self.to(),
                    promotion: self.promotion(),
                },
                MoveType::PawnAttack | MoveType::PawnAttackPromotion | MoveType::EnPassant => {
                    SanInner::Normal {
                        role: Role::Pawn,
                        file: Some(self.from().file()),
                        rank: None,
                        capture: true,
                        target: self.to(),
                        promotion: self.promotion(),
                    }
                }
                _ => {
                    fn aux<const ROLE: u8>(m: &Move) -> SanInner {
                        let mut moves = MoveGenImpl::<ROLE>::new(m.to());
                        m.position().generate_moves(&mut moves);
                        let candidates = moves.candidates;
                        let (file, rank) = if candidates == m.from().bitboard() {
                            (None, None)
                        } else if candidates & m.from().file().bitboard() == m.from().bitboard() {
                            (Some(m.from().file()), None)
                        } else if candidates & m.from().rank().bitboard() == m.from().bitboard() {
                            (None, Some(m.from().rank()))
                        } else {
                            (Some(m.from().file()), Some(m.from().rank()))
                        };
                        SanInner::Normal {
                            role: m.role(),
                            file,
                            rank,
                            capture: m.is_capture(),
                            target: m.to(),
                            promotion: None,
                        }
                    }
                    match self.role() {
                        Role::Pawn => aux::<1>(&self),
                        Role::Knight => aux::<2>(&self),
                        Role::Bishop => aux::<3>(&self),
                        Role::Rook => aux::<4>(&self),
                        Role::Queen => aux::<5>(&self),
                        Role::King => aux::<6>(&self),
                    }
                }
            },
            suffix: {
                let pos = self.make();
                let mut moves = MateMoveGenImpl::new();
                pos.generate_moves(&mut moves);
                moves.is_check.then(|| match moves.is_mate {
                    true => SanSuffix::Checkmate,
                    false => SanSuffix::Check,
                })
            },
        }
    }
}

/// A list of legal moves on the same position.
///
/// It can be obtained using the [`Position::legal_moves`] method. This type is an iterator over
/// [`Move`] objects.
#[must_use]
pub struct Moves<'l> {
    position: &'l Position,
    is_check: bool,
    en_passant_is_legal: bool,
    array: ArrayVec<RawMove, MAX_LEGAL_MOVES>,
}

impl<'l> MoveGen for Moves<'l> {
    #[inline]
    fn is_check(&mut self) {
        self.is_check = true;
    }
    #[inline]
    fn en_passant_is_legal(&mut self) {
        self.en_passant_is_legal = true;
    }
    #[inline]
    fn extend<I>(&mut self, iter: I)
    where
        I: Iterator<Item = RawMove> + ExactSizeIterator,
    {
        iter.for_each(|raw| unsafe { self.array.push_unchecked(raw) });
    }
}

impl<'l> Moves<'l> {
    #[inline]
    pub(crate) fn compute(position: &'l Position) -> Moves<'l> {
        fn aux(position: &Position, moves: &mut Moves) {
            position.generate_moves(moves);
        }
        let mut moves = Moves {
            position,
            is_check: false,
            en_passant_is_legal: false,
            array: ArrayVec::new(),
        };
        aux(position, &mut moves);
        moves
    }

    /// Returns the position on which the moves are played.
    #[inline]
    pub fn position(&self) -> &Position {
        self.position
    }

    /// Iterates over the moves.
    #[inline]
    pub fn iter(&'l self) -> MovesIter<'l> {
        MovesIter {
            position: self.position,
            iter: (&self.array).into_iter(),
        }
    }

    /// Returns the number of moves in the list.
    #[inline]
    pub fn len(&self) -> usize {
        self.array.len()
    }

    /// Returns `true` if en passant is legal.
    #[inline]
    pub fn en_passant_is_legal(&self) -> bool {
        self.en_passant_is_legal
    }

    /// Returns `true` if the king is in check.
    #[inline]
    pub fn is_check(&self) -> bool {
        self.is_check
    }

    /// Returns the move at the given index, if it exists.
    #[inline]
    pub fn get(&self, index: usize) -> Option<Move<'l>> {
        self.array.get(index).copied().map(|raw| Move {
            position: self.position,
            raw,
        })
    }

    /// Sorts the moves in the list.
    ///
    /// See [`slice::sort_unstable_by`] for potential panics.
    #[inline]
    pub fn sort_by<F>(&mut self, mut compare: F)
    where
        F: FnMut(Move, Move) -> std::cmp::Ordering,
    {
        self.array.as_slice_mut().sort_unstable_by(|a, b| {
            compare(
                Move {
                    position: self.position,
                    raw: *a,
                },
                Move {
                    position: self.position,
                    raw: *b,
                },
            )
        });
    }
}

/// An iterator over legal moves.
pub struct MovesIter<'l> {
    position: &'l Position,
    iter: ArrayVecIter<'l, RawMove, MAX_LEGAL_MOVES>,
}
impl<'l> Iterator for MovesIter<'l> {
    type Item = Move<'l>;
    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        self.iter.next().map(|raw| Move {
            position: self.position,
            raw,
        })
    }
}
impl<'l> FusedIterator for MovesIter<'l> {}
impl<'l> ExactSizeIterator for MovesIter<'l> {
    #[inline]
    fn len(&self) -> usize {
        self.iter.len()
    }
}
impl<'l> IntoIterator for &'l Moves<'l> {
    type Item = Move<'l>;
    type IntoIter = MovesIter<'l>;
    #[inline]
    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

/// An iterator over legal moves.
pub struct MovesIntoIter<'l> {
    position: &'l Position,
    iter: ArrayVecIntoIter<RawMove, MAX_LEGAL_MOVES>,
}
impl<'l> Iterator for MovesIntoIter<'l> {
    type Item = Move<'l>;
    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        self.iter.next().map(|raw| Move {
            position: self.position,
            raw,
        })
    }
    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        self.iter.size_hint()
    }
}
impl<'l> FusedIterator for MovesIntoIter<'l> {}
impl<'l> ExactSizeIterator for MovesIntoIter<'l> {
    #[inline]
    fn len(&self) -> usize {
        self.iter.len()
    }
}
impl<'l> IntoIterator for Moves<'l> {
    type Item = Move<'l>;
    type IntoIter = MovesIntoIter<'l>;
    #[inline]
    fn into_iter(self) -> Self::IntoIter {
        MovesIntoIter {
            position: self.position,
            iter: self.array.into_iter(),
        }
    }
}