sprocket

-module(sprocket@internal@utils@ordered_map).
-compile([no_auto_import, nowarn_unused_vars]).

-export([new/0, from/3, insert/3, update/3, has_key/2, get/2, remove/2, size/1, iter/1, next/1, fold/3]).
-export_type([keyed_item/2, ordered_map/2, ordered_map_iter/2]).

-type keyed_item(JKC, JKD) :: {keyed_item, JKC, JKD}.

-opaque ordered_map(JKE, JKF) :: {ordered_map,
        list(keyed_item(JKE, JKF)),
        gleam@map:map_(JKE, JKF),
        integer()}.

-opaque ordered_map_iter(JKG, JKH) :: {ordered_map_iter,
        list(keyed_item(JKG, JKH))}.

-spec new() -> ordered_map(any(), any()).
new() ->
    {ordered_map, [], gleam@map:new(), 0}.

-spec from(list(keyed_item(JKM, JKN)), gleam@map:map_(JKM, JKN), integer()) -> ordered_map(JKM, JKN).
from(Ordered, Map, Size) ->
    {ordered_map, Ordered, Map, Size}.

-spec insert(ordered_map(JKV, JKW), JKV, JKW) -> ordered_map(JKV, JKW).
insert(M, Key, Value) ->
    {ordered_map,
        gleam@list:reverse(
            [{keyed_item, Key, Value} |
                gleam@list:reverse(erlang:element(2, M))]
        ),
        gleam@map:insert(erlang:element(3, M), Key, Value),
        erlang:element(4, M) + 1}.

-spec update(ordered_map(JLB, JLC), JLB, JLC) -> ordered_map(JLB, JLC).
update(M, Key, Value) ->
    case gleam@map: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@map:insert(erlang:element(3, M), Key, Value),
                erlang:element(4, M)};

        false ->
            M
    end.

-spec has_key(ordered_map(JLH, any()), JLH) -> boolean().
has_key(M, Key) ->
    gleam@map:has_key(erlang:element(3, M), Key).

-spec get(ordered_map(JLL, JLM), JLL) -> {ok, JLM} | {error, nil}.
get(M, Key) ->
    gleam@map:get(erlang:element(3, M), Key).

-spec remove(ordered_map(JLR, JLS), JLR) -> ordered_map(JLR, JLS).
remove(M, Key) ->
    case gleam@map:has_key(erlang:element(3, M), Key) of
        true ->
            {ordered_map,
                erlang:element(2, M),
                gleam@map:delete(erlang:element(3, M), Key),
                erlang:element(4, M) - 1};

        false ->
            M
    end.

-spec size(ordered_map(any(), any())) -> integer().
size(M) ->
    erlang:element(4, M).

-spec iter(ordered_map(JMB, JMC)) -> ordered_map_iter(JMB, JMC).
iter(M) ->
    _pipe = erlang:element(2, M),
    {ordered_map_iter, _pipe}.

-spec next(ordered_map_iter(JMH, JMI)) -> {ok,
        {ordered_map_iter(JMH, JMI), keyed_item(JMH, JMI)}} |
    {error, nil}.
next(Iter) ->
    case Iter of
        {ordered_map_iter, []} ->
            {error, nil};

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

-spec fold(ordered_map(JMR, JMS), JMV, fun((JMV, keyed_item(JMR, JMS)) -> JMV)) -> JMV.
fold(M, Acc, Func) ->
    _pipe = erlang:element(2, M),
    gleam@list:fold(_pipe, Acc, Func).