-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(A) ->
    maps:size(A).

-spec to_list(map_(CSJ, CSK)) -> list({CSJ, CSK}).
to_list(A) ->
    maps:to_list(A).

-spec from_list(list({CSO, CSP})) -> map_(CSO, CSP).
from_list(A) ->
    maps:from_list(A).

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

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

-spec get(map_(CTI, CTF), CTI) -> {ok, CTF} | {error, nil}.
get(A, B) ->
    gleam_stdlib:map_get(A, B).

-spec insert(map_(CTR, CTS), CTR, CTS) -> map_(CTR, CTS).
insert(Map, Key, Value) ->
    maps:put(Key, Value, Map).

-spec map_values(map_(CUF, CUG), fun((CUF, CUG) -> CUJ)) -> map_(CUF, CUJ).
map_values(Map, Fun) ->
    maps:map(Fun, Map).

-spec keys(map_(CUM, any())) -> list(CUM).
keys(A) ->
    maps:keys(A).

-spec values(map_(any(), CUR)) -> list(CUR).
values(A) ->
    maps:values(A).

-spec filter(map_(CVC, CVD), fun((CVC, CVD) -> boolean())) -> map_(CVC, CVD).
filter(Map, Property) ->
    maps:filter(Property, Map).

-spec take(map_(CVP, CVQ), list(CVP)) -> map_(CVP, CVQ).
take(Map, Desired_keys) ->
    maps:with(Desired_keys, Map).

-spec merge(map_(CVW, CVX), map_(CVW, CVX)) -> map_(CVW, CVX).
merge(A, B) ->
    maps:merge(A, B).

-spec delete(map_(CWK, CWL), CWK) -> map_(CWK, CWL).
delete(Map, Key) ->
    maps:remove(Key, Map).

-spec drop(map_(CWQ, CWR), list(CWQ)) -> map_(CWQ, CWR).
drop(Map, Disallowed_keys) ->
    gleam@list:fold(Disallowed_keys, Map, fun(Key, Acc) -> delete(Acc, Key) end).

-spec update(map_(CWX, CWY), CWX, fun(({ok, CWY} | {error, nil}) -> CWY)) -> map_(CWX, CWY).
update(Map, Key, Fun) ->
    insert(Map, Key, Fun(gleam_stdlib:map_get(Map, Key))).

-spec do_fold(list({CXF, CXG}), CXI, fun((CXF, CXG, CXI) -> CXI)) -> CXI.
do_fold(List, Initial, Fun) ->
    case List of
        [] ->
            Initial;

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

-spec fold(map_(CXJ, CXK), CXN, fun((CXJ, CXK, CXN) -> CXN)) -> CXN.
fold(Map, Initial, Fun) ->
    do_fold(maps:to_list(Map), Initial, Fun).