-module(ordered_dict).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([new/0, from_list/1, has_key/2, size/1, is_empty/1, prepend/3, insert_end/3, insert/4, get_key_at/2, get_value_at/2, get_at/2, get/2, get_index/2, delete_at_with_key/3, delete_at/2, delete/2, drop/2, take/2, reorder/3, to_list/1, to_list_indexed/1, filter/2, keys/1, values/1, backing_dict/1, fold/3, each/2, map_values/2, upsert/3]).
-export_type([ordered_dict/2, upsert_index/0, upsert/2]).

-opaque ordered_dict(FUK, FUL) :: {ordered_dict,
        gleam@dict:dict(FUK, FUL),
        list(FUK)}.

-type upsert_index() :: start | 'end' | {index, integer()}.

-type upsert(FUM, FUN) :: {update, FUN, fun((FUN) -> ordered_dict(FUM, FUN))} |
    {insert, fun((upsert_index(), FUN) -> ordered_dict(FUM, FUN))}.

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 18).
-spec new() -> ordered_dict(any(), any()).
new() ->
    {ordered_dict, maps:new(), []}.

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 27).
-spec from_list(list({FUS, FUT})) -> ordered_dict(FUS, FUT).
from_list(Entries) ->
    {D, Rev} = (gleam@list:fold(
        Entries,
        {maps:new(), []},
        fun(_use0, _use1) ->
            {Map, Rev_order} = _use0,
            {Key, Val} = _use1,
            {gleam@dict:insert(Map, Key, Val),
                [Key | gleam@list:filter(Rev_order, fun(K) -> K /= Key end)]}
        end
    )),
    {ordered_dict, D, lists:reverse(Rev)}.

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 52).
-spec has_key(ordered_dict(FUX, any()), FUX) -> boolean().
has_key(O_dict, Key) ->
    gleam@dict:has_key(erlang:element(2, O_dict), Key).

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 71).
-spec size(ordered_dict(any(), any())) -> integer().
size(O_dict) ->
    erlang:length(erlang:element(3, O_dict)).

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 89).
-spec is_empty(ordered_dict(any(), any())) -> boolean().
is_empty(O_dict) ->
    gleam@dict:is_empty(erlang:element(2, O_dict)).

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 105).
-spec prepend(ordered_dict(FVJ, FVK), FVJ, FVK) -> ordered_dict(FVJ, FVK).
prepend(O_dict, Key, Val) ->
    {ordered_dict,
        gleam@dict:insert(erlang:element(2, O_dict), Key, Val),
        [Key |
            gleam@list:filter(erlang:element(3, O_dict), fun(K) -> K /= Key end)]}.

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 128).
-spec insert_end(ordered_dict(FVP, FVQ), FVP, FVQ) -> ordered_dict(FVP, FVQ).
insert_end(O_dict, Key, Val) ->
    {ordered_dict,
        gleam@dict:insert(erlang:element(2, O_dict), Key, Val),
        lists:append(
            gleam@list:filter(erlang:element(3, O_dict), fun(K) -> K /= Key end),
            [Key]
        )}.

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 151).
-spec insert(ordered_dict(FVV, FVW), integer(), FVV, FVW) -> ordered_dict(FVV, FVW).
insert(O_dict, Index, Key, Val) ->
    Filter = fun(L) -> gleam@list:filter(L, fun(K) -> K /= Key end) end,
    {ordered_dict,
        gleam@dict:insert(erlang:element(2, O_dict), Key, Val),
        case gleam@list:split(erlang:element(3, O_dict), Index) of
            {Pre, []} ->
                lists:append(Filter(Pre), [Key]);

            {Pre@1, Post} ->
                lists:append(Pre@1, [Key | Filter(Post)])
        end}.

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 183).
-spec get_key_at(ordered_dict(FWB, any()), integer()) -> {ok, FWB} |
    {error, nil}.
get_key_at(O_dict, Index) ->
    case gleam@list:split(erlang:element(3, O_dict), Index) of
        {_, []} ->
            {error, nil};

        {_, [Key | _]} ->
            {ok, Key}
    end.

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 210).
-spec get_value_at(ordered_dict(any(), FWI), integer()) -> {ok, FWI} |
    {error, nil}.
get_value_at(O_dict, Index) ->
    case gleam@list:split(erlang:element(3, O_dict), Index) of
        {_, []} ->
            {error, nil};

        {_, [Key | _]} ->
            gleam_stdlib:map_get(erlang:element(2, O_dict), Key)
    end.

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 237).
-spec get_at(ordered_dict(FWN, FWO), integer()) -> {ok, {FWN, FWO}} |
    {error, nil}.
get_at(O_dict, Index) ->
    case gleam@list:split(erlang:element(3, O_dict), Index) of
        {_, []} ->
            {error, nil};

        {_, [Key | _]} ->
            _pipe = gleam_stdlib:map_get(erlang:element(2, O_dict), Key),
            gleam@result:map(_pipe, fun(Val) -> {Key, Val} end)
    end.

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 265).
-spec get(ordered_dict(FWT, FWU), FWT) -> {ok, FWU} | {error, nil}.
get(O_dict, Key) ->
    gleam_stdlib:map_get(erlang:element(2, O_dict), Key).

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 286).
-spec get_index(ordered_dict(FWZ, any()), FWZ) -> {ok, integer()} | {error, nil}.
get_index(O_dict, Key) ->
    case has_key(O_dict, Key) of
        true ->
            Len = erlang:length(erlang:element(3, O_dict)),
            Idx = (gleam@list:fold_until(
                erlang:element(3, O_dict),
                0,
                fun(I, K) -> case K =:= Key of
                        true ->
                            {stop, I};

                        _ ->
                            {continue, I + 1}
                    end end
            )),
            case Idx < Len of
                true ->
                    {ok, Idx};

                _ ->
                    {error, nil}
            end;

        _ ->
            {error, nil}
    end.

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 331).
-spec delete_at_with_key(ordered_dict(FXF, FXG), integer(), FXF) -> ordered_dict(FXF, FXG).
delete_at_with_key(O_dict, Index, Key) ->
    case gleam@list:split(erlang:element(3, O_dict), Index) of
        {Pre, [Key_at | Post]} when Key =:= Key_at ->
            {ordered_dict,
                gleam@dict:delete(erlang:element(2, O_dict), Key_at),
                lists:append(Pre, Post)};

        _ ->
            O_dict
    end.

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 358).
-spec delete_at(ordered_dict(FXL, FXM), integer()) -> ordered_dict(FXL, FXM).
delete_at(O_dict, Index) ->
    case gleam@list:split(erlang:element(3, O_dict), Index) of
        {Pre, [Key_at | Post]} ->
            {ordered_dict,
                gleam@dict:delete(erlang:element(2, O_dict), Key_at),
                lists:append(Pre, Post)};

        _ ->
            O_dict
    end.

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 384).
-spec delete(ordered_dict(FXR, FXS), FXR) -> ordered_dict(FXR, FXS).
delete(O_dict, Key) ->
    {ordered_dict,
        gleam@dict:delete(erlang:element(2, O_dict), Key),
        gleam@list:filter(
            erlang:element(3, O_dict),
            fun(Item) -> Item /= Key end
        )}.

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 414).
-spec drop(ordered_dict(FXX, FXY), list(FXX)) -> ordered_dict(FXX, FXY).
drop(O_dict, Disallowed_keys) ->
    {ordered_dict,
        gleam@dict:drop(erlang:element(2, O_dict), Disallowed_keys),
        gleam@list:filter(
            erlang:element(3, O_dict),
            fun(Item) -> not gleam@list:contains(Disallowed_keys, Item) end
        )}.

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 438).
-spec take(ordered_dict(FYD, FYE), list(FYD)) -> ordered_dict(FYD, FYE).
take(O_dict, Desired_keys) ->
    {ordered_dict,
        gleam@dict:take(erlang:element(2, O_dict), Desired_keys),
        gleam@list:filter(
            erlang:element(3, O_dict),
            fun(_capture) -> gleam@list:contains(Desired_keys, _capture) end
        )}.

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 501).
-spec reorder(ordered_dict(FYQ, FYR), integer(), integer()) -> ordered_dict(FYQ, FYR).
reorder(O_dict, Old_index, New_index) ->
    Old = gleam@int:min(
        Old_index,
        gleam@int:max(0, erlang:length(erlang:element(3, O_dict)) - 1)
    ),
    Delta = gleam@int:absolute_value(New_index - Old),
    erlang:setelement(3, O_dict, case gleam@int:compare(New_index, Old) of
            eq ->
                erlang:element(3, O_dict);

            gt ->
                _assert_subject = gleam@list:split(
                    erlang:element(3, O_dict),
                    Old
                ),
                {Pre, [Key | Rest]} = case _assert_subject of
                    {_, [_ | _]} -> _assert_subject;
                    _assert_fail ->
                        erlang:error(#{gleam_error => let_assert,
                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                    value => _assert_fail,
                                    module => <<"ordered_dict"/utf8>>,
                                    function => <<"reorder"/utf8>>,
                                    line => 513})
                end,
                {Mid, Post} = gleam@list:split(Rest, Delta),
                gleam@list:flatten([Pre, Mid, [Key], Post]);

            lt ->
                _assert_subject@1 = gleam@list:split(
                    erlang:element(3, O_dict),
                    New_index
                ),
                {Pre@1, [Key@1 | Rest@1]} = case _assert_subject@1 of
                    {_, [_ | _]} -> _assert_subject@1;
                    _assert_fail@1 ->
                        erlang:error(#{gleam_error => let_assert,
                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                    value => _assert_fail@1,
                                    module => <<"ordered_dict"/utf8>>,
                                    function => <<"reorder"/utf8>>,
                                    line => 518})
                end,
                {Mid@1, Post@1} = gleam@list:split(Rest@1, Delta),
                gleam@list:flatten([Pre@1, [Key@1], Mid@1, Post@1])
        end).

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 545).
-spec to_list(ordered_dict(FYW, FYX)) -> list({FYW, FYX}).
to_list(O_dict) ->
    gleam@list:filter_map(
        erlang:element(3, O_dict),
        fun(Key) ->
            _pipe = gleam_stdlib:map_get(erlang:element(2, O_dict), Key),
            gleam@result:map(_pipe, fun(D) -> {Key, D} end)
        end
    ).

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 570).
-spec to_list_indexed(ordered_dict(FZB, FZC)) -> list({integer(), FZB, FZC}).
to_list_indexed(O_dict) ->
    _pipe = erlang:element(
        1,
        (gleam@list:fold(
            erlang:element(3, O_dict),
            {[], 0},
            fun(_use0, Key) ->
                {Out, I} = _use0,
                case gleam_stdlib:map_get(erlang:element(2, O_dict), Key) of
                    {ok, Val} ->
                        {[{I, Key, Val} | Out], I + 1};

                    _ ->
                        {Out, I}
                end
            end
        ))
    ),
    lists:reverse(_pipe).

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 465).
-spec filter(ordered_dict(FYK, FYL), fun((FYK, FYL, integer()) -> boolean())) -> ordered_dict(FYK, FYL).
filter(O_dict, Predicate) ->
    _pipe = to_list_indexed(O_dict),
    _pipe@1 = gleam@list:filter_map(
        _pipe,
        fun(E) ->
            case Predicate(
                erlang:element(2, E),
                erlang:element(3, E),
                erlang:element(1, E)
            ) of
                true ->
                    {ok, {erlang:element(2, E), erlang:element(3, E)}};

                _ ->
                    {error, nil}
            end
        end
    ),
    from_list(_pipe@1).

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 590).
-spec keys(ordered_dict(FZG, any())) -> list(FZG).
keys(O_dict) ->
    gleam@list:filter(
        erlang:element(3, O_dict),
        fun(_capture) ->
            gleam@dict:has_key(erlang:element(2, O_dict), _capture)
        end
    ).

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 603).
-spec values(ordered_dict(any(), FZM)) -> list(FZM).
values(O_dict) ->
    gleam@list:map(
        to_list(O_dict),
        fun(_use0) ->
            {_, Val} = _use0,
            Val
        end
    ).

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 609).
-spec backing_dict(ordered_dict(FZQ, FZR)) -> gleam@dict:dict(FZQ, FZR).
backing_dict(O_dict) ->
    erlang:element(2, O_dict).

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 634).
-spec fold(ordered_dict(FZW, FZX), GAA, fun((GAA, FZW, FZX, integer()) -> GAA)) -> GAA.
fold(O_dict, Initial, Fun) ->
    gleam@list:fold(
        to_list_indexed(O_dict),
        Initial,
        fun(Acc, _use1) ->
            {Idx, Key, Val} = _use1,
            Fun(Acc, Key, Val, Idx)
        end
    ).

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 662).
-spec each(ordered_dict(GAB, GAC), fun((GAB, GAC, integer()) -> any())) -> nil.
each(O_dict, Fun) ->
    fold(
        O_dict,
        nil,
        fun(Nil, K, V, I) ->
            Fun(K, V, I),
            Nil
        end
    ).

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 680).
-spec map_values(ordered_dict(GAG, GAH), fun((GAG, GAH, integer()) -> GAK)) -> ordered_dict(GAG, GAK).
map_values(O_dict, Fun) ->
    _pipe = to_list_indexed(O_dict),
    _pipe@1 = gleam@list:map(
        _pipe,
        fun(E) ->
            {erlang:element(2, E),
                Fun(
                    erlang:element(2, E),
                    erlang:element(3, E),
                    erlang:element(1, E)
                )}
        end
    ),
    from_list(_pipe@1).

-file("/home/nick/programming/gleam/ordered_dict/src/ordered_dict.gleam", 723).
-spec upsert(
    ordered_dict(GAN, GAO),
    GAN,
    fun((upsert(GAN, GAO)) -> ordered_dict(GAN, GAO))
) -> ordered_dict(GAN, GAO).
upsert(O_dict, Key, Fun) ->
    _pipe = case get(O_dict, Key) of
        {ok, Val} ->
            {update,
                Val,
                fun(Val@1) ->
                    erlang:setelement(
                        2,
                        O_dict,
                        gleam@dict:insert(erlang:element(2, O_dict), Key, Val@1)
                    )
                end};

        _ ->
            {insert, fun(Index, Val@2) -> case Index of
                        start ->
                            prepend(O_dict, Key, Val@2);

                        {index, I} when I =< 0 ->
                            prepend(O_dict, Key, Val@2);

                        {index, I@1} ->
                            insert(O_dict, I@1, Key, Val@2);

                        'end' ->
                            insert_end(O_dict, Key, Val@2)
                    end end}
    end,
    Fun(_pipe).