prng

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

-export([step/2, sample/2, to_iterator/2, to_random_iterator/1, random_sample/1, int/2, 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 sample(generator(FEO), prng@seed:seed()) -> FEO.
sample(Generator, Seed) ->
    erlang:element(1, step(Generator, Seed)).

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

-spec to_random_iterator(generator(FES)) -> gleam@iterator:iterator(FES).
to_random_iterator(Generator) ->
    to_iterator(Generator, prng@seed:random()).

-spec random_sample(generator(FEQ)) -> FEQ.
random_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 => <<"random_sample"/utf8>>,
                        line => 178})
    end,
    Result.

-spec sort_ascending(FEZ, FEZ, fun((FEZ, FEZ) -> gleam@order:order())) -> {FEZ,
    FEZ}.
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 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(FFB) -> generator(FFB).
constant(Value) ->
    {generator, fun(Seed) -> {Value, Seed} end}.

-spec get_by_weight({float(), FFT}, list({float(), FFT}), float()) -> FFT.
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(FGG), prng@seed:seed(), generator(FGG), integer()) -> {list(FGG),
    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(FGC), integer()) -> generator(list(FGC)).
list(Generator, Length) ->
    {generator, fun(Seed) -> do_list([], Seed, Generator, Length) end}.

-spec then(generator(FGK), fun((FGK) -> generator(FGM))) -> generator(FGM).
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(FGP), fun((FGP) -> FGR)) -> generator(FGR).
map(Generator, Fun) ->
    {generator,
        fun(Seed) ->
            {Value, Seed@1} = step(Generator, Seed),
            {Fun(Value), Seed@1}
        end}.

-spec weighted({float(), FFL}, list({float(), FFL})) -> generator(FFL).
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(), FFO})) -> {ok, generator(FFO)} | {error, nil}.
try_weighted(Options) ->
    case Options of
        [First | Rest] ->
            {ok, weighted(First, Rest)};

        [] ->
            {error, nil}
    end.

-spec map2(generator(FGT), generator(FGV), fun((FGT, FGV) -> FGX)) -> generator(FGX).
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(FFX), generator(FFZ)) -> generator({FFX, FFZ}).
pair(One, Other) ->
    map2(One, Other, fun gleam@pair:new/2).

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

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

        [] ->
            {error, nil}
    end.

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

-spec map3(
    generator(FGZ),
    generator(FHB),
    generator(FHD),
    fun((FGZ, FHB, FHD) -> FHF)
) -> generator(FHF).
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(FHH),
    generator(FHJ),
    generator(FHL),
    generator(FHN),
    fun((FHH, FHJ, FHL, FHN) -> FHP)
) -> generator(FHP).
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(FHR),
    generator(FHT),
    generator(FHV),
    generator(FHX),
    generator(FHZ),
    fun((FHR, FHT, FHV, FHX, FHZ) -> FIB)
) -> generator(FIB).
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}.