cangaroo

-module(cangaroo@internal).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/cangaroo/internal.gleam").
-export([check_status/1, decode_result/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(false).

-file("src/cangaroo/internal.gleam", 12).
?DOC(false).
-spec check_status(gleam@erlang@atom:atom_()) -> {ok, nil} |
    {error, cangaroo@errors:can_error()}.
check_status(Status) ->
    case erlang:atom_to_binary(Status) of
        <<"ok"/utf8>> ->
            {ok, nil};

        Other ->
            {error, {unknown_error, Other}}
    end.

-file("src/cangaroo/internal.gleam", 30).
?DOC(false).
-spec decode_as_error_tuple(gleam@dynamic:dynamic_()) -> {ok, nil} |
    {error, cangaroo@errors:can_error()}.
decode_as_error_tuple(Raw) ->
    Tuple_decoder = begin
        gleam@dynamic@decode:subfield(
            [0],
            gleam@erlang@atom:decoder(),
            fun(Tag) ->
                gleam@dynamic@decode:subfield(
                    [1],
                    gleam@erlang@atom:decoder(),
                    fun(Reason) ->
                        gleam@dynamic@decode:success(
                            {erlang:atom_to_binary(Tag),
                                erlang:atom_to_binary(Reason)}
                        )
                    end
                )
            end
        )
    end,
    case gleam@dynamic@decode:run(Raw, Tuple_decoder) of
        {ok, {Tag@1, Reason@1}} ->
            case {Tag@1, Reason@1} of
                {<<"error"/utf8>>, <<"ebound"/utf8>>} ->
                    {error, {interface_bound_error, <<"ebound"/utf8>>}};

                {<<"error"/utf8>>, R} ->
                    {error, {unknown_error, R}};

                {_, _} ->
                    {error, {unknown_error, <<"unparsable_return"/utf8>>}}
            end;

        {error, _} ->
            {error, {unknown_error, <<"unparsable_return"/utf8>>}}
    end.

-file("src/cangaroo/internal.gleam", 19).
?DOC(false).
-spec decode_result(gleam@dynamic:dynamic_()) -> {ok, nil} |
    {error, cangaroo@errors:can_error()}.
decode_result(Raw) ->
    case gleam@dynamic@decode:run(Raw, gleam@erlang@atom:decoder()) of
        {ok, Atom_val} ->
            case erlang:atom_to_binary(Atom_val) of
                <<"ok"/utf8>> ->
                    {ok, nil};

                Other ->
                    {error, {unknown_error, Other}}
            end;

        {error, _} ->
            decode_as_error_tuple(Raw)
    end.