cigogne

-module(cigogne@internal@utils).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-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, try_map_index/2]).

-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(JPR), JPR, fun((JPR, JPR) -> gleam@order:order())) -> {ok,
        JPR} |
    {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(JPZ),
    list(JPZ),
    list(JPZ),
    fun((JPZ, JPZ) -> gleam@order:order())
) -> list(JPZ).
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(JPV),
    list(JPV),
    fun((JPV, JPV) -> gleam@order:order())
) -> list(JPV).
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(JQK),
    list(JQK),
    list({JQK, {ok, JQK} | {error, nil}}),
    fun((JQK, JQK) -> gleam@order:order())
) -> list({JQK, {ok, JQK} | {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(JQE), list(JQE), fun((JQE, JQE) -> gleam@order:order())) -> list({JQE,
    {ok, JQE} | {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, JQR} | {error, any()},
    JQV,
    fun((JQR) -> {ok, JQW} | {error, JQV})
) -> {ok, JQW} | {error, JQV}.
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, JRK} | {error, JRL}),
    {ok, list(JRK)} | {error, list(JRL)}
) -> {ok, list(JRK)} | {error, list(JRL)}.
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, JRB} | {error, JRC})) -> {ok, list(JRB)} |
    {error, list(JRC)}.
get_results_or_errors(Results) ->
    do_get_results_or_errors(Results, {ok, []}).

-file("src/cigogne/internal/utils.gleam", 152).
?DOC(false).
-spec do_try_map_index(
    list(JSG),
    fun((JSG, integer()) -> {ok, JSI} | {error, JSJ}),
    integer(),
    list(JSI)
) -> {ok, list(JSI)} | {error, JSJ}.
do_try_map_index(List, F, Index, Result_so_far) ->
    case List of
        [] ->
            _pipe = Result_so_far,
            _pipe@1 = lists:reverse(_pipe),
            {ok, _pipe@1};

        [First | Rest] ->
            case F(First, Index) of
                {ok, Mapped} ->
                    do_try_map_index(
                        Rest,
                        F,
                        Index + 1,
                        [Mapped | Result_so_far]
                    );

                {error, Err} ->
                    {error, Err}
            end
    end.

-file("src/cigogne/internal/utils.gleam", 145).
?DOC(false).
-spec try_map_index(
    list(JRX),
    fun((JRX, integer()) -> {ok, JRZ} | {error, JSA})
) -> {ok, list(JRZ)} | {error, JSA}.
try_map_index(List, F) ->
    do_try_map_index(List, F, 0, []).