gchess

-module(bitboard).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([new_bitboard/1, empty_bitboard/0, full_bitboard/0, 'and'/2, exclusive_or/2, 'or'/2, 'not'/1, shift_left/2, shift_right/2, bitscan_forward_inner/2, bitscan_forward/1, bitscan_backward_inner/2, bitscan_backward/1]).

-spec new_bitboard(integer()) -> integer().
new_bitboard(Bitboard) ->
    Bitboard.

-spec empty_bitboard() -> integer().
empty_bitboard() ->
    0.

-spec full_bitboard() -> integer().
full_bitboard() ->
    16#ffffffffffffffff.

-spec 'and'(integer(), integer()) -> integer().
'and'(Bitboard1, Bitboard2) ->
    erlang:'band'(Bitboard1, Bitboard2).

-spec exclusive_or(integer(), integer()) -> integer().
exclusive_or(Bitboard1, Bitboard2) ->
    erlang:'bxor'(Bitboard1, Bitboard2).

-spec 'or'(integer(), integer()) -> integer().
'or'(Bitboard1, Bitboard2) ->
    erlang:'bor'(Bitboard1, Bitboard2).

-spec 'not'(integer()) -> integer().
'not'(Bitboard) ->
    erlang:'bnot'(Bitboard).

-spec shift_left(integer(), integer()) -> integer().
shift_left(Bitboard, Shift) ->
    erlang:'bsl'(Bitboard, Shift).

-spec shift_right(integer(), integer()) -> integer().
shift_right(Bitboard, Shift) ->
    erlang:'bsr'(Bitboard, Shift).

-spec bitscan_forward_inner(integer(), integer()) -> integer().
bitscan_forward_inner(Bitboard, Index) ->
    case (Bitboard =:= 0) orelse (Index > 63) of
        true ->
            -1;

        false ->
            Lsb_digit = 2#0000000000000000000000000000000000000000000000000000000000000001,
            First_digit_bitboard = 'and'(Bitboard, new_bitboard(Lsb_digit)),
            case First_digit_bitboard of
                0 ->
                    bitscan_forward_inner(shift_right(Bitboard, 1), Index + 1);

                _ ->
                    Index
            end
    end.

-spec bitscan_forward(integer()) -> integer().
bitscan_forward(Bitboard) ->
    bitscan_forward_inner(Bitboard, 0).

-spec bitscan_backward_inner(integer(), integer()) -> integer().
bitscan_backward_inner(Bitboard, Index) ->
    case (Bitboard =:= 0) orelse (Index < 0) of
        true ->
            -1;

        false ->
            Msb_digit = 2#1000000000000000000000000000000000000000000000000000000000000000,
            First_digit_bitboard = 'and'(Bitboard, new_bitboard(Msb_digit)),
            case First_digit_bitboard of
                0 ->
                    bitscan_backward_inner(shift_left(Bitboard, 1), Index - 1);

                _ ->
                    Index
            end
    end.

-spec bitscan_backward(integer()) -> integer().
bitscan_backward(Bitboard) ->
    bitscan_backward_inner(Bitboard, 63).