sprocket

-module(docs).
-compile([no_auto_import, nowarn_unused_vars]).

-export([main/0]).

-spec handle_ws_message(
    nil,
    mist@internal@websocket:websocket_connection(),
    mist:websocket_message(any()),
    sprocket@cassette:live_service()
) -> gleam@otp@actor:next(any(), nil).
handle_ws_message(State, Conn, Message, Live_service) ->
    {live_service, Id, On_msg, _, On_close} = Live_service,
    case Message of
        {text, Msg} ->
            _assert_subject = gleam@bit_string:to_string(Msg),
            {ok, Msg@1} = case _assert_subject of
                {ok, _} -> _assert_subject;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Assertion pattern match failed"/utf8>>,
                                value => _assert_fail,
                                module => <<"docs"/utf8>>,
                                function => <<"handle_ws_message"/utf8>>,
                                line => 62})
            end,
            _ = On_msg(
                Msg@1,
                Id,
                fun(Msg@2) ->
                    _assert_subject@1 = mist:send_text_frame(
                        Conn,
                        gleam@bit_string:from_string(Msg@2)
                    ),
                    {ok, _} = case _assert_subject@1 of
                        {ok, _} -> _assert_subject@1;
                        _assert_fail@1 ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Assertion pattern match failed"/utf8>>,
                                        value => _assert_fail@1,
                                        module => <<"docs"/utf8>>,
                                        function => <<"handle_ws_message"/utf8>>,
                                        line => 69})
                    end,
                    {ok, nil}
                end
            ),
            gleam@otp@actor:continue(State);

        closed ->
            _ = On_close(Id),
            {stop, normal};

        shutdown ->
            _ = On_close(Id),
            {stop, normal};

        _ ->
            docs@utils@logger:info(
                <<"Received unsupported websocket message type"/utf8>>
            ),
            gleam@otp@actor:continue(State)
    end.

-spec live_service(
    gleam@http@request:request(mist@internal@http:connection()),
    gleam@erlang@process:subject(sprocket@cassette:message())
) -> gleam@http@response:response(mist:response_data()).
live_service(Req, Ca) ->
    Live_service = sprocket@cassette:live_service(Ca),
    Selector = gleam@erlang@process:new_selector(),
    _pipe = mist:websocket(Req),
    _pipe@1 = mist:with_state(_pipe, nil),
    _pipe@2 = mist:selecting(_pipe@1, Selector),
    _pipe@3 = mist:on_message(
        _pipe@2,
        fun(State, Conn, Message) ->
            handle_ws_message(State, Conn, Message, Live_service)
        end
    ),
    mist:upgrade(_pipe@3).

-spec mist_response(
    gleam@http@response:response(gleam@bit_builder:bit_builder())
) -> gleam@http@response:response(mist:response_data()).
mist_response(Response) ->
    _pipe = gleam@http@response:new(erlang:element(2, Response)),
    gleam@http@response:set_body(_pipe, {bytes, erlang:element(4, Response)}).

-spec http_service(
    gleam@http@request:request(mist@internal@http:connection()),
    fun((gleam@http@request:request(bitstring())) -> gleam@http@response:response(gleam@bit_builder:bit_builder()))
) -> gleam@http@response:response(mist:response_data()).
http_service(Req, Router) ->
    _pipe = Req,
    _pipe@1 = mist:read_body(_pipe, (1024 * 1024) * 10),
    _pipe@4 = gleam@result:map(_pipe@1, fun(Http_req) -> _pipe@2 = Http_req,
            _pipe@3 = Router(_pipe@2),
            mist_response(_pipe@3) end),
    gleam@result:unwrap(
        _pipe@4,
        begin
            _pipe@5 = gleam@http@response:new(500),
            gleam@http@response:set_body(
                _pipe@5,
                {bytes, gleam@bit_builder:new()}
            )
        end
    ).

-spec load_port() -> integer().
load_port() ->
    _pipe = gleam@erlang@os:get_env(<<"PORT"/utf8>>),
    _pipe@1 = gleam@result:then(_pipe, fun gleam@int:parse/1),
    gleam@result:unwrap(_pipe@1, 3000).

-spec main() -> nil.
main() ->
    docs@utils@logger:configure_backend(),
    Port = load_port(),
    Ca = sprocket@cassette:start(none),
    Router = docs@routes:stack({app_context, Ca}),
    _pipe = fun(Req) ->
        case {erlang:element(2, Req), gleam@http@request:path_segments(Req)} of
            {get, [<<"live"/utf8>>]} ->
                live_service(Req, Ca);

            {_, _} ->
                http_service(Req, Router)
        end
    end,
    _pipe@1 = mist:new(_pipe),
    _pipe@2 = mist:port(_pipe@1, Port),
    mist:start_http(_pipe@2),
    _pipe@3 = gleam@string:concat(
        [<<"Listening on localhost:"/utf8>>,
            gleam@int:to_string(Port),
            <<" ✨"/utf8>>]
    ),
    docs@utils@logger:info(_pipe@3),
    gleam@erlang@process:sleep_forever().