cigogne

-module(cigogne@internal@utils).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/cigogne/internal/utils.gleam").
-export([epoch/0, make_sha256/1, find_compare/3, list_difference/3, find_matches/3, try_or/3, get_results_or_errors/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(false).

-file("src/cigogne/internal/utils.gleam", 8).
?DOC(false).
-spec epoch() -> gleam@time@timestamp:timestamp().
epoch() ->
    Epoch_date = {date, 1970, january, 1},
    Epoch_time = {time_of_day, 0, 0, 0, 0},
    gleam@time@timestamp:from_calendar(Epoch_date, Epoch_time, {duration, 0, 0}).

-file("src/cigogne/internal/utils.gleam", 14).
?DOC(false).
-spec make_sha256(binary()) -> binary().
make_sha256(Content) ->
    _pipe = gleam@crypto:hash(sha256, gleam_stdlib:identity(Content)),
    gleam_stdlib:base16_encode(_pipe).

-file("src/cigogne/internal/utils.gleam", 19).
?DOC(false).
-spec find_compare(list(JKK), JKK, fun((JKK, JKK) -> gleam@order:order())) -> {ok,
        JKK} |
    {error, nil}.
find_compare(List, Element, Compare_fn) ->
    _pipe = List,
    gleam@list:find(_pipe, fun(El) -> Compare_fn(Element, El) =:= eq end).

-file("src/cigogne/internal/utils.gleam", 39).
?DOC(false).
-spec loop_and_find_difference(
    list(JKS),
    list(JKS),
    list(JKS),
    fun((JKS, JKS) -> gleam@order:order())
) -> list(JKS).
loop_and_find_difference(From, Minus, Diff_acc, Compare_fn) ->
    case {From, Minus} of
        {[], _} ->
            _pipe = Diff_acc,
            lists:reverse(_pipe);

        {[First | Rest], []} ->
            loop_and_find_difference(Rest, [], [First | Diff_acc], Compare_fn);

        {[First_from | Rest_from], [First_minus | Rest_minus]} ->
            case Compare_fn(First_from, First_minus) of
                eq ->
                    loop_and_find_difference(
                        Rest_from,
                        Rest_minus,
                        Diff_acc,
                        Compare_fn
                    );

                gt ->
                    loop_and_find_difference(
                        From,
                        Rest_minus,
                        Diff_acc,
                        Compare_fn
                    );

                lt ->
                    loop_and_find_difference(
                        Rest_from,
                        Minus,
                        [First_from | Diff_acc],
                        Compare_fn
                    )
            end
    end.

-file("src/cigogne/internal/utils.gleam", 28).
?DOC(false).
-spec list_difference(
    list(JKO),
    list(JKO),
    fun((JKO, JKO) -> gleam@order:order())
) -> list(JKO).
list_difference(From, Minus, Compare_fn) ->
    Sorted_from = gleam@list:sort(From, Compare_fn),
    Sorted_minus = gleam@list:sort(Minus, Compare_fn),
    loop_and_find_difference(Sorted_from, Sorted_minus, [], Compare_fn).

-file("src/cigogne/internal/utils.gleam", 78).
?DOC(false).
-spec loop_and_find_matches(
    list(JLD),
    list(JLD),
    list({JLD, {ok, JLD} | {error, nil}}),
    fun((JLD, JLD) -> gleam@order:order())
) -> list({JLD, {ok, JLD} | {error, nil}}).
loop_and_find_matches(Elements, Matches, Acc, Compare) ->
    case {Elements, Matches} of
        {[], _} ->
            lists:reverse(Acc);

        {[First | Rest], []} ->
            loop_and_find_matches(
                Rest,
                [],
                [{First, {error, nil}} | Acc],
                Compare
            );

        {[First_el | Rest_el], [First_match | Rest_matches]} ->
            case Compare(First_el, First_match) of
                eq ->
                    loop_and_find_matches(
                        Rest_el,
                        Rest_matches,
                        [{First_el, {ok, First_match}} | Acc],
                        Compare
                    );

                gt ->
                    loop_and_find_matches(Elements, Rest_matches, Acc, Compare);

                lt ->
                    loop_and_find_matches(
                        Rest_el,
                        Matches,
                        [{First_el, {error, nil}} | Acc],
                        Compare
                    )
            end
    end.

-file("src/cigogne/internal/utils.gleam", 67).
?DOC(false).
-spec find_matches(list(JKX), list(JKX), fun((JKX, JKX) -> gleam@order:order())) -> list({JKX,
    {ok, JKX} | {error, nil}}).
find_matches(Elements, Matches, Compare_fn) ->
    Sorted_elements = gleam@list:sort(Elements, Compare_fn),
    Sorted_matches = gleam@list:sort(Matches, Compare_fn),
    loop_and_find_matches(Sorted_elements, Sorted_matches, [], Compare_fn).

-file("src/cigogne/internal/utils.gleam", 110).
?DOC(false).
-spec try_or(
    {ok, JLK} | {error, any()},
    JLO,
    fun((JLK) -> {ok, JLP} | {error, JLO})
) -> {ok, JLP} | {error, JLO}.
try_or(Result, Or, Callback) ->
    case Result of
        {ok, V} ->
            Callback(V);

        {error, _} ->
            {error, Or}
    end.

-file("src/cigogne/internal/utils.gleam", 127).
?DOC(false).
-spec do_get_results_or_errors(
    list({ok, JMD} | {error, JME}),
    {ok, list(JMD)} | {error, list(JME)}
) -> {ok, list(JMD)} | {error, list(JME)}.
do_get_results_or_errors(Results, Result_so_far) ->
    case {Results, Result_so_far} of
        {[], {error, Errs}} ->
            {error,
                begin
                    _pipe = Errs,
                    lists:reverse(_pipe)
                end};

        {[], {ok, Vals}} ->
            {ok,
                begin
                    _pipe@1 = Vals,
                    lists:reverse(_pipe@1)
                end};

        {[{error, Err} | Rest], {ok, _}} ->
            do_get_results_or_errors(Rest, {error, [Err]});

        {[{error, Err@1} | Rest@1], {error, Errs@1}} ->
            do_get_results_or_errors(Rest@1, {error, [Err@1 | Errs@1]});

        {[{ok, Val} | Rest@2], {ok, Vals@1}} ->
            do_get_results_or_errors(Rest@2, {ok, [Val | Vals@1]});

        {[{ok, _} | Rest@3], {error, Errs@2}} ->
            do_get_results_or_errors(Rest@3, {error, Errs@2})
    end.

-file("src/cigogne/internal/utils.gleam", 121).
?DOC(false).
-spec get_results_or_errors(list({ok, JLU} | {error, JLV})) -> {ok, list(JLU)} |
    {error, list(JLV)}.
get_results_or_errors(Results) ->
    do_get_results_or_errors(Results, {ok, []}).