use board::Board; 
use bitboard::*;
use movegen::*;

use std::i32;

///
/// type that is returned by the evaluate funcion
/// 
/// the score value must not exceed 2^23-1 (only 3 bytes), as it
/// will be compressed to 3 bytes in the transposition table
/// 
pub type PosValue = i32;

pub const MIN_VALUE: PosValue = i32::MIN + 1;
pub const MAX_VALUE: PosValue = i32::MAX;

const MATE_VALUE: PosValue = 1i32 << 22;
const MATE_CUTOFF: PosValue = 1i32 << 21;

///
/// evaluation score for a position in which the player to move is checkmated
/// 
pub fn checkmated() -> PosValue {
    -mate_in_p1(0)
}

/// 
/// constructs a PosValue that indicates that from a given position mate
/// can be achieved in plies halfmoves
/// 
pub fn mate_in_p1(plies: i32) -> PosValue {
    if plies < 0 {
        return -mate_in_p1(- plies);
    }
    else {
        return MATE_VALUE - plies;
    }
}

/// 
/// returns Some(turns) if the pos_val indicates that mate
/// can be reached in turns-1 moves
/// 
/// turns is negative if the moving side is getting mated
/// in turns moves
/// 
pub fn is_mate_in_p1(pos_val: PosValue) -> Option<i32> {
    if pos_val > MATE_CUTOFF && pos_val <= MATE_VALUE {
        Some(-pos_val + MATE_VALUE)
    }
    else if pos_val < -MATE_CUTOFF {
        Some(-pos_val - MATE_VALUE)
    }
    else {
        None
    }
}

pub fn increase_mate_in(mut val: PosValue) -> PosValue {
    if let Some(plies) = is_mate_in_p1(val) {
        if plies < 0 {
            val = mate_in_p1(plies - 1);
        }
        if plies > 0 {
            val = mate_in_p1(plies + 1);
        }
        if plies == 0 {
            if val < 0 {
                val = mate_in_p1(-1);
            }
            else {
                val = mate_in_p1(1);
            }
        }
    }
    val
}

pub fn decrease_mate_in(mut val: PosValue) -> PosValue {
    if let Some(plies) = is_mate_in_p1(val) {
        if plies < 0 {
            val = mate_in_p1(plies + 1);
        }
        if plies > 0 {
            val = mate_in_p1(plies - 1);
        }
    }
    val
}



fn side_value(game: &Board, side: Side) -> u32 {
    let adv_pawn_mask = match side { WHITE => ROW_7, BLACK => ROW_2 };
    let semi_adv_pawn_mask = match side { WHITE => ROW_6, BLACK => ROW_3 };
    let advanced_pawns = (game.get_piece(PAWN, side) & adv_pawn_mask).count_ones() * 200;
    let semi_advanced_pawns = (game.get_piece(PAWN, side) & semi_adv_pawn_mask).count_ones() * 50;
    advanced_pawns + semi_advanced_pawns
}

fn pawn_structure(game: &Board, side: Side) -> PosValue {
    let pawns = game.pawns(side);
    let all_own_pieces = game.get_all_side(side);
    let all_pieces = all_own_pieces | game.get_all_side(!side);

    let pawn_protect = if side == WHITE {
            northeast_one(pawns) | northwest_one(pawns)
        }
        else {
            southeast_one(pawns) | southwest_one(pawns)
        };

    let pawn_pushes = if side == WHITE { north_one(pawns) } else { south_one(pawns) };

    let protections = (pawn_protect & all_own_pieces).count_ones();
    let pushable_pawns = (pawn_pushes & !all_pieces).count_ones();

    return (protections * 15 + pushable_pawns * 10) as _;
}

fn knight_value(game: &Board, side: Side) -> PosValue {
    let knights = game.get_piece(KNIGHT, side);
    let ks = BitboardIterator(knights);
    let mut k_attacks: u32 = 0;

    for k in ks {
        let targets = get_knight_targets(square(k));
        k_attacks += targets.count_ones() * 8;
    }

    let num_opp_pawns = game.get_piece(PAWN, !side).count_ones() as PosValue;
    let num_knights = game.get_piece(KNIGHT, side).count_ones() as PosValue;

    let center = (ROW_4 | ROW_5) & (FILE_D | FILE_E);
    let center_knights = (game.get_piece(KNIGHT, side) & center).count_ones() as PosValue;
    
    center_knights * 6 + k_attacks as PosValue + ((num_knights * 75 * num_opp_pawns) / 8) as PosValue
}

pub fn material_value(game: &Board, side: Side) -> PosValue {
    (game.get_piece(PAWN, side).count_ones() * 100
        + game.get_piece(KNIGHT, side).count_ones() * 220
        + game.get_piece(BISHOP, side).count_ones() * 320
        + game.get_piece(ROOK, side).count_ones() * 400
        + game.get_piece(QUEEN, side).count_ones() * 800) as PosValue
}

fn castling_rights(game: &Board, side: Side) -> PosValue {
    let castling_value = 15;

    (if side == WHITE {
        0
        + if game.castling_rights[0] { 1 } else { 0 }
        + if game.castling_rights[1] { 1 } else { 0 }
    }
    else {
        0
        + if game.castling_rights[2] { 1 } else { 0 }
        + if game.castling_rights[3] { 1 } else { 0 }
    }
    * castling_value) as PosValue
}

fn king_safety(game: &Board, side: Side) -> PosValue {
    let king = game.get_piece(KING, side);
    let king_leftright = west_one(king) | king | east_one(king);
    let area = north_one(king_leftright) | king_leftright | south_one(king_leftright);
    
    let guards = game.get_all_side(side) & area;
    let attackers = game.get_all_side(!side) & area;

    let backrow =  if king & ((ROW_1 | ROW_8) & !(FILE_D | FILE_E)) != 0 { 20 } else { 0 };
    let pawn_shield_mask = north_one(king_leftright) | north_one(north_one(king_leftright));
    let pawn_shield = ((pawn_shield_mask & game.pawns(side)).count_ones() * 8) as PosValue;

    let kneighbors = guards.count_ones() as PosValue * 3 - attackers.count_ones() as PosValue * 12;

    let enemies = game.get_all_side(!side);

    if king != 0 {
        let diag_rays = generate_sliding_destinations(king, 0, square(king), false, true);
        let straight_rays = generate_sliding_destinations(0, 0, square(king), true, false); 

        let bishops_in_rays = diag_rays & game.bishops(!side);
        let rooks_in_rays = straight_rays & game.rooks(!side);
        let queens_in_rays = (straight_rays | diag_rays) & game.queens(!side);
        let possible_pin_score = (bishops_in_rays | rooks_in_rays | queens_in_rays).count_ones() as PosValue * -4;
        return kneighbors + possible_pin_score + backrow + pawn_shield;
    }
    else {
        return kneighbors + backrow + pawn_shield;
    }
}

fn king_there(game: &Board, side: Side) -> PosValue {
    if game.get_piece(KING, side) != 0 { 10000 } else { 0 }
}

///
/// The evaluate function of the engine
/// 
pub fn evaluate(game: &Board) -> PosValue {
    let sv = side_value(game, game.turn) as PosValue - side_value(game, !game.turn) as PosValue;
    let material_value_us = material_value(game, game.turn);
    let material_value_them = material_value(game, !game.turn);

    let mat_val = (material_value_us) - (material_value_them) as PosValue;

    let kv = knight_value(game, game.turn) - knight_value(game, !game.turn);
    let king_safety = king_safety(game, game.turn) - king_safety(game, !game.turn);
    let king_there = king_there(game, game.turn) - king_there(game, !game.turn);
    let castling_rights = castling_rights(game, game.turn) - castling_rights(game, !game.turn);

    let pawn_structure = pawn_structure(game, game.turn) - pawn_structure(game, !game.turn);
    let bishop_moves = (bishop_moves(game, game.turn) - bishop_moves(game, !game.turn)) * 3;
    let queen_moves = (queen_moves(game, game.turn) - queen_moves(game, !game.turn)) * 3;

    let mge = sv + kv + king_safety + king_there + castling_rights + pawn_structure + bishop_moves + queen_moves;
    let lge = late_game_eval(game);

    let lateness = game_lateness(game);

    let ge = (mge * (100 - lateness) + lge * lateness) / 100;

    return mat_val + ge + 10 /* turn bonus */;
}

pub fn game_lateness(game: &Board) -> i32 {
    let all_pieces = game.get_all_side(WHITE) | game.get_all_side(BLACK);
    let n_pieces = all_pieces.count_ones() as i32;
    let captured_pieces = 32 - n_pieces;

    if captured_pieces > 15 {
        let lateness = (captured_pieces - 15) * 100 / 10;
        return std::cmp::min(lateness as _, 100);
    }
    return 0;
}

///
/// counts the number of moves the rooks of side can do
/// 
fn rook_moves(game: &Board, side: Side) -> PosValue {
    let rooks = game.rooks(side);
    let rook_moves = count_sliding_move_bitboard(
        game.get_all_side(side),
        game.get_all_side(!side),
        rooks,
        true, false,
        false);
    
    return rook_moves as _;
}

///
/// counts the number of moves the bishops of side can do
/// 
fn bishop_moves(game: &Board, side: Side) -> PosValue {
    let bishops = game.bishops(side);
    let bishop_moves = count_sliding_move_bitboard(
        game.get_all_side(side),
        game.get_all_side(!side),
        bishops,
        false, true,
        false);
    
    return bishop_moves as _;
}

///
/// counts the number of moves the queens of side can do
/// 
fn queen_moves(game: &Board, side: Side) -> PosValue {
    let queens = game.queens(side);
    let queen_moves = count_sliding_move_bitboard(
        game.get_all_side(side),
        game.get_all_side(!side),
        queens,
        true, true,
        false);
    
    return queen_moves as _;
}

pub fn late_game_eval(game: &Board) -> PosValue {
    let pp = pawn_push_value(game, game.turn) - pawn_push_value(game, !game.turn);
    let bp = blocked_pawns(game, game.turn) - blocked_pawns(game, !game.turn);
    let rook_moves = rook_moves(game, game.turn) - rook_moves(game, !game.turn);

    pp + bp + rook_moves * 3
}

pub fn pawn_push_value(game: &Board, side: Side) -> PosValue {
    let val = if side == WHITE {
        (game.get_piece(PAWN, side) & ROW_3).count_ones() * 10
        + (game.get_piece(PAWN, side) & ROW_4).count_ones() * 20
        + (game.get_piece(PAWN, side) & ROW_5).count_ones() * 30
        + (game.get_piece(PAWN, side) & ROW_6).count_ones() * 40
        + (game.get_piece(PAWN, side) & ROW_7).count_ones() * 50
    }
    else {
        (game.get_piece(PAWN, side) & ROW_6).count_ones() * 10
        + (game.get_piece(PAWN, side) & ROW_5).count_ones() * 20
        + (game.get_piece(PAWN, side) & ROW_4).count_ones() * 30
        + (game.get_piece(PAWN, side) & ROW_3).count_ones() * 40
        + (game.get_piece(PAWN, side) & ROW_2).count_ones() * 50
    };
    val as PosValue
}

pub fn blocked_pawns(game: &Board, side: Side) -> PosValue {
    let pawns = game.get_piece(PAWN, side);
    let pushed_pawns = if side == WHITE {
        north_one(pawns)
    } else {
        south_one(pawns)
    };

    let blocked_pawns = pushed_pawns & game.get_all_side(!side);

    blocked_pawns.count_ones() as _
}



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

    #[test]
    fn test_mate_values() {
        let mate_in_three = mate_in_p1(3);
        let mate_in_four = mate_in_p1(4);

        assert!(mate_in_three > mate_in_four);
        assert!(mate_in_three > mate_in_four);
    }
}