path: root/src/grossmeister/UCI.rs

use std::{
    io::stdin,
    str::Split,
    sync::{
        atomic::{AtomicBool, Ordering},
        Arc,
    },
    thread::{sleep, spawn, JoinHandle},
    time::Duration,
};

use crate::{
    board::{color::Color, io::IO, Board},
    moves::{Move, MoveKind},
};

use super::Grossmeister;

const NAME: &str = "Chessnost";
const AUTHOR: &str = "Eugene Sokolov";

impl Grossmeister {
    pub fn start(&mut self) {
        let mut search_handle: Option<JoinHandle<Self>> = None;

        loop {
            let mut cmd = String::new();
            stdin().read_line(&mut cmd).unwrap();
            if !self.parse_command(cmd, &mut search_handle) {
                break;
            }
        }
    }

    pub fn parse_command(
        &mut self,
        cmd: String,
        search_handle: &mut Option<JoinHandle<Self>>,
    ) -> bool {
        let mut tokens = cmd.trim().split(' ');
        if let Some(token) = tokens.next() {
            match token {
                "uci" => {
                    println!("id name {}", NAME);
                    println!("id author {}", AUTHOR);
                    println!("uciok");
                }
                "debug" => {
                    if let Some(token) = tokens.next() {
                        match token {
                            "on" => self.debug = true,
                            "off" => self.debug = false,
                            _ => panic!("Wrong option to debug: {}", token),
                        }
                    };
                }
                "isready" => {
                    println!("readyok");
                }
                "setoption" => {
                    todo!()
                }
                "ucinewgame" => *self = Self::default(),
                "position" => {
                    match tokens.next() {
                        Some("startpos") => {
                            self.board = Board::new();
                        }
                        Some("fen") => {
                            let fen = (0..6)
                                .filter_map(|_| tokens.next())
                                .collect::<Vec<_>>()
                                .join(" ");
                            self.board = Board::from_FEN(fen);
                        }
                        _ => panic!("Expected position"),
                    }
                    if let Some("moves") = tokens.next() {
                        for token in tokens.by_ref() {
                            let input_move = Move::from_notation(token.chars());
                            let moves = self.board.generate_pseudolegal_moves();
                            if let Some(mov) = moves.iter().find(|m| {
                                let promo_matches = match input_move.kind {
                                    MoveKind::Promotion(piece) => match m.kind {
                                        MoveKind::Promotion(another_piece) => {
                                            piece.without_color() == another_piece.without_color()
                                        }
                                        _ => false,
                                    },
                                    _ => true,
                                };
                                promo_matches
                                    && m.source == input_move.source
                                    && m.target == input_move.target
                            }) {
                                self.board.make_move(*mov);
                                let repeated = self
                                    .board
                                    .positions
                                    .iter()
                                    .filter(|&&p| p == self.board.hash)
                                    .count();
                                if self.board.hash == 13465997660506371065 {
                                    self.board.print();
                                    dbg!(mov, repeated, self.board.hash, self.board.ply);
                                }
                            } else {
                                panic!("Illegal move: {}", input_move);
                            }
                        }
                    }
                }
                "go" => {
                    // Before we go, let's join to the latest search
                    if let Some(hand) = search_handle.take() {
                        match hand.join() {
                            Ok(better_self) => {
                                self.transposition_table = better_self.transposition_table
                            }
                            Err(err) => println!("info string error {:?}", err),
                        }
                    }

                    *search_handle = Some(self.parse_go(tokens, false));
                }
                "stop" => {
                    self.should_halt
                        .store(true, std::sync::atomic::Ordering::SeqCst);
                }
                "ponderhit" => {
                    // Since we were pondering without any scheduled halting previously,
                    // in case of ponderhit we need to schedule a new halting based on clock
                    // TODO: isn't the color flipped here? Might lead to time management bugs
                    let color = self.board.color();
                    let duration = (self.board.clock.time[color as usize]
                        + self.board.clock.increment[color as usize])
                        / 20;
                    let halt_scheduled = self.schedule_halt(duration);

                    // Join to the current pondering search
                    if let Some(hand) = search_handle.take() {
                        match hand.join() {
                            Ok(better_self) => {
                                self.transposition_table = better_self.transposition_table
                            }
                            Err(err) => println!("info string error {:?}", err),
                        }
                        halt_scheduled.store(false, Ordering::SeqCst); // Cancel scheduled halting
                    } else {
                        panic!("Search thread not found!");
                    }
                }
                "quit" => return false,
                // Non-UCI debug commands
                "print" => self.board.print(),
                _ => {}
            }
        }
        true
    }

    fn parse_go(&mut self, mut tokens: Split<char>, ponder: bool) -> JoinHandle<Self> {
        if let Some(token) = tokens.next() {
            match token {
                "searchmoves" => todo!(),
                "ponder" => {
                    println!("info will start in pondering mode");
                    return self.parse_go(tokens, true);
                }
                "wtime" => {
                    if let Some(time) = tokens.next() {
                        let time: u64 = time.parse().unwrap();
                        self.board.clock.time[Color::White as usize] = Duration::from_millis(time);
                    }
                }
                "btime" => {
                    if let Some(time) = tokens.next() {
                        let time: u64 = time.parse().unwrap();
                        self.board.clock.time[Color::Black as usize] = Duration::from_millis(time);
                    }
                }
                "winc" => {
                    if let Some(time) = tokens.next() {
                        let time: u64 = time.parse().unwrap();
                        self.board.clock.increment[Color::White as usize] =
                            Duration::from_millis(time);
                    }
                }
                "binc" => {
                    if let Some(time) = tokens.next() {
                        let time: u64 = time.parse().unwrap();
                        self.board.clock.increment[Color::Black as usize] =
                            Duration::from_millis(time);
                    }
                }
                "movestogo" => {}
                "depth" => {
                    if let Some(depth) = tokens.next() {
                        let depth: u8 = depth.parse().unwrap();
                        return self.create_search_thread(depth, Duration::MAX);
                    }
                }
                "nodes" => todo!(),
                "mate" => todo!(),
                "movetime" => {
                    if let Some(time) = tokens.next() {
                        let time: u64 = time.parse().unwrap();
                        let duration = Duration::from_millis(time);

                        return self.create_search_thread(u8::MAX, duration);
                    }
                }
                "infinite" => {
                    return self.create_search_thread(u8::MAX, Duration::MAX);
                }
                _ => {}
            }
            return self.parse_go(tokens, ponder);
        }

        let color = self.board.color();

        let duration = if ponder {
            Duration::MAX
        } else {
            (self.board.clock.time[color as usize] + self.board.clock.increment[color as usize])
                / 20
        };

        self.create_search_thread(u8::MAX, duration)
    }

    fn schedule_halt(&self, duration: Duration) -> Arc<AtomicBool> {
        let halt_scheduled = Arc::new(AtomicBool::new(false));

        if duration < Duration::MAX {
            halt_scheduled.store(true, Ordering::SeqCst);
            let should_halt = self.should_halt.clone();

            // Create a thread that will terminate search when the duration is expired
            let halt_scheduled = halt_scheduled.clone();
            spawn(move || {
                println!("info string terminating search in {:?}", duration);
                sleep(duration);
                // Make sure schedule is not cancelled externally
                if halt_scheduled.load(Ordering::SeqCst) {
                    should_halt.store(true, Ordering::SeqCst);
                }
            });
        }

        halt_scheduled
    }

    fn create_search_thread(&self, depth: u8, duration: Duration) -> JoinHandle<Self> {
        // Make sure we don't halt right away
        self.should_halt.store(false, Ordering::SeqCst);

        let halt_scheduled = self.schedule_halt(duration);

        // Clone current self and move it into thread to analyze a position
        let mut gm = self.clone();
        spawn(move || {
            gm.iterative_deepening(depth);
            halt_scheduled.store(false, Ordering::SeqCst); // Cancel the scheduled halting
            gm // Return better version of Self
        })
    }
}