sprocket

-module(sprocket@internal@utils@ordered_map).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/sprocket/internal/utils/ordered_map.gleam").
-export([new/0, from/3, from_list/1, insert/3, update/3, has_key/2, get/2, remove/2, size/1, iter/1, next/1, fold/3, map/2, index_map/2, find_next/2, find_previous/2, find/2]).
-export_type([keyed_item/2, ordered_map/2, ordered_map_iter/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).

-type keyed_item(FMR, FMS) :: {keyed_item, FMR, FMS}.

-opaque ordered_map(FMT, FMU) :: {ordered_map,
        list(keyed_item(FMT, FMU)),
        gleam@dict:dict(FMT, FMU),
        integer()}.

-opaque ordered_map_iter(FMV, FMW) :: {ordered_map_iter,
        list(keyed_item(FMV, FMW))}.

-file("src/sprocket/internal/utils/ordered_map.gleam", 16).
?DOC(false).
-spec new() -> ordered_map(any(), any()).
new() ->
    {ordered_map, [], maps:new(), 0}.

-file("src/sprocket/internal/utils/ordered_map.gleam", 20).
?DOC(false).
-spec from(list(keyed_item(FNB, FNC)), gleam@dict:dict(FNB, FNC), integer()) -> ordered_map(FNB, FNC).
from(Ordered, Map, Size) ->
    {ordered_map, Ordered, Map, Size}.

-file("src/sprocket/internal/utils/ordered_map.gleam", 28).
?DOC(false).
-spec from_list(list(keyed_item(FNK, FNL))) -> ordered_map(FNK, FNL).
from_list(Ordered) ->
    {R_ordered, Map@1, Size@1} = begin
        _pipe = Ordered,
        gleam@list:fold(
            _pipe,
            {[], maps:new(), 0},
            fun(Acc, Keyed_item) ->
                {Ordered@1, Map, Size} = Acc,
                {keyed_item, Key, Value} = Keyed_item,
                Keyed_item@1 = {keyed_item, Key, Value},
                case gleam@dict:has_key(Map, Key) of
                    true ->
                        {Ordered@1, Map, Size};

                    false ->
                        {[Keyed_item@1 | Ordered@1],
                            gleam@dict:insert(Map, Key, Value),
                            Size + 1}
                end
            end
        )
    end,
    {ordered_map, lists:reverse(R_ordered), Map@1, Size@1}.

-file("src/sprocket/internal/utils/ordered_map.gleam", 49).
?DOC(false).
-spec insert(ordered_map(FNR, FNS), FNR, FNS) -> ordered_map(FNR, FNS).
insert(M, Key, Value) ->
    {ordered_map,
        lists:reverse(
            [{keyed_item, Key, Value} | lists:reverse(erlang:element(2, M))]
        ),
        gleam@dict:insert(erlang:element(3, M), Key, Value),
        erlang:element(4, M) + 1}.

-file("src/sprocket/internal/utils/ordered_map.gleam", 58).
?DOC(false).
-spec update(ordered_map(FNX, FNY), FNX, FNY) -> ordered_map(FNX, FNY).
update(M, Key, Value) ->
    case gleam@dict:has_key(erlang:element(3, M), Key) of
        true ->
            {ordered_map,
                gleam@list:map(
                    erlang:element(2, M),
                    fun(Keyed_item) ->
                        {keyed_item, K, _} = Keyed_item,
                        case K =:= Key of
                            true ->
                                {keyed_item, Key, Value};

                            false ->
                                Keyed_item
                        end
                    end
                ),
                gleam@dict:insert(erlang:element(3, M), Key, Value),
                erlang:element(4, M)};

        false ->
            M
    end.

-file("src/sprocket/internal/utils/ordered_map.gleam", 76).
?DOC(false).
-spec has_key(ordered_map(FOD, any()), FOD) -> boolean().
has_key(M, Key) ->
    gleam@dict:has_key(erlang:element(3, M), Key).

-file("src/sprocket/internal/utils/ordered_map.gleam", 80).
?DOC(false).
-spec get(ordered_map(FOH, FOI), FOH) -> {ok, FOI} | {error, nil}.
get(M, Key) ->
    gleam_stdlib:map_get(erlang:element(3, M), Key).

-file("src/sprocket/internal/utils/ordered_map.gleam", 84).
?DOC(false).
-spec remove(ordered_map(FON, FOO), FON) -> ordered_map(FON, FOO).
remove(M, Key) ->
    case gleam@dict:has_key(erlang:element(3, M), Key) of
        true ->
            {ordered_map,
                erlang:element(2, M),
                gleam@dict:delete(erlang:element(3, M), Key),
                erlang:element(4, M) - 1};

        false ->
            M
    end.

-file("src/sprocket/internal/utils/ordered_map.gleam", 96).
?DOC(false).
-spec size(ordered_map(any(), any())) -> integer().
size(M) ->
    erlang:element(4, M).

-file("src/sprocket/internal/utils/ordered_map.gleam", 100).
?DOC(false).
-spec iter(ordered_map(FOX, FOY)) -> ordered_map_iter(FOX, FOY).
iter(M) ->
    _pipe = erlang:element(2, M),
    {ordered_map_iter, _pipe}.

-file("src/sprocket/internal/utils/ordered_map.gleam", 105).
?DOC(false).
-spec next(ordered_map_iter(FPD, FPE)) -> {ok,
        {ordered_map_iter(FPD, FPE), keyed_item(FPD, FPE)}} |
    {error, nil}.
next(Iter) ->
    case Iter of
        {ordered_map_iter, []} ->
            {error, nil};

        {ordered_map_iter, [Item | Rest]} ->
            {ok, {{ordered_map_iter, Rest}, Item}}
    end.

-file("src/sprocket/internal/utils/ordered_map.gleam", 115).
?DOC(false).
-spec fold(ordered_map(FPN, FPO), FPR, fun((FPR, keyed_item(FPN, FPO)) -> FPR)) -> FPR.
fold(M, Acc, Func) ->
    _pipe = erlang:element(2, M),
    gleam@list:fold(_pipe, Acc, Func).

-file("src/sprocket/internal/utils/ordered_map.gleam", 121).
?DOC(false).
-spec map(ordered_map(FPU, FPV), fun((keyed_item(FPU, FPV)) -> FQA)) -> list(FQA).
map(M, Func) ->
    _pipe = erlang:element(2, M),
    gleam@list:map(_pipe, Func).

-file("src/sprocket/internal/utils/ordered_map.gleam", 127).
?DOC(false).
-spec index_map(
    ordered_map(FQC, FQD),
    fun((keyed_item(FQC, FQD), integer()) -> FQI)
) -> list(FQI).
index_map(M, Func) ->
    _pipe = erlang:element(2, M),
    gleam@list:index_map(_pipe, Func).

-file("src/sprocket/internal/utils/ordered_map.gleam", 150).
?DOC(false).
-spec find_next_helper(list(keyed_item(any(), FQR))) -> {ok, FQR} | {error, nil}.
find_next_helper(Ordered) ->
    case Ordered of
        [Item | _] ->
            {ok, erlang:element(3, Item)};

        _ ->
            {error, nil}
    end.

-file("src/sprocket/internal/utils/ordered_map.gleam", 136).
?DOC(false).
-spec find_next(ordered_map(FQK, FQL), FQK) -> {ok, FQL} | {error, nil}.
find_next(M, Key) ->
    case erlang:element(2, M) of
        [] ->
            {error, nil};

        [Item | Rest] ->
            case Item of
                {keyed_item, K, _} ->
                    case K =:= Key of
                        true ->
                            find_next_helper(Rest);

                        false ->
                            find_next(
                                {ordered_map,
                                    Rest,
                                    erlang:element(3, M),
                                    erlang:element(4, M)},
                                Key
                            )
                    end
            end
    end.

-file("src/sprocket/internal/utils/ordered_map.gleam", 162).
?DOC(false).
-spec find_previous_helper(ordered_map(FRD, FRE), FRD, {ok, FRE} | {error, nil}) -> {ok,
        FRE} |
    {error, nil}.
find_previous_helper(M, Key, Prev) ->
    case erlang:element(2, M) of
        [] ->
            {error, nil};

        [Item | Rest] ->
            case Item of
                {keyed_item, K, V} ->
                    case K =:= Key of
                        true ->
                            Prev;

                        false ->
                            find_previous_helper(
                                {ordered_map,
                                    Rest,
                                    erlang:element(3, M),
                                    erlang:element(4, M)},
                                Key,
                                {ok, V}
                            )
                    end
            end
    end.

-file("src/sprocket/internal/utils/ordered_map.gleam", 158).
?DOC(false).
-spec find_previous(ordered_map(FQX, FQY), FQX) -> {ok, FQY} | {error, nil}.
find_previous(M, Key) ->
    find_previous_helper(M, Key, {error, nil}).

-file("src/sprocket/internal/utils/ordered_map.gleam", 181).
?DOC(false).
-spec find(ordered_map(FRL, FRM), fun((keyed_item(FRL, FRM)) -> boolean())) -> {ok,
        keyed_item(FRL, FRM)} |
    {error, nil}.
find(M, Find_by) ->
    case erlang:element(2, M) of
        [] ->
            {error, nil};

        [Item | Rest] ->
            case Item of
                {keyed_item, K, V} ->
                    case Find_by(Item) of
                        true ->
                            {ok, {keyed_item, K, V}};

                        false ->
                            find(
                                {ordered_map,
                                    Rest,
                                    erlang:element(3, M),
                                    erlang:element(4, M)},
                                Find_by
                            )
                    end
            end
    end.