pona

-module(pona@compound).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([compound/1, get_definitions/1, fetch/1]).
-export_type([compound_fetcher/0, compound_error/0, compound/0]).

-type compound_fetcher() :: {compound_fetcher, binary()}.

-type compound_error() :: {dynamic_error, gleam@dynamic:dynamic_()} |
    {word_not_found, binary()}.

-type compound() :: {compound, binary(), gleam@dict:dict(binary(), integer())}.

-spec compound(binary()) -> compound_fetcher().
compound(English) ->
    {compound_fetcher, English}.

-spec get_definitions(compound()) -> gleam@dict:dict(binary(), integer()).
get_definitions(Compound) ->
    erlang:element(3, Compound).

-spec fetch(compound_fetcher()) -> {ok, compound()} | {error, compound_error()}.
fetch(Fetcher) ->
    _assert_subject = gleam@http@request:to(
        <<"https://nimi.pona.la/en-tp.json"/utf8>>
    ),
    {ok, Req} = case _assert_subject of
        {ok, _} -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"pona/compound"/utf8>>,
                        function => <<"fetch"/utf8>>,
                        line => 35})
    end,
    Resp = gleam@result:replace_error(
        gleam@httpc:send(Req),
        fun(Field@0) -> {dynamic_error, Field@0} end
    ),
    Body = case Resp of
        {ok, Resp@1} ->
            erlang:element(4, Resp@1);

        {error, _} ->
            <<"{}"/utf8>>
    end,
    Data_decoder = gleam@dynamic:dict(
        fun gleam@dynamic:string/1,
        gleam@dynamic:dict(fun gleam@dynamic:string/1, fun gleam@dynamic:int/1)
    ),
    Data = begin
        _pipe = gleam@json:decode(Body, Data_decoder),
        gleam@result:unwrap(_pipe, gleam@dict:new())
    end,
    Result = begin
        _pipe@1 = Data,
        gleam@dict:get(_pipe@1, erlang:element(2, Fetcher))
    end,
    case Result of
        {ok, Definitions} ->
            {ok, {compound, erlang:element(2, Fetcher), Definitions}};

        {error, _} ->
            {error,
                {word_not_found,
                    <<"Word not found:"/utf8,
                        (erlang:element(2, Fetcher))/binary>>}}
    end.