eensy_dev_tools

-module(eensy_dev_tools@cli).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([run/2, return/1, throw/1, from_result/1, do/2, in/1, map/2, 'try'/2, log/2, success/2, notify/2, mute/0, unmute/0, get_config/0, get_name/0, get_flags/0, get_config_value/5, get_int/4, get_string/4, get_bool/4]).
-export_type([cli/1, env/0, spinner_status/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.

-opaque cli(MUO) :: {cli,
        fun((env()) -> {env(),
            {ok, MUO} | {error, eensy_dev_tools@error:error()}})}.

-type env() :: {env,
        boolean(),
        spinner_status(),
        glint:flags(),
        eensy_dev_tools@project:config()}.

-type spinner_status() :: {running, spinner:spinner(), binary()} | paused.

-file("src/eensy_dev_tools/cli.gleam", 35).
?DOC("\n").
-spec run(cli(MUP), glint:flags()) -> {ok, MUP} |
    {error, eensy_dev_tools@error:error()}.
run(Step, Flags) ->
    gleam@result:'try'(
        eensy_dev_tools@project:config(),
        fun(Config) ->
            Env = {env, false, paused, Flags, Config},
            {Env@1, Result} = (erlang:element(2, Step))(Env),
            case erlang:element(3, Env@1) of
                {running, Spinner, _} ->
                    spinner:stop(Spinner);

                paused ->
                    nil
            end,
            case {Result, erlang:element(3, Env@1)} of
                {{error, _}, {running, _, Message}} ->
                    gleam_stdlib:println(
                        <<"❌ "/utf8,
                            (gleam_community@ansi:red(Message))/binary>>
                    );

                {{error, _}, _} ->
                    nil;

                {{ok, _}, _} ->
                    nil
            end,
            Result
        end
    ).

-file("src/eensy_dev_tools/cli.gleam", 59).
?DOC("\n").
-spec return(MUT) -> cli(MUT).
return(Value) ->
    {cli, fun(Env) -> {Env, {ok, Value}} end}.

-file("src/eensy_dev_tools/cli.gleam", 67).
?DOC("\n").
-spec throw(eensy_dev_tools@error:error()) -> cli(any()).
throw(Error) ->
    {cli, fun(Env) -> {Env, {error, Error}} end}.

-file("src/eensy_dev_tools/cli.gleam", 73).
-spec from_result({ok, MUX} | {error, eensy_dev_tools@error:error()}) -> cli(MUX).
from_result(Result) ->
    {cli, fun(Env) -> {Env, Result} end}.

-file("src/eensy_dev_tools/cli.gleam", 83).
?DOC("\n").
-spec do(cli(MVB), fun((MVB) -> cli(MVD))) -> cli(MVD).
do(Step, Next) ->
    {cli,
        fun(Env) ->
            {Env@1, Result} = (erlang:element(2, Step))(Env),
            case Result of
                {ok, Value} ->
                    (erlang:element(2, Next(Value)))(Env@1);

                {error, Error} ->
                    case erlang:element(3, Env@1) of
                        {running, Spinner, _} ->
                            spinner:stop(Spinner);

                        paused ->
                            nil
                    end,
                    {Env@1, {error, Error}}
            end
        end}.

-file("src/eensy_dev_tools/cli.gleam", 100).
-spec in(fun(() -> MVG)) -> cli(MVG).
in(Value) ->
    {cli, fun(Env) -> {Env, {ok, Value()}} end}.

-file("src/eensy_dev_tools/cli.gleam", 106).
-spec map(cli(MVI), fun((MVI) -> MVK)) -> cli(MVK).
map(Step, Next) ->
    {cli,
        fun(Env) ->
            {Env@1, Result} = (erlang:element(2, Step))(Env),
            Result@1 = gleam@result:map(Result, Next),
            {Env@1, Result@1}
        end}.

-file("src/eensy_dev_tools/cli.gleam", 116).
?DOC("\n").
-spec 'try'(
    {ok, MVM} | {error, eensy_dev_tools@error:error()},
    fun((MVM) -> cli(MVP))
) -> cli(MVP).
'try'(Result, Next) ->
    {cli, fun(Env) -> case Result of
                {ok, A} ->
                    (erlang:element(2, Next(A)))(Env);

                {error, Error} ->
                    case erlang:element(3, Env) of
                        {running, Spinner, _} ->
                            spinner:stop(Spinner);

                        paused ->
                            nil
                    end,
                    {Env, {error, Error}}
            end end}.

-file("src/eensy_dev_tools/cli.gleam", 136).
?DOC("\n").
-spec log(binary(), fun(() -> cli(MVS))) -> cli(MVS).
log(Message, Next) ->
    {cli,
        fun(Env) ->
            Env@1 = case erlang:element(2, Env) of
                true ->
                    Env;

                false ->
                    _record = Env,
                    {env,
                        erlang:element(2, _record),
                        case erlang:element(3, Env) of
                            paused ->
                                {running,
                                    begin
                                        _pipe = spinner:new(Message),
                                        _pipe@1 = spinner:with_colour(
                                            _pipe,
                                            fun gleam_community@ansi:magenta/1
                                        ),
                                        _pipe@2 = spinner:with_frames(
                                            _pipe@1,
                                            [<<"⠋"/utf8>>,
                                                <<"⠙"/utf8>>,
                                                <<"⠹"/utf8>>,
                                                <<"⠸"/utf8>>,
                                                <<"⠼"/utf8>>,
                                                <<"⠴"/utf8>>,
                                                <<"⠦"/utf8>>,
                                                <<"⠧"/utf8>>,
                                                <<"⠇"/utf8>>,
                                                <<"⠏"/utf8>>]
                                        ),
                                        spinner:start(_pipe@2)
                                    end,
                                    Message};

                            {running, Spinner, _} ->
                                spinner:set_text(Spinner, Message),
                                {running, Spinner, Message}
                        end,
                        erlang:element(4, _record),
                        erlang:element(5, _record)}
            end,
            (erlang:element(2, Next()))(Env@1)
        end}.

-file("src/eensy_dev_tools/cli.gleam", 161).
-spec success(binary(), fun(() -> cli(MVV))) -> cli(MVV).
success(Message, Next) ->
    {cli,
        fun(Env) ->
            Env@1 = begin
                _record = Env,
                {env, erlang:element(2, _record), case erlang:element(3, Env) of
                        paused ->
                            paused;

                        {running, Spinner, _} ->
                            spinner:stop(Spinner),
                            paused
                    end, erlang:element(4, _record), erlang:element(5, _record)}
            end,
            case erlang:element(2, Env@1) of
                true ->
                    nil;

                false ->
                    gleam_stdlib:println(
                        <<"✅ "/utf8,
                            (gleam_community@ansi:green(Message))/binary>>
                    )
            end,
            (erlang:element(2, Next()))(Env@1)
        end}.

-file("src/eensy_dev_tools/cli.gleam", 180).
-spec notify(binary(), fun(() -> cli(MVY))) -> cli(MVY).
notify(Message, Next) ->
    {cli,
        fun(Env) ->
            Env@1 = begin
                _record = Env,
                {env, erlang:element(2, _record), case erlang:element(3, Env) of
                        paused ->
                            paused;

                        {running, Spinner, _} ->
                            spinner:stop(Spinner),
                            paused
                    end, erlang:element(4, _record), erlang:element(5, _record)}
            end,
            case erlang:element(2, Env@1) of
                true ->
                    nil;

                false ->
                    gleam_stdlib:println(
                        gleam_community@ansi:bright_cyan(Message)
                    )
            end,
            (erlang:element(2, Next()))(Env@1)
        end}.

-file("src/eensy_dev_tools/cli.gleam", 199).
-spec mute() -> cli(nil).
mute() ->
    {cli,
        fun(Env) ->
            {begin
                    _record = Env,
                    {env,
                        true,
                        erlang:element(3, _record),
                        erlang:element(4, _record),
                        erlang:element(5, _record)}
                end,
                {ok, nil}}
        end}.

-file("src/eensy_dev_tools/cli.gleam", 205).
-spec unmute() -> cli(nil).
unmute() ->
    {cli,
        fun(Env) ->
            {begin
                    _record = Env,
                    {env,
                        false,
                        erlang:element(3, _record),
                        erlang:element(4, _record),
                        erlang:element(5, _record)}
                end,
                {ok, nil}}
        end}.

-file("src/eensy_dev_tools/cli.gleam", 213).
-spec get_config() -> cli(eensy_dev_tools@project:config()).
get_config() ->
    {cli, fun(Env) -> {Env, {ok, erlang:element(5, Env)}} end}.

-file("src/eensy_dev_tools/cli.gleam", 219).
-spec get_name() -> cli(binary()).
get_name() ->
    {cli,
        fun(Env) -> {Env, {ok, erlang:element(2, erlang:element(5, Env))}} end}.

-file("src/eensy_dev_tools/cli.gleam", 227).
-spec get_flags() -> cli(glint:flags()).
get_flags() ->
    {cli, fun(Env) -> {Env, {ok, erlang:element(4, Env)}} end}.

-file("src/eensy_dev_tools/cli.gleam", 233).
-spec get_config_value(
    binary(),
    MWG,
    list(binary()),
    fun((gleam@dict:dict(binary(), tom:toml()), list(binary())) -> {ok, MWG} |
        {error, any()}),
    fun((glint:flags()) -> {ok, MWG} | {error, any()})
) -> cli(MWG).
get_config_value(Name, Fallback, Namespace, Toml, Flag) ->
    {cli,
        fun(Env) ->
            Toml_path = gleam@list:flatten(
                [[<<"eensy"/utf8>>], Namespace, [Name]]
            ),
            Value = begin
                _pipe = gleam@result:'or'(
                    gleam@result:replace_error(
                        Flag(erlang:element(4, Env)),
                        nil
                    ),
                    gleam@result:replace_error(
                        Toml(
                            erlang:element(4, erlang:element(5, Env)),
                            Toml_path
                        ),
                        nil
                    )
                ),
                gleam@result:unwrap(_pipe, Fallback)
            end,
            {Env, {ok, Value}}
        end}.

-file("src/eensy_dev_tools/cli.gleam", 253).
-spec get_int(
    binary(),
    integer(),
    list(binary()),
    fun((glint:flags()) -> {ok, integer()} | {error, any()})
) -> cli(integer()).
get_int(Name, Fallback, Namespace, Flag) ->
    get_config_value(Name, Fallback, Namespace, fun tom:get_int/2, Flag).

-file("src/eensy_dev_tools/cli.gleam", 262).
-spec get_string(
    binary(),
    binary(),
    list(binary()),
    fun((glint:flags()) -> {ok, binary()} | {error, any()})
) -> cli(binary()).
get_string(Name, Fallback, Namespace, Flag) ->
    get_config_value(Name, Fallback, Namespace, fun tom:get_string/2, Flag).

-file("src/eensy_dev_tools/cli.gleam", 271).
-spec get_bool(
    binary(),
    boolean(),
    list(binary()),
    fun((glint:flags()) -> {ok, boolean()} | {error, any()})
) -> cli(boolean()).
get_bool(Name, Fallback, Namespace, Flag) ->
    get_config_value(Name, Fallback, Namespace, fun tom:get_bool/2, Flag).