-module(gleam@map).
-compile(no_auto_import).

-export([size/1, to_list/1, from_list/1, has_key/2, new/0, get/2, insert/3, map_values/2, keys/1, values/1, filter/2, take/2, merge/2, delete/2, drop/2, update/3, fold/3]).
-export_type([map_/2]).

-type map_(Key, Value) :: any() | {gleam_phantom, Key, Value}.

-spec size(map_(any(), any())) -> integer().
size(Map) ->
    maps:size(Map).

-spec to_list(map_(ASM, ASN)) -> list({ASM, ASN}).
to_list(Map) ->
    maps:to_list(Map).

-spec from_list(list({ASW, ASX})) -> map_(ASW, ASX).
from_list(List) ->
    maps:from_list(List).

-spec has_key(map_(ATG, any()), ATG) -> boolean().
has_key(Map, Key) ->
    maps:is_key(Key, Map).

-spec new() -> map_(any(), any()).
new() ->
    maps:new().

-spec get(map_(ATW, ATX), ATW) -> {ok, ATX} | {error, nil}.
get(From, Get) ->
    gleam_stdlib:map_get(From, Get).

-spec insert(map_(AUI, AUJ), AUI, AUJ) -> map_(AUI, AUJ).
insert(Map, Key, Value) ->
    maps:put(Key, Value, Map).

-spec map_values(map_(AUU, AUV), fun((AUU, AUV) -> AUY)) -> map_(AUU, AUY).
map_values(Map, Fun) ->
    maps:map(Fun, Map).

-spec keys(map_(AVI, any())) -> list(AVI).
keys(Map) ->
    maps:keys(Map).

-spec values(map_(any(), AVT)) -> list(AVT).
values(Map) ->
    maps:values(Map).

-spec filter(map_(AWC, AWD), fun((AWC, AWD) -> boolean())) -> map_(AWC, AWD).
filter(Map, Property) ->
    maps:filter(Property, Map).

-spec take(map_(AWO, AWP), list(AWO)) -> map_(AWO, AWP).
take(Map, Desired_keys) ->
    maps:with(Desired_keys, Map).

-spec merge(map_(AXC, AXD), map_(AXC, AXD)) -> map_(AXC, AXD).
merge(Map, New_entries) ->
    maps:merge(Map, New_entries).

-spec delete(map_(AXS, AXT), AXS) -> map_(AXS, AXT).
delete(Map, Key) ->
    maps:remove(Key, Map).

-spec drop(map_(AYE, AYF), list(AYE)) -> map_(AYE, AYF).
drop(Map, Disallowed_keys) ->
    gleam@list:fold(Disallowed_keys, Map, fun delete/2).

-spec update(map_(AYL, AYM), AYL, fun((gleam@option:option(AYM)) -> AYM)) -> map_(AYL, AYM).
update(Map, Key, Fun) ->
    _pipe = Map,
    _pipe@1 = get(_pipe, Key),
    _pipe@2 = gleam@option:from_result(_pipe@1),
    _pipe@3 = Fun(_pipe@2),
    insert(Map, Key, _pipe@3).

-spec do_fold(list({AYS, AYT}), AYV, fun((AYV, AYS, AYT) -> AYV)) -> AYV.
do_fold(List, Initial, Fun) ->
    case List of
        [] ->
            Initial;

        [{K, V} | Tail] ->
            do_fold(Tail, Fun(Initial, K, V), Fun)
    end.

-spec fold(map_(AYW, AYX), AZA, fun((AZA, AYW, AYX) -> AZA)) -> AZA.
fold(Map, Initial, Fun) ->
    _pipe = Map,
    _pipe@1 = to_list(_pipe),
    do_fold(_pipe@1, Initial, Fun).