use crate::movegen::r#move::Move;

use super::zobrist::ZobristHash;

pub struct TranspositionTable {
    positions: Vec<Option<TTEntry>>,
    size: u64,
}

impl TranspositionTable {
    pub fn new(size: u64) -> Self {
        Self {
            positions: vec![None; size as usize],
            size,
        }
    }

    pub fn lookup(&self, zobrist_hash: ZobristHash) -> Option<&TTEntry> {
        let entry = self
            .positions
            .get((zobrist_hash.hash % self.size) as usize)
            .and_then(|entry| entry.as_ref());

        entry
    }

    pub fn insert(&mut self, tt_entry: TTEntry) {
        let index = (tt_entry.hash.hash % self.size) as usize;

        if let Some(stored) = &self.positions[index] {
            if tt_entry.depth > stored.depth || matches!(tt_entry.bound, Bound::Exact) {
                self.positions[index] = Some(tt_entry);
            }
        } else {
            self.positions[index] = Some(tt_entry);
        }
    }
}

#[derive(Clone)]
pub struct TTEntry {
    pub hash: ZobristHash,
    pub depth: u8,
    pub score: i32,
    pub mv: Option<Move>,
    pub bound: Bound,
}

impl TTEntry {
    pub const fn new(
        hash: ZobristHash,
        depth: u8,
        score: i32,
        mv: Option<Move>,
        bound: Bound,
    ) -> Self {
        Self {
            hash,
            depth,
            score,
            mv,
            bound,
        }
    }
}

#[derive(Clone)]
pub enum Bound {
    Exact,
    Lower,
    Upper,
}

#[cfg(test)]
mod tests {
    use crate::{
        board::{fen::from_fen, transposition_table::TranspositionTable},
        evaluation::{MAX_SCORE, MIN_SCORE},
        movegen::attack_generator::init_attacks,
        search,
    };

    const FEN: &str = "1r2k2r/2P1pq1p/2npb3/1p3ppP/p3P3/P2B1Q2/1P1PNPP1/R3K2R w KQk g6 0 1";
    const FEN_WILL_BE: &str = "1r2k2r/2P1pq1p/2npb3/1B3ppP/p3P3/P4Q2/1P1PNPP1/R3K2R b KQk - 0 1";
    const FEN_WONT_BE: &str = "1Q2k2r/2P1pq1p/2npb3/1p3ppP/p3P3/P2B4/1P1PNPP1/R3K2R b KQk - 0 1";

    #[test]
    fn test_transposition_table() -> Result<(), String> {
        init_attacks();
        let mut game = from_fen(FEN)?;
        let mut tt = TranspositionTable::new(1000000);

        // fill Transposition Table
        search::negamax::negamax(&mut game, MIN_SCORE, MAX_SCORE, 2, 0, &mut tt);

        let will_be_hash = from_fen(FEN_WILL_BE)?.hash;
        let tt_entry = tt.lookup(will_be_hash);

        assert!(tt_entry.is_some());

        let wont_be_hash = from_fen(FEN_WONT_BE)?.hash;
        let tt_entry = tt.lookup(wont_be_hash);

        assert!(tt_entry.is_none());

        Ok(())
    }
}