-module(cangaroo).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/cangaroo.gleam").
-export([start/0, open/2, close/1, send/2, set_loopback/2, recv_own_messages/2, set_filters/2, set_error_filter/2]).
-export_type([can_socket/0, can_error/0]).

-opaque can_socket() :: {can_socket, gleam@erlang@process:pid_()}.

-type can_error() :: interface_bound | {unknown_error, binary()}.

-file("src/cangaroo.gleam", 42).
-spec check_status(gleam@erlang@atom:atom_()) -> {ok, nil} |
    {error, 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.gleam", 49).
-spec decode_result(gleam@dynamic:dynamic_()) -> {ok, nil} |
    {error, can_error()}.
decode_result(Raw) ->
    Ok = erlang:binary_to_atom(<<"ok"/utf8>>),
    Error_tuple_decoder = begin
        gleam@dynamic@decode:subfield(
            [0],
            {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
            fun(Tag_dyn) ->
                gleam@dynamic@decode:subfield(
                    [1],
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
                    fun(Reason_dyn) ->
                        Tag = gleam_erlang_ffi:identity(Tag_dyn),
                        Reason = gleam_erlang_ffi:identity(Reason_dyn),
                        case {Tag =:= erlang:binary_to_atom(<<"error"/utf8>>),
                            Reason =:= erlang:binary_to_atom(<<"ebound"/utf8>>)} of
                            {true, true} ->
                                gleam@dynamic@decode:success(
                                    {error, interface_bound}
                                );

                            {_, _} ->
                                gleam@dynamic@decode:success(
                                    {error,
                                        {unknown_error,
                                            erlang:atom_to_binary(Reason)}}
                                )
                        end
                    end
                )
            end
        )
    end,
    Success_atom_decoder = begin
        gleam@dynamic@decode:then(
            {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
            fun(Result_dyn) ->
                Result = gleam_erlang_ffi:identity(Result_dyn),
                case Result =:= Ok of
                    true ->
                        gleam@dynamic@decode:success({ok, nil});

                    _ ->
                        gleam@dynamic@decode:success(
                            {error,
                                {unknown_error, erlang:atom_to_binary(Result)}}
                        )
                end
            end
        )
    end,
    Decoder = gleam@dynamic@decode:one_of(
        Error_tuple_decoder,
        [Success_atom_decoder]
    ),
    case gleam@dynamic@decode:run(Raw, Decoder) of
        {ok, Result@1} ->
            Result@1;

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

-file("src/cangaroo.gleam", 94).
-spec start() -> {ok, can_socket()} | {error, can_error()}.
start() ->
    {Status, Pid} = 'Elixir.Excansock':start_link(),
    case erlang:atom_to_binary(Status) of
        <<"ok"/utf8>> ->
            {ok, {can_socket, Pid}};

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

-file("src/cangaroo.gleam", 102).
-spec open(can_socket(), binary()) -> {ok, nil} | {error, can_error()}.
open(Socket, Interface) ->
    Raw = 'Elixir.Excansock':open(erlang:element(2, Socket), Interface, false),
    decode_result(Raw).

-file("src/cangaroo.gleam", 107).
-spec close(can_socket()) -> {ok, nil} | {error, can_error()}.
close(Socket) ->
    Status = 'Elixir.Excansock':close(erlang:element(2, Socket)),
    check_status(Status).

-file("src/cangaroo.gleam", 112).
-spec send(can_socket(), cangaroo@bridge:can_frame()) -> {ok, nil} |
    {error, can_error()}.
send(Socket, Frame) ->
    Status = 'Elixir.Excansock':send(erlang:element(2, Socket), Frame),
    check_status(Status).

-file("src/cangaroo.gleam", 117).
-spec set_loopback(can_socket(), boolean()) -> {ok, nil} | {error, can_error()}.
set_loopback(Socket, Value) ->
    Status = 'Elixir.Excansock':set_loopback(erlang:element(2, Socket), Value),
    check_status(Status).

-file("src/cangaroo.gleam", 122).
-spec recv_own_messages(can_socket(), boolean()) -> {ok, nil} |
    {error, can_error()}.
recv_own_messages(Socket, Value) ->
    Status = 'Elixir.Excansock':recv_own_messages(
        erlang:element(2, Socket),
        Value
    ),
    check_status(Status).

-file("src/cangaroo.gleam", 130).
-spec set_filters(can_socket(), list(cangaroo@bridge:can_filter())) -> {ok, nil} |
    {error, can_error()}.
set_filters(Socket, Filters) ->
    Status = 'Elixir.Excansock':set_filters(erlang:element(2, Socket), Filters),
    check_status(Status).

-file("src/cangaroo.gleam", 138).
-spec set_error_filter(can_socket(), integer()) -> {ok, nil} |
    {error, can_error()}.
set_error_filter(Socket, Filter) ->
    Status = 'Elixir.Excansock':set_error_filter(
        erlang:element(2, Socket),
        Filter
    ),
    check_status(Status).