prng

-module(prng@random).
-compile([no_auto_import, nowarn_unused_vars]).

-export([step/2, to_iterator/2, int/2, to_random_iterator/1, sample/1, float/2, constant/1, list/2, then/2, map/2, weighted/2, try_weighted/1, map2/3, pair/2, uniform/2, try_uniform/1, choose/2, map3/4, map4/5, map5/6]).
-export_type([generator/1]).

-opaque generator(FEL) :: {generator,
        fun((prng@seed:seed()) -> {FEL, prng@seed:seed()})}.

-spec step(generator(FEM), prng@seed:seed()) -> {FEM, prng@seed:seed()}.
step(Generator, Seed) ->
    (erlang:element(2, Generator))(Seed).

-spec to_iterator(generator(FET), prng@seed:seed()) -> gleam@iterator:iterator(FET).
to_iterator(Generator, Seed) ->
    gleam@iterator:unfold(
        Seed,
        fun(Seed@1) ->
            {Value, New_seed} = step(Generator, Seed@1),
            {next, Value, New_seed}
        end
    ).

-spec sort_ascending(FEX, FEX, fun((FEX, FEX) -> gleam@order:order())) -> {FEX,
    FEX}.
sort_ascending(One, Other, Compare) ->
    case Compare(One, Other) of
        lt ->
            {One, Other};

        eq ->
            {One, Other};

        gt ->
            {Other, One}
    end.

-spec int(integer(), integer()) -> generator(integer()).
int(From, To) ->
    {generator,
        fun(Seed) ->
            {Low, High} = sort_ascending(From, To, fun gleam@int:compare/2),
            ffi:random_int(Seed, Low, High)
        end}.

-spec to_random_iterator(generator(FEQ)) -> gleam@iterator:iterator(FEQ).
to_random_iterator(Generator) ->
    to_iterator(Generator, ffi:new_seed(gleam@int:random(0, 4294967296))).

-spec sample(generator(FEO)) -> FEO.
sample(Generator) ->
    _assert_subject = gleam@iterator:first(to_random_iterator(Generator)),
    {ok, Result} = case _assert_subject of
        {ok, _} -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"prng/random"/utf8>>,
                        function => <<"sample"/utf8>>,
                        line => 141})
    end,
    Result.

-spec float(float(), float()) -> generator(float()).
float(From, To) ->
    {generator,
        fun(Seed) ->
            {Low, High} = sort_ascending(From, To, fun gleam@float:compare/2),
            ffi:random_float(Seed, Low, High)
        end}.

-spec constant(FEZ) -> generator(FEZ).
constant(Value) ->
    {generator, fun(Seed) -> {Value, Seed} end}.

-spec get_by_weight({float(), FFR}, list({float(), FFR}), float()) -> FFR.
get_by_weight(First, Others, Countdown) ->
    {Weight, Value} = First,
    case Others of
        [] ->
            Value;

        [Second | Rest] ->
            Positive_weight = gleam@float:absolute_value(Weight),
            case gleam@float:compare(Countdown, Positive_weight) of
                lt ->
                    Value;

                eq ->
                    Value;

                gt ->
                    get_by_weight(Second, Rest, Countdown - Positive_weight)
            end
    end.

-spec do_list(list(FGE), prng@seed:seed(), generator(FGE), integer()) -> {list(FGE),
    prng@seed:seed()}.
do_list(Acc, Seed, Generator, Length) ->
    case Length =< 0 of
        true ->
            {Acc, Seed};

        false ->
            {Value, Seed@1} = step(Generator, Seed),
            do_list([Value | Acc], Seed@1, Generator, Length - 1)
    end.

-spec list(generator(FGA), integer()) -> generator(list(FGA)).
list(Generator, Length) ->
    {generator, fun(Seed) -> do_list([], Seed, Generator, Length) end}.

-spec then(generator(FGI), fun((FGI) -> generator(FGK))) -> generator(FGK).
then(Generator, Generator_from) ->
    {generator,
        fun(Seed) ->
            {Value, Seed@1} = step(Generator, Seed),
            _pipe = Generator_from(Value),
            step(_pipe, Seed@1)
        end}.

-spec map(generator(FGN), fun((FGN) -> FGP)) -> generator(FGP).
map(Generator, Fun) ->
    {generator,
        fun(Seed) ->
            {Value, Seed@1} = step(Generator, Seed),
            {Fun(Value), Seed@1}
        end}.

-spec weighted({float(), FFJ}, list({float(), FFJ})) -> generator(FFJ).
weighted(First, Others) ->
    Normalise = fun(Pair) ->
        gleam@float:absolute_value(gleam@pair:first(Pair))
    end,
    Total = Normalise(First) + gleam@float:sum(
        gleam@list:map(Others, Normalise)
    ),
    map(
        float(0.0, Total),
        fun(_capture) -> get_by_weight(First, Others, _capture) end
    ).

-spec try_weighted(list({float(), FFM})) -> {ok, generator(FFM)} | {error, nil}.
try_weighted(Options) ->
    case Options of
        [First | Rest] ->
            {ok, weighted(First, Rest)};

        [] ->
            {error, nil}
    end.

-spec map2(generator(FGR), generator(FGT), fun((FGR, FGT) -> FGV)) -> generator(FGV).
map2(One, Other, Fun) ->
    {generator,
        fun(Seed) ->
            {A, Seed@1} = step(One, Seed),
            {B, Seed@2} = step(Other, Seed@1),
            {Fun(A, B), Seed@2}
        end}.

-spec pair(generator(FFV), generator(FFX)) -> generator({FFV, FFX}).
pair(One, Other) ->
    map2(One, Other, fun gleam@pair:new/2).

-spec uniform(FFB, list(FFB)) -> generator(FFB).
uniform(First, Others) ->
    weighted(
        {1.0, First},
        gleam@list:map(
            Others,
            fun(_capture) -> gleam@pair:new(1.0, _capture) end
        )
    ).

-spec try_uniform(list(FFE)) -> {ok, generator(FFE)} | {error, nil}.
try_uniform(Options) ->
    case Options of
        [First | Rest] ->
            {ok, uniform(First, Rest)};

        [] ->
            {error, nil}
    end.

-spec choose(FFT, FFT) -> generator(FFT).
choose(One, Other) ->
    uniform(One, [Other]).

-spec map3(
    generator(FGX),
    generator(FGZ),
    generator(FHB),
    fun((FGX, FGZ, FHB) -> FHD)
) -> generator(FHD).
map3(One, Two, Three, Fun) ->
    {generator,
        fun(Seed) ->
            {A, Seed@1} = step(One, Seed),
            {B, Seed@2} = step(Two, Seed@1),
            {C, Seed@3} = step(Three, Seed@2),
            {Fun(A, B, C), Seed@3}
        end}.

-spec map4(
    generator(FHF),
    generator(FHH),
    generator(FHJ),
    generator(FHL),
    fun((FHF, FHH, FHJ, FHL) -> FHN)
) -> generator(FHN).
map4(One, Two, Three, Four, Fun) ->
    {generator,
        fun(Seed) ->
            {A, Seed@1} = step(One, Seed),
            {B, Seed@2} = step(Two, Seed@1),
            {C, Seed@3} = step(Three, Seed@2),
            {D, Seed@4} = step(Four, Seed@3),
            {Fun(A, B, C, D), Seed@4}
        end}.

-spec map5(
    generator(FHP),
    generator(FHR),
    generator(FHT),
    generator(FHV),
    generator(FHX),
    fun((FHP, FHR, FHT, FHV, FHX) -> FHZ)
) -> generator(FHZ).
map5(One, Two, Three, Four, Five, Fun) ->
    {generator,
        fun(Seed) ->
            {A, Seed@1} = step(One, Seed),
            {B, Seed@2} = step(Two, Seed@1),
            {C, Seed@3} = step(Three, Seed@2),
            {D, Seed@4} = step(Four, Seed@3),
            {E, Seed@5} = step(Five, Seed@4),
            {Fun(A, B, C, D, E), Seed@5}
        end}.