gleam_stats

-module(gleam_stats@random).
-compile(no_auto_import).

-export([shuffle/2, bools/2]).

-spec shuffle(list(FBD), gleam@iterator:iterator(integer())) -> {list(FBD),
                                                                 gleam@iterator:iterator(integer())}.
shuffle(List, Stream) ->
    Length = gleam@list:length(List),
    {ok, Out@1} = case gleam_stats@distributions@bernoulli:bernoulli_random(
        Stream,
        0.5,
        Length
    ) of
        {ok, Out} -> {ok, Out};
        _try ->
            erlang:error(#{gleam_error => assert,
                           message => <<"Assertion pattern match failed"/utf8>>,
                           value => _try,
                           module => <<"gleam_stats/random"/utf8>>,
                           function => <<"shuffle"/utf8>>,
                           line => 50})
    end,
    Shuffled_list = do_shuffle(List, Length, gleam@pair:first(Out@1)),
    {Shuffled_list, gleam@pair:second(Out@1)}.

-spec shuffle_list(list(FBI), list(FBI), list(integer())) -> list(FBI).
shuffle_list(A, B, C) ->
    case {A, B, C} of
        {[], _@1, _@2} ->
            B;

        {_@3, [], _@4} ->
            A;

        {[Ax | Ar], [Bx | Br], [Cx | Cr]} ->
            case Cx of
                1 ->
                    [Ax | shuffle_list(Ar, B, Cr)];

                0 ->
                    [Bx | shuffle_list(A, Br, Cr)]
            end
    end.

-spec do_shuffle(list(FBN), integer(), list(integer())) -> list(FBN).
do_shuffle(List, List_length, C) ->
    case List_length < 2 of
        true ->
            List;

        false ->
            Split_length = List_length div 2,
            A_list = gleam@list:take(List, Split_length),
            B_list = gleam@list:drop(List, Split_length),
            C1_list = gleam@list:take(C, Split_length),
            C2_list = gleam@list:drop(C, Split_length),
            shuffle_list(
                do_shuffle(A_list, Split_length, C1_list),
                do_shuffle(B_list, List_length - Split_length, C2_list),
                C
            )
    end.

-spec bools(integer(), gleam@iterator:iterator(integer())) -> {ok,
                                                               {list(boolean()),
                                                                gleam@iterator:iterator(integer())}} |
    {error, binary()}.
bools(M, Stream) ->
    case M > 0 of
        false ->
            _pipe = <<"Invalid input arugment: m < 0. Valid input is m > 0."/utf8>>,
            {error, _pipe};

        true ->
            {ok, Out@1} = case gleam_stats@distributions@uniform:uniform_random(
                Stream,
                0.0,
                1.0,
                M
            ) of
                {ok, Out} -> {ok, Out};
                _try ->
                    erlang:error(#{gleam_error => assert,
                                   message => <<"Assertion pattern match failed"/utf8>>,
                                   value => _try,
                                   module => <<"gleam_stats/random"/utf8>>,
                                   function => <<"bools"/utf8>>,
                                   line => 125})
            end,
            Bools_list = begin
                _pipe@1 = gleam@pair:first(Out@1),
                gleam@list:map(_pipe@1, fun(X) -> case X =< 0.5 of
                            true ->
                                true;

                            false ->
                                false
                        end end)
            end,
            _pipe@2 = {Bools_list, gleam@pair:second(Out@1)},
            {ok, _pipe@2}
    end.