use crate::{board::zobrist::ZobristHash, movegen::r#move::Move};

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,
        evaluation::{MAX_SCORE, MIN_SCORE},
        movegen::attack_generator::init_attacks,
        search::{
            negamax::negamax, time::TimeInfo, transposition_table::TranspositionTable, MAX_TT_SIZE,
        },
    };

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

    #[test]
    fn test_transposition_table() -> anyhow::Result<()> {
        init_attacks();
        let mut game = from_fen(FEN).unwrap();
        let mut tt = TranspositionTable::new(MAX_TT_SIZE);
        let time_info = TimeInfo::new(std::time::Instant::now(), 30000);

        negamax(&mut game, MIN_SCORE, MAX_SCORE, 3, 0, &time_info, &mut tt)
            .expect("Expected a search result")
            .best_move
            .expect("Expected a move");

        dbg!(time_info.time.elapsed());

        let will_be_hash = from_fen(FEN_POSSIBLE).unwrap().hash;
        let tt_entry = tt.lookup(will_be_hash);

        assert!(tt_entry.is_some());

        let wont_be_hash = from_fen(FEN_IMPOSSIBLE).unwrap().hash;
        let tt_entry = tt.lookup(wont_be_hash);

        assert!(tt_entry.is_none());

        Ok(())
    }
}