use std::time::{Duration, Instant};
use std::env;

use chessnost::board::color::Color;
use chessnost::board::io::IO;
use chessnost::board::Board;
use chessnost::grossmeister::Grossmeister;
use chessnost::player::Player;

fn opponent_move(board: &mut Board) {
    let mov = match board.read_move() {
        Ok(m) => m,
        Err(e) => {
            println!("Error: {}", e);
            return opponent_move(board);
        }
    };
    print!("{:?}", mov);
    board.make_move(mov);
    board.print();
}

fn computer_move(board: &mut Board, gm: &mut Grossmeister, time_left: &mut Duration) {
    let allowed_move_duration = *time_left / 20;
    // let max_depth = 7 + (board.ply as i32 / 15) as u8;
    println!("~{:?} left, allocating {:?} for a move", time_left, allowed_move_duration);

    let move_start = Instant::now();
    let (score, pv) = gm.analyze(*board, allowed_move_duration);
    let elapsed = move_start.elapsed();

    if *time_left >= elapsed {
        *time_left -= elapsed;
    } else {
        println!("You are probably out of time. I will keep going anyway...");
    }

    println!("Finished in {:?}: score={:?}", elapsed, score);

    let mov = pv[0];
    println!("{:?}", mov);
    board.make_move(mov);
    board.print();

    // Ponder for some time
    // println!("Pondering, assume opponent move from PV: {:?}", pv[1]);
    // let ep_target_before = gm.board.ep_target;
    // let castling_rights_before = gm.board.castling_rights;
    // let hash_before = gm.board.hash;
    // let captured_piece = gm.board.make_move(pv[1]);
    // gm.iterative_deepening(max_depth, Duration::from_secs(3), false);
    // gm.board.unmake_move(pv[1], captured_piece, ep_target_before, castling_rights_before, hash_before);
}

fn main() {
    let args: Vec<String> = env::args().collect();
    assert!(args.len() >= 4, "Provide all arguments [COLOR] [TIME_MINUTES] [INCREMENT_SECONDS]");

    let color = match args[1].as_str() {
        "w" => Color::White,
        "b" => Color::Black,
        _ => panic!("Please provide a color [w|b]")
    };

    let mut time_left = Duration::from_secs(60 * match args[2].parse() {
        Ok(x) => x,
        Err(..) => 15
    });

    let increment = Duration::from_secs(match args[3].parse() {
        Ok(x) => x,
        Err(..) => 10
    });
    let manual_decrement = Duration::from_secs(7); // Time to sync moves with the game

    let mut board = if args.len() == 5 {
        Board::from_FEN(args[4].to_string())
    } else {
        Board::new()
    };
    board.print();

    let mut gm = Grossmeister::default();

    loop {
        time_left += increment;
        time_left -= manual_decrement;

        match color {
            Color::White => {
                computer_move(&mut board, &mut gm, &mut time_left);
                opponent_move(&mut board);
            }
            Color::Black => {
                opponent_move(&mut board);
                computer_move(&mut board, &mut gm, &mut time_left);
            }
        }
    }
}