use super::{
    bitboard::BitBoard,
    chains::{gen_adj_lookup, ChainCollection, PosMap},
    piece::Piece,
};
use const_fn::const_fn;
use lazy_static::lazy_static;
use std::{cmp::Ordering, fmt};

#[derive(PartialEq, Eq, Copy, Clone, Debug)]
pub enum Winner {
    Player(Piece),
    Tie,
    None,
}

lazy_static! {
    /// Precompute all possible chains for each position on the board
    static ref ADJ_LOOKUP: PosMap<ChainCollection> = gen_adj_lookup();
}

/// Repersents a Othello game board at a certain space
#[derive(Copy, Clone, PartialEq, Eq)]
pub struct Board {
    /// [`BitBoard`] containing all white pieces
    white_board: BitBoard,

    /// [`BitBoard`] containing all black pieces
    black_board: BitBoard,
}

impl fmt::Display for Board {
    #[allow(clippy::repeat_once)] // clippy gets mad about when PADDING == 1
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let horiz_sep_line = "-".repeat(Self::BOARD_SIZE * 2 + 1);

        // basically calculates the # of digits BOARD_SIZE needs
        const PADDING: usize = (Board::BOARD_SIZE - 1).ilog10() as usize + 1;

        let space_padding = " ".repeat(PADDING);

        // Print numbers at top so the board can be read more easier
        write!(f, "{} ", space_padding)?;
        for j in (0..Self::BOARD_SIZE).rev() {
            write!(f, "{:0PADDING$} ", j)?;
        }
        writeln!(f)?;

        for i in (0..Self::BOARD_SIZE).rev() {
            writeln!(f, "{}{}", space_padding, horiz_sep_line)?;

            write!(f, "{:0PADDING$}|", i)?;
            for j in (0..Self::BOARD_SIZE).rev() {
                write!(
                    f,
                    "{}|",
                    self.get(i, j).as_ref().map(Piece::symbol).unwrap_or(' ')
                )?;
            }
            writeln!(f)?;
        }
        // put a line at the bottom of the board too
        writeln!(f, " {}", horiz_sep_line)?;

        // Print the current score
        write!(
            f,
            "{}",
            [Piece::White, Piece::Black]
                .map(|p| format!("{} Score: {}\n", p.text(), self.count(p)))
                .concat()
        )?;

        Ok(())
    }
}

impl fmt::Debug for Board {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self)
    }
}

impl Board {
    pub const BOARD_SIZE: usize = 8;

    /// Area of the board
    pub const BOARD_AREA: usize = Self::BOARD_SIZE.pow(2);

    /// Create a new empty board
    #[allow(clippy::new_without_default)]
    pub const fn new() -> Self {
        Self {
            white_board: BitBoard::new(),
            black_board: BitBoard::new(),
        }
    }

    /// Starting position
    #[const_fn(cfg(not(feature = "bitvec")))]
    pub const fn starting_pos(mut self) -> Self {
        self.place_unchecked(
            (Self::BOARD_SIZE / 2) - 1,
            (Self::BOARD_SIZE / 2) - 1,
            Piece::White,
        );
        self.place_unchecked(
            Self::BOARD_SIZE / 2,
            (Self::BOARD_SIZE / 2) - 1,
            Piece::Black,
        );
        self.place_unchecked(
            (Self::BOARD_SIZE / 2) - 1,
            Self::BOARD_SIZE / 2,
            Piece::Black,
        );
        self.place_unchecked(Self::BOARD_SIZE / 2, Self::BOARD_SIZE / 2, Piece::White);
        self
    }

    /// Provides an iterator of all possible positions on the board
    pub fn all_positions() -> impl Iterator<Item = (usize, usize)> {
        (0..Self::BOARD_SIZE).flat_map(|i| (0..Self::BOARD_SIZE).map(move |j| (i, j)))
    }

    /// Returns an iterator of all possible moves a `color` can make
    pub fn possible_moves(&self, color: Piece) -> impl Iterator<Item = (usize, usize)> + use<'_> {
        Self::all_positions().filter(move |&(i, j)| self.would_prop(i, j, color))
    }

    pub fn sides() -> impl Iterator<Item = (usize, usize)> {
        (0..Self::BOARD_SIZE)
            .map(|i| (i, Self::BOARD_SIZE - 1))
            .chain((0..Self::BOARD_SIZE).map(|i| (i, 0)))
            .chain((0..Self::BOARD_SIZE).map(|j| (Self::BOARD_SIZE - 1, j)))
            .chain((0..Self::BOARD_SIZE).map(|j| (0, j)))
    }

    pub fn corners() -> impl Iterator<Item = (usize, usize)> {
        [0, Self::BOARD_SIZE - 1]
            .into_iter()
            .flat_map(|i| [0, Self::BOARD_SIZE - 1].into_iter().map(move |j| (i, j)))
    }

    /// Get a reference to a backing [`BitBoard`]
    const fn board(&self, color: Piece) -> &BitBoard {
        match color {
            Piece::Black => &self.black_board,
            Piece::White => &self.white_board,
        }
    }

    /// Get a mutable reference to a backing [`BitBoard`]
    const fn board_mut(&mut self, color: Piece) -> &mut BitBoard {
        match color {
            Piece::Black => &mut self.black_board,
            Piece::White => &mut self.white_board,
        }
    }

    #[const_fn(cfg(not(feature = "bitvec")))]
    pub const fn get_piece(&self, i: usize, j: usize, color: Piece) -> bool {
        self.board(color).get(i, j)
    }

    /// Returns the color of a place on the [`Board`] at a position
    #[const_fn(cfg(not(feature = "bitvec")))]
    pub const fn get(&self, i: usize, j: usize) -> Option<Piece> {
        if self.get_piece(i, j, Piece::White) {
            Some(Piece::White)
        } else if self.get_piece(i, j, Piece::Black) {
            Some(Piece::Black)
        } else {
            None
        }
    }

    /// Place a piece without checking for propegation of validity
    #[const_fn(cfg(not(feature = "bitvec")))]
    const fn place_unchecked(&mut self, i: usize, j: usize, piece: Piece) {
        self.board_mut(piece).set(i, j, true);
        self.board_mut(piece.flip()).set(i, j, false);
    }

    #[const_fn(cfg(not(feature = "bitvec")))]
    const fn delete(&mut self, i: usize, j: usize) {
        self.board_mut(Piece::White).set(i, j, false);
        self.board_mut(Piece::Black).set(i, j, false);
    }

    /// Return a modified [`Board`] with the piece placed at a position
    /// Returns None if the move was invalid
    pub fn what_if(&self, i: usize, j: usize, piece: Piece) -> Result<Self, &'static str> {
        // extract check here to avoid copy
        if self.get(i, j).is_some() {
            return Err("position is occupied");
        }

        let mut self_copy = *self;
        self_copy.place(i, j, piece).map(|_| self_copy)
    }

    /// Returns a bool which represents whether or not a move would propegate and be valid
    pub fn would_prop(&self, i: usize, j: usize, piece: Piece) -> bool {
        self.get(i, j).is_none() && self.propegate_from_dry(i, j, piece).next().is_some()
    }

    pub fn place(&mut self, i: usize, j: usize, piece: Piece) -> Result<(), &'static str> {
        if self.get(i, j).is_some() {
            return Err("position is occupied");
        }

        self.place_unchecked(i, j, piece);
        if self.propegate_from(i, j) == 0 {
            self.delete(i, j);
            Err("move would not propegate")
        } else {
            Ok(())
        }
    }

    /// Propegate the board and captures starting from a specific position
    fn propegate_from(&mut self, i: usize, j: usize) -> usize {
        let Some(starting_color) = self.get(i, j) else {
            return 0;
        };

        // PERF! avoid clones and collections here using raw pointers
        let iterator = unsafe {
            // SAFETY! `propegate_from_dry` should not have overlapping chains
            // if overlapping chains were to exist, `self.place_unchecked` could collide with `self.get`
            // I now have a check in `ADJ_LOOKUP` on creation
            (*(self as *const Self)).propegate_from_dry(i, j, starting_color)
        };

        let mut count = 0;
        for &(i, j) in iterator {
            self.place_unchecked(i, j, starting_color);
            count += 1;
        }

        count
    }

    /// Propegate piece captures originating from (i, j)
    /// DO NOT USE THIS ALONE, this should be called as a part of
    /// [`Board::place`] or [`Board::place_and_prop_unchecked`]
    fn propegate_from_dry(
        &self,
        i: usize,
        j: usize,
        starting_color: Piece,
    ) -> impl Iterator<Item = &(usize, usize)> + use<'_> {
        ADJ_LOOKUP
            .get(i, j)
            .iter()
            .flat_map(move |chain| {
                for (idx, &(new_i, new_j)) in chain.into_iter().enumerate() {
                    let piece = self.get(new_i, new_j)?;
                    if piece == starting_color {
                        return chain.get(..idx);
                    }
                }
                None
            })
            .flatten()
    }

    /// Count the number of a type of [`Piece`] on the board
    #[const_fn(cfg(not(feature = "bitvec")))]
    pub const fn count(&self, piece: Piece) -> usize {
        self.board(piece).count()
    }

    /// Get the "net score" of a player
    /// Formula: `net_score = Score_player - Score_opponent`
    #[const_fn(cfg(not(feature = "bitvec")))]
    pub const fn net_score(&self, piece: Piece) -> i16 {
        self.count(piece) as i16 - self.count(piece.flip()) as i16
    }

    /// Returns the winner of the board (if any)
    pub fn game_winner(&self) -> Winner {
        // Wikipedia: `Players take alternate turns. If one player cannot make a valid move, play passes back to the other player. The game ends when the grid has filled up or if neither player can make a valid move.`

        if self.possible_moves(Piece::Black).next().is_some()
            || self.possible_moves(Piece::White).next().is_some()
        {
            // player can still make a move, there is no winner
            return Winner::None;
        }

        match self.count(Piece::White).cmp(&self.count(Piece::Black)) {
            Ordering::Greater => Winner::Player(Piece::White), // White win
            Ordering::Less => Winner::Player(Piece::Black),    // Black win
            Ordering::Equal => Winner::Tie,
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn place_and_get() {
        let mut board = Board::new();
        assert_eq!(board.get(0, 0), None);
        board.place_unchecked(0, 0, Piece::Black);
        assert_eq!(board.get(0, 0), Some(Piece::Black));
    }

    #[test]
    fn place_and_capture_simple() {
        let mut board = Board::new();
        board.place_unchecked(0, 0, Piece::Black);
        board.place_unchecked(0, 1, Piece::White);

        assert_eq!(board.place(0, 2, Piece::Black), Ok(()));

        assert_eq!(board.get(0, 1), Some(Piece::Black));
    }

    #[test]
    fn failed_capture() {
        let mut board = Board::new();

        board.place_unchecked(0, 0, Piece::Black);
        board.place_unchecked(0, 2, Piece::White);

        // should fail
        assert_ne!(board.place(0, 3, Piece::Black), Ok(()));

        assert_eq!(
            board.get(0, 1),
            None,
            "(0, 1) was overridden even though it's an empty space"
        );
    }

    #[test]
    fn long_capture_horiz() {
        let mut board = Board::new();

        board.place_unchecked(0, 0, Piece::Black);

        for j in 1..=6 {
            board.place_unchecked(0, j, Piece::White);
        }

        assert_eq!(board.place(0, 7, Piece::Black), Ok(()));

        for j in 2..=6 {
            assert_eq!(
                board.get(0, j),
                Some(Piece::Black),
                "should be black at: ({}, {})",
                0,
                j
            );
        }
    }

    #[test]
    fn long_capture_vert() {
        let mut board = Board::new();

        board.place_unchecked(0, 0, Piece::Black);

        for i in 1..=6 {
            board.place_unchecked(i, 0, Piece::White);
        }

        assert_eq!(board.place(7, 0, Piece::Black), Ok(()));

        for i in 2..=6 {
            assert_eq!(
                board.get(i, 0),
                Some(Piece::Black),
                "should be black at: ({}, {})",
                i,
                0
            );
        }
    }

    // Test corner capture from top-left corner
    #[test]
    fn corner_capture_top_left() {
        let mut board = Board::new();

        // Black pieces at (2, 2) and (0, 0)
        board.place_unchecked(1, 1, Piece::White); // to be captured
        board.place_unchecked(2, 2, Piece::Black);
        assert_eq!(board.place(0, 0, Piece::Black), Ok(()));

        // Capture white piece at (1,1)
        assert_eq!(board.get(1, 1), Some(Piece::Black), "\n{}", board);
    }

    // Test corner capture from top-right corner
    #[test]
    fn corner_capture_top_right() {
        let mut board = Board::new();

        // Black pieces at (0, 7) and (2, 5)
        board.place_unchecked(0, 7, Piece::Black);
        board.place_unchecked(1, 6, Piece::White); // to be captured
        assert_eq!(board.place(2, 5, Piece::Black), Ok(()));

        // Capture white piece at (1, 6)
        assert_eq!(board.get(1, 6), Some(Piece::Black), "\n{}", board);
    }

    // Test corner capture from bottom-left corner
    #[test]
    fn corner_capture_bottom_left() {
        let mut board = Board::new();

        // Black pieces at (7, 0) and (5, 2)
        board.place_unchecked(7, 0, Piece::Black);
        board.place_unchecked(6, 1, Piece::White); // to be captured
        assert_eq!(board.place(5, 2, Piece::Black), Ok(()));

        // Capture white piece at (6, 1)
        assert_eq!(board.get(6, 1), Some(Piece::Black), "\n{}", board);
    }

    // Test corner capture from bottom-right corner
    #[test]
    fn corner_capture_bottom_right() {
        let mut board = Board::new();

        // Black pieces at (7, 7) and (5, 5)
        board.place_unchecked(7, 7, Piece::Black);
        board.place_unchecked(6, 6, Piece::White); // to be captured
        assert_eq!(board.place(5, 5, Piece::Black), Ok(()));

        // Capture white piece at (6, 6)
        assert_eq!(board.get(6, 6), Some(Piece::Black), "\n{}", board);
    }

    // Test capture from top-left corner (horizontal)
    #[test]
    fn capture_top_left_horiz() {
        let mut board = Board::new();

        // Create a scenario where a capture should happen horizontally from (0, 0)
        board.place_unchecked(0, 0, Piece::Black);
        board.place_unchecked(0, 1, Piece::White); // to be captured
        assert_eq!(board.place(0, 2, Piece::Black), Ok(()));

        assert_eq!(board.get(0, 1), Some(Piece::Black), "\n{}", board);
    }

    // Test capture from top-right corner (horizontal)
    #[test]
    fn capture_top_right_horiz() {
        let mut board = Board::new();

        // Create a scenario where a capture should happen horizontally from (0, 7)
        board.place_unchecked(0, 7, Piece::Black);
        board.place_unchecked(0, 6, Piece::White); // to be captured
        assert_eq!(board.place(0, 5, Piece::Black), Ok(()));

        assert_eq!(board.get(0, 6), Some(Piece::Black), "\n{}", board);
    }

    // Test capture from top-left corner (vertical)
    #[test]
    fn capture_top_left_vert() {
        let mut board = Board::new();

        // Create a scenario where a capture should happen vertically from (0, 0)
        board.place_unchecked(0, 0, Piece::Black);
        board.place_unchecked(1, 0, Piece::White); // to be captured
        assert_eq!(board.place(2, 0, Piece::Black), Ok(()));

        assert_eq!(board.get(1, 0), Some(Piece::Black), "\n{}", board);
    }

    // Test capture from bottom-left corner (vertical)
    #[test]
    fn capture_bottom_left_vert() {
        let mut board = Board::new();

        // Create a scenario where a capture should happen vertically from (7, 0)
        board.place_unchecked(7, 0, Piece::Black);
        board.place_unchecked(6, 0, Piece::White); // to be captured
        assert_eq!(board.place(5, 0, Piece::Black), Ok(()));

        assert_eq!(board.get(6, 0), Some(Piece::Black), "\n{}", board);
    }
}