eensy

-module(eensy@gpio).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([pin/5, write/2, read/1, sync/1, do_start/0, init/1, set_pin_pull/2, set_pin_mode/2, digital_write/2, digital_read/1, start/1]).
-export_type([direction/0, level/0, pin/0, pin_actor/2, msg/0]).

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

-type direction() :: input | output | output_od.

-type level() :: low | high.

-opaque pin() :: {pin,
        level(),
        eensy:pull(),
        integer(),
        direction(),
        gleam@option:option(fun((level()) -> nil))}.

-opaque pin_actor(GUZ, GVA) :: {pin_actor, gleam@erlang@process:subject(msg())} |
    {gleam_phantom, GUZ, GVA}.

-type msg() :: {write, level()} |
    {read, gleam@erlang@process:subject({ok, pin()} | {error, nil})} |
    sync.

-file("src/eensy/gpio.gleam", 54).
-spec pin(
    level(),
    eensy:pull(),
    integer(),
    direction(),
    gleam@option:option(fun((level()) -> nil))
) -> pin().
pin(Level, Pull, Port, Direction, Update) ->
    {pin, Level, Pull, Port, Direction, Update}.

-file("src/eensy/gpio.gleam", 64).
-spec write(pin_actor(any(), any()), level()) -> nil.
write(Actor, Value) ->
    gleam@erlang@process:send(erlang:element(2, Actor), {write, Value}).

-file("src/eensy/gpio.gleam", 68).
-spec read(pin_actor(any(), any())) -> {ok, pin()} | {error, nil}.
read(Actor) ->
    _pipe = gleam@erlang@process:try_call(
        erlang:element(2, Actor),
        fun(_capture) -> {read, _capture} end,
        100
    ),
    _pipe@1 = gleam@result:map_error(_pipe, fun(_) -> nil end),
    gleam@result:flatten(_pipe@1).

-file("src/eensy/gpio.gleam", 74).
-spec sync(pin_actor(any(), any())) -> nil.
sync(Actor) ->
    gleam@erlang@process:send(erlang:element(2, Actor), sync).

-file("src/eensy/gpio.gleam", 122).
?DOC(" Start gpio\n").
-spec do_start() -> {ok, integer()} | {error, nil}.
do_start() ->
    eensy_ffi:start_with_result().

-file("src/eensy/gpio.gleam", 126).
?DOC(" Init pin\n").
-spec init(integer()) -> nil.
init(Pin) ->
    gpio:init(Pin).

-file("src/eensy/gpio.gleam", 130).
?DOC(" Set pin pull\n").
-spec set_pin_pull(integer(), eensy:pull()) -> {ok, nil} | {error, nil}.
set_pin_pull(Pin, Pull) ->
    gpio:set_pin_pull(Pin, Pull).

-file("src/eensy/gpio.gleam", 134).
?DOC(" Set gpio pin direction\n").
-spec set_pin_mode(integer(), direction()) -> {ok, integer()} | {error, nil}.
set_pin_mode(Pin, Direction) ->
    eensy_ffi:set_pin_mode_with_result(Pin, Direction).

-file("src/eensy/gpio.gleam", 138).
?DOC(" Write to gpio pin\n").
-spec digital_write(integer(), level()) -> {ok, integer()} | {error, nil}.
digital_write(Pin, Level) ->
    eensy_ffi:digital_write_with_result(Pin, Level).

-file("src/eensy/gpio.gleam", 142).
?DOC(" Read from gpio pin\n").
-spec digital_read(integer()) -> {ok, level()} | {error, nil}.
digital_read(Pin) ->
    eensy_ffi:digital_read_with_result(Pin).

-file("src/eensy/gpio.gleam", 78).
-spec handle_message(msg(), pin()) -> eensy@otp@actor:next(msg(), pin()).
handle_message(Message, State) ->
    case Message of
        {write, Value} ->
            _ = eensy_ffi:digital_write_with_result(
                erlang:element(4, State),
                Value
            ),
            case erlang:element(6, State) of
                {some, Update} ->
                    Update(Value);

                none ->
                    nil
            end,
            State@1 = begin
                _record = State,
                {pin,
                    Value,
                    erlang:element(3, _record),
                    erlang:element(4, _record),
                    erlang:element(5, _record),
                    erlang:element(6, _record)}
            end,
            eensy@otp@actor:continue(State@1);

        {read, Client} ->
            Level = begin
                _pipe = eensy_ffi:digital_read_with_result(
                    erlang:element(4, State)
                ),
                gleam@result:unwrap(_pipe, low)
            end,
            case erlang:element(6, State) of
                {some, Update@1} ->
                    Update@1(Level);

                none ->
                    nil
            end,
            State@2 = begin
                _record@1 = State,
                {pin,
                    Level,
                    erlang:element(3, _record@1),
                    erlang:element(4, _record@1),
                    erlang:element(5, _record@1),
                    erlang:element(6, _record@1)}
            end,
            gleam@erlang@process:send(Client, {ok, State@2}),
            eensy@otp@actor:continue(State@2);

        sync ->
            Level@1 = begin
                _pipe@1 = eensy_ffi:digital_read_with_result(
                    erlang:element(4, State)
                ),
                gleam@result:unwrap(_pipe@1, low)
            end,
            State@3 = begin
                _record@2 = State,
                {pin,
                    Level@1,
                    erlang:element(3, _record@2),
                    erlang:element(4, _record@2),
                    erlang:element(5, _record@2),
                    erlang:element(6, _record@2)}
            end,
            case erlang:element(6, State@3) of
                {some, Update@2} ->
                    Update@2(Level@1);

                none ->
                    nil
            end,
            eensy@otp@actor:continue(State@3)
    end.

-file("src/eensy/gpio.gleam", 46).
-spec start(pin()) -> {ok, pin_actor(any(), any())} |
    {error, eensy@otp@actor:start_error()}.
start(Pin) ->
    _ = eensy_ffi:set_pin_mode_with_result(
        erlang:element(4, Pin),
        erlang:element(5, Pin)
    ),
    _ = gpio:set_pin_pull(erlang:element(4, Pin), erlang:element(3, Pin)),
    _pipe = eensy@otp@actor:start(Pin, fun handle_message/2),
    gleam@result:map(_pipe, fun(Field@0) -> {pin_actor, Field@0} end).