translate

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

-export([with_directory/2, from_json/1, get_key/2, get_key_with_args/3, new_translator/1]).
-export_type([translator/0]).

-type translator() :: {translator,
        binary(),
        gleam@option:option(binary()),
        gleam@option:option(gleam@dict:dict(binary(), gleam@dict:dict(binary(), binary())))}.

-spec with_directory(translator(), binary()) -> translator().
with_directory(Translator, Directory) ->
    erlang:setelement(3, Translator, {some, Directory}).

-spec from_json(translator()) -> {ok, translator()} |
    {error, error:translator_error()}.
from_json(Translator) ->
    gleam@result:'try'(
        gleam@option:to_result(erlang:element(3, Translator), directory_not_set),
        fun(Directory) ->
            Directory_with_language = begin
                _pipe = Directory,
                _pipe@1 = gleam@string:append(_pipe, <<"/"/utf8>>),
                gleam@string:append(_pipe@1, erlang:element(2, Translator))
            end,
            gleam@result:'try'(
                begin
                    _pipe@2 = simplifile:is_directory(Directory_with_language),
                    gleam@result:map_error(
                        _pipe@2,
                        fun(Field@0) -> {file_error, Field@0} end
                    )
                end,
                fun(Is_directory) -> gleam@result:'try'(case Is_directory of
                            true ->
                                {ok, json:read_file(Directory_with_language)};

                            false ->
                                {error, directory_not_found}
                        end, fun(Translations) ->
                            gleam@result:'try'(
                                Translations,
                                fun(Translations@1) ->
                                    {ok,
                                        erlang:setelement(
                                            4,
                                            Translator,
                                            {some, Translations@1}
                                        )}
                                end
                            )
                        end) end
            )
        end
    ).

-spec get_key(translator(), binary()) -> {ok, binary()} |
    {error, error:translator_error()}.
get_key(Translator, Key) ->
    Translations = begin
        _pipe = erlang:element(4, Translator),
        gleam@option:unwrap(_pipe, gleam@dict:new())
    end,
    gleam@result:'try'(
        begin
            _pipe@1 = gleam@dict:get(Translations, Key),
            gleam@result:replace_error(_pipe@1, key_not_found)
        end,
        fun(Translation) ->
            _pipe@2 = gleam@dict:get(Translation, <<"value"/utf8>>),
            gleam@result:replace_error(_pipe@2, key_not_found)
        end
    ).

-spec rec_replace_args(binary(), list({binary(), binary()})) -> binary().
rec_replace_args(Value, Args) ->
    case Args of
        [Head | Tail] ->
            {Param, Param_value} = Head,
            Updated_translation = gleam@string:replace(
                Value,
                <<<<"{"/utf8, (gleam@string:uppercase(Param))/binary>>/binary,
                    "}"/utf8>>,
                Param_value
            ),
            rec_replace_args(Updated_translation, Tail);

        _ ->
            Value
    end.

-spec get_key_with_args(translator(), binary(), list({binary(), binary()})) -> {ok,
        binary()} |
    {error, error:translator_error()}.
get_key_with_args(Translator, Key, Args) ->
    gleam@result:'try'(
        get_key(Translator, Key),
        fun(Translation) -> {ok, rec_replace_args(Translation, Args)} end
    ).

-spec new_translator(binary()) -> translator().
new_translator(Language) ->
    {translator, Language, {some, <<"src/translations"/utf8>>}, none}.