usingnamespace @import("attack.zig");

const std = @import("std");
const expectEqual = std.testing.expectEqual;

test "white pawn attacks two squares in front" {
    const side = Side.White;
    const pawn = Square.e2;
    const expected_attacked_squares = [2]Square{ Square.d3, Square.f3 };
    const expected = bitboardFromSquares(expected_attacked_squares[0..]);
    const actual = pawnAttacks(side, pawn);
    expectEqual(expected, actual);
}

test "black pawn attacks two squares in front" {
    const side = Side.Black;
    const pawn = Square.c7;
    const expected_attacked_squares = [2]Square{ Square.b6, Square.d6 };
    const expected = bitboardFromSquares(expected_attacked_squares[0..]);
    const actual = pawnAttacks(side, pawn);
    expectEqual(expected, actual);
}

test "white pawn on a file attacks only one square" {
    const side = Side.White;
    const pawn = Square.a4;
    const expected = bitboardFromSquare(Square.b5);
    const actual = pawnAttacks(side, pawn);
    expectEqual(expected, actual);
}

test "white pawn on h file attacks only one square" {
    const side = Side.White;
    const pawn = Square.h7;
    const expected = bitboardFromSquare(Square.g8);
    const actual = pawnAttacks(side, pawn);
    expectEqual(expected, actual);
}

test "black pawn on a file attacks only one square" {
    const side = Side.Black;
    const pawn = Square.a8;
    const expected = bitboardFromSquare(Square.b7);
    const actual = pawnAttacks(side, pawn);
    expectEqual(expected, actual);
}

test "white pawn on 8th rank attacks nothing" {
    const side = Side.White;
    const pawn = Square.f8;
    const expected = @as(u64, 0);
    const actual = pawnAttacks(side, pawn);
    expectEqual(expected, actual);
}

test "black pawn on 1st rank attacks nothing" {
    const side = Side.Black;
    const pawn = Square.g1;
    const expected = @as(u64, 0);
    const actual = pawnAttacks(side, pawn);
    expectEqual(expected, actual);
}

test "knight in center attacks all 8 squares" {
    const knight = Square.e4;
    const expected_attacked_squares = [8]Square{
        Square.f6,
        Square.g5,
        Square.g3,
        Square.f2,
        Square.d2,
        Square.c3,
        Square.c5,
        Square.d6,
    };
    const expected = bitboardFromSquares(expected_attacked_squares[0..]);
    const actual = knightAttacks(knight);
    expectEqual(expected, actual);
}

test "knights in corners attack only 2 squares" {
    const knight_a8 = Square.a8;
    const knight_h8 = Square.h8;
    const knight_h1 = Square.h1;
    const knight_a1 = Square.a1;

    const expected_a8 = [2]Square{ Square.c7, Square.b6 };
    const expected_h8 = [2]Square{ Square.g6, Square.f7 };
    const expected_h1 = [2]Square{ Square.f2, Square.g3 };
    const expected_a1 = [2]Square{ Square.b3, Square.c2 };

    expectEqual(bitboardFromSquares(expected_a8[0..]), knightAttacks(knight_a8));
    expectEqual(bitboardFromSquares(expected_h8[0..]), knightAttacks(knight_h8));
    expectEqual(bitboardFromSquares(expected_h1[0..]), knightAttacks(knight_h1));
    expectEqual(bitboardFromSquares(expected_a1[0..]), knightAttacks(knight_a1));
}

test "king in center attacks all 8 squares" {
    const king = Square.d4;
    const expected_attacked_squares = [8]Square{
        Square.d5,
        Square.e5,
        Square.e4,
        Square.e3,
        Square.d3,
        Square.c3,
        Square.c4,
        Square.c5,
    };
    const expected = bitboardFromSquares(expected_attacked_squares[0..]);
    const actual = kingAttacks(king);
    expectEqual(expected, actual);
}

test "kings in corners attack only 3 squares" {
    const king_a8 = Square.a8;
    const king_h8 = Square.h8;
    const king_h1 = Square.h1;
    const king_a1 = Square.a1;

    const expected_a8 = [3]Square{ Square.b8, Square.b7, Square.a7 };
    const expected_h8 = [3]Square{ Square.h7, Square.g7, Square.g8 };
    const expected_h1 = [3]Square{ Square.g1, Square.g2, Square.h2 };
    const expected_a1 = [3]Square{ Square.a2, Square.b2, Square.b1 };

    expectEqual(bitboardFromSquares(expected_a8[0..]), kingAttacks(king_a8));
    expectEqual(bitboardFromSquares(expected_h8[0..]), kingAttacks(king_h8));
    expectEqual(bitboardFromSquares(expected_h1[0..]), kingAttacks(king_h1));
    expectEqual(bitboardFromSquares(expected_a1[0..]), kingAttacks(king_a1));
}

test "bishop in centre occupancy bits" {
    const bishop = Square.e4;

    const expected_squares = [_]Square{
        Square.f5,
        Square.g6,
        Square.f3,
        Square.g2,
        Square.d3,
        Square.c2,
        Square.d5,
        Square.c6,
        Square.b7,
    };

    expectEqual(bitboardFromSquares(expected_squares[0..]), maskBishopOccupancy(bishop));
}

test "bishop at side occupancy bits" {
    const bishop = Square.h6;

    const expected_squares = [_]Square{
        Square.g5,
        Square.f4,
        Square.e3,
        Square.d2,
        Square.g7,
    };

    expectEqual(bitboardFromSquares(expected_squares[0..]), maskBishopOccupancy(bishop));
}