mist_reload

-module(mist@reload).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/mist/reload.gleam").
-export([wrap/1]).
-export_type([message/1, reload_message/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 message(PPI) :: {register,
        gleam@erlang@process:subject(PPI),
        gleam@erlang@process:subject(nil)} |
    {broadcast, PPI}.

-type reload_message() :: reloaded.

-file("src/mist/reload.gleam", 106).
-spec loop(PPR, reload_message(), mist:s_s_e_connection()) -> gleam@otp@actor:next(PPR, any()).
loop(State, Message, Conn) ->
    case Message of
        reloaded ->
            _ = mist:send_event(
                Conn,
                mist:event(gleam_stdlib:identity(<<"reload"/utf8>>))
            ),
            gleam@otp@actor:continue(State)
    end.

-file("src/mist/reload.gleam", 93).
?DOC(" See `mist.send_file` to use this response type.\n").
-spec reload(
    gleam@erlang@process:subject(message(reload_message())),
    gleam@http@request:request(mist@internal@http:connection())
) -> gleam@http@response:response(mist:response_data()).
reload(Registry, Request) ->
    Init = fun(Self) ->
        nil = gleam@otp@actor:call(
            Registry,
            10,
            fun(_capture) -> {register, Self, _capture} end
        ),
        {ok, gleam@otp@actor:initialised(nil)}
    end,
    mist:server_sent_events(
        Request,
        gleam@http@response:new(200),
        Init,
        fun loop/3
    ).

-file("src/mist/reload.gleam", 56).
-spec debug_handler(
    gleam@erlang@process:subject(message(reload_message())),
    fun((gleam@http@request:request(mist@internal@http:connection())) -> gleam@http@response:response(mist:response_data()))
) -> fun((gleam@http@request:request(mist@internal@http:connection())) -> gleam@http@response:response(mist:response_data())).
debug_handler(Registry, Handler) ->
    fun(Request) ->
        Response = case gleam@http@request:path_segments(Request) of
            [<<"_reload"/utf8>>] ->
                reload(Registry, Request);

            _ ->
                Handler(Request)
        end,
        case erlang:element(4, Response) of
            {websocket, _} ->
                Response;

            {bytes, Tree} ->
                case gleam@http@response:get_header(
                    Response,
                    <<"content-type"/utf8>>
                ) of
                    {ok, <<"text/html"/utf8, _/binary>>} ->
                        Binary = erlang:list_to_bitstring(Tree),
                        case gleam@bit_array:to_string(Binary) of
                            {ok, Html} ->
                                _pipe = Html,
                                _pipe@1 = gleam@string:replace(
                                    _pipe,
                                    <<"</head>"/utf8>>,
                                    <<"<script>
  let reloading = false;
  const source = new EventSource(\"/_reload\");
  source.onmessage = (e) => {
    if (reloading) return;
    reloading = true;
    globalThis.setTimeout(() => window.location.reload(), 200);
  }
</script>"/utf8,
                                        "</head>"/utf8>>
                                ),
                                _pipe@2 = gleam_stdlib:wrap_list(_pipe@1),
                                _pipe@3 = {bytes, _pipe@2},
                                gleam@http@response:set_body(Response, _pipe@3);

                            {error, _} ->
                                Response
                        end;

                    _ ->
                        Response
                end;

            {chunked, _} ->
                Response;

            {file, _, _, _} ->
                Response;

            {server_sent_events, _} ->
                Response
        end
    end.

-file("src/mist/reload.gleam", 18).
-spec wrap(
    fun((gleam@http@request:request(mist@internal@http:connection())) -> gleam@http@response:response(mist:response_data()))
) -> fun((gleam@http@request:request(mist@internal@http:connection())) -> gleam@http@response:response(mist:response_data())).
wrap(Handler) ->
    Registry@1 = case begin
        _pipe = gleam@otp@actor:new(gleam@set:new()),
        _pipe@2 = gleam@otp@actor:on_message(
            _pipe,
            fun(State, Message) -> case Message of
                    {register, Subscriber, Reply} ->
                        gleam@otp@actor:send(Reply, nil),
                        _pipe@1 = gleam@set:insert(State, Subscriber),
                        gleam@otp@actor:continue(_pipe@1);

                    {broadcast, Payload} ->
                        gleam@set:each(
                            State,
                            fun(Pid) -> gleam@otp@actor:send(Pid, Payload) end
                        ),
                        gleam@otp@actor:continue(State)
                end end
        ),
        gleam@otp@actor:start(_pipe@2)
    end of
        {ok, Registry} -> Registry;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"mist/reload"/utf8>>,
                        function => <<"wrap"/utf8>>,
                        line => 19,
                        value => _assert_fail,
                        start => 374,
                        'end' => 816,
                        pattern_start => 385,
                        pattern_end => 397})
    end,
    _ = begin
        _pipe@3 = radiate:new(),
        _pipe@4 = radiate:add_dir(_pipe@3, <<"src"/utf8>>),
        _pipe@5 = radiate:on_reload(
            _pipe@4,
            fun(_, _) ->
                gleam@otp@actor:send(
                    erlang:element(3, Registry@1),
                    {broadcast, reloaded}
                )
            end
        ),
        radiate:start(_pipe@5)
    end,
    debug_handler(erlang:element(3, Registry@1), Handler).