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

-export([new/0, add_dir/2, on_reload/2, set_initializer/2, start_state/1, start/1]).
-export_type([no_directories/0, has_directories/0, no_initializer/0, has_initializer/0, builder/3, module_/0, what/0]).

-type no_directories() :: any().

-type has_directories() :: any().

-type no_initializer() :: any().

-type has_initializer() :: any().

-opaque builder(HRS, HRT, HRU) :: {builder,
        list(binary()),
        gleam@option:option(fun((HRS, binary()) -> HRS)),
        gleam@option:option(fun(() -> HRS))} |
    {gleam_phantom, HRT, HRU}.

-type module_() :: any().

-type what() :: any().

-spec new() -> builder(nil, no_directories(), no_initializer()).
new() ->
    {builder, [], none, none}.

-spec add_dir(builder(HRY, any(), HSA), binary()) -> builder(HRY, has_directories(), HSA).
add_dir(Builder, Dir) ->
    {builder,
        [Dir | erlang:element(2, Builder)],
        erlang:element(3, Builder),
        erlang:element(4, Builder)}.

-spec on_reload(builder(HSH, HSI, HSJ), fun((HSH, binary()) -> HSH)) -> builder(HSH, HSI, HSJ).
on_reload(Builder, Callback) ->
    {builder,
        erlang:element(2, Builder),
        {some, Callback},
        erlang:element(4, Builder)}.

-spec set_initializer(builder(HSQ, HSR, no_initializer()), fun(() -> HSQ)) -> builder(HSQ, HSR, has_initializer()).
set_initializer(Builder, Initializer) ->
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        {some, Initializer}}.

-spec start_state(builder(any(), has_directories(), has_initializer())) -> {ok,
        gleam@erlang@process:subject(filespy:change())} |
    {error, gleam@otp@actor:start_error()}.
start_state(Builder) ->
    _pipe = filespy:new(),
    _pipe@1 = filespy:set_initializer(
        _pipe,
        fun() ->
            _assert_subject = erlang:element(4, Builder),
            {some, Init} = case _assert_subject of
                {some, _} -> _assert_subject;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Assertion pattern match failed"/utf8>>,
                                value => _assert_fail,
                                module => <<"radiate"/utf8>>,
                                function => <<"start_state"/utf8>>,
                                line => 97})
            end,
            Init()
        end
    ),
    _pipe@2 = filespy:add_dirs(_pipe@1, erlang:element(2, Builder)),
    _pipe@5 = filespy:set_actor_handler(
        _pipe@2,
        fun(Msg, State) ->
            {change, Path, Events} = Msg,
            _pipe@4 = gleam@list:fold(
                Events,
                State,
                fun(State@1, Event) -> case Event of
                        closed ->
                            case gleam@string:ends_with(Path, <<".gleam"/utf8>>) of
                                true ->
                                    Build_result = shellout:command(
                                        <<"gleam"/utf8>>,
                                        [<<"build"/utf8>>],
                                        <<"."/utf8>>,
                                        []
                                    ),
                                    case Build_result of
                                        {ok, _} ->
                                            Mods = code:modified_modules(),
                                            gleam@list:each(
                                                Mods,
                                                fun code:purge/1
                                            ),
                                            _ = code:atomic_load(Mods),
                                            case erlang:element(3, Builder) of
                                                {some, Cb} ->
                                                    Cb(State@1, Path);

                                                none ->
                                                    State@1
                                            end;

                                        {error, {_, Message}} ->
                                            _pipe@3 = Message,
                                            gleam@io:print_error(_pipe@3),
                                            State@1
                                    end;

                                _ ->
                                    State@1
                            end;

                        _ ->
                            State@1
                    end end
            ),
            gleam@otp@actor:continue(_pipe@4)
        end
    ),
    filespy:start(_pipe@5).

-spec start(builder(nil, has_directories(), no_initializer())) -> {ok,
        gleam@erlang@process:subject(filespy:change())} |
    {error, gleam@otp@actor:start_error()}.
start(Builder) ->
    _pipe = Builder,
    _pipe@1 = set_initializer(_pipe, fun() -> nil end),
    start_state(_pipe@1).