mcp_toolkit

-module(mcp_toolkit@transport@sse).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/mcp_toolkit/transport/sse.gleam").
-export([start_registry/0, handle_get/2, handle_post/3]).
-export_type([sse_msg/0, registry_msg/0]).

-type sse_msg() :: {push, binary()} | stop.

-type registry_msg() :: {alloc, gleam@erlang@process:subject(binary())} |
    {put, binary(), gleam@erlang@process:subject(sse_msg())} |
    {remove, binary()} |
    {get,
        binary(),
        gleam@erlang@process:subject(gleam@option:option(gleam@erlang@process:subject(sse_msg())))}.

-file("src/mcp_toolkit/transport/sse.gleam", 31).
-spec start_registry() -> gleam@erlang@process:subject(registry_msg()).
start_registry() ->
    Loop = fun(State, Msg) ->
        {Table, Next_id} = State,
        case Msg of
            {alloc, Reply} ->
                Id = <<"sse_"/utf8, (erlang:integer_to_binary(Next_id))/binary>>,
                gleam@erlang@process:send(Reply, Id),
                gleam@otp@actor:continue({Table, Next_id + 1});

            {put, Id@1, Subj} ->
                gleam@otp@actor:continue(
                    {gleam@dict:insert(Table, Id@1, Subj), Next_id}
                );

            {remove, Id@2} ->
                gleam@otp@actor:continue(
                    {gleam@dict:delete(Table, Id@2), Next_id}
                );

            {get, Id@3, Reply@1} ->
                Subject_opt = case gleam_stdlib:map_get(Table, Id@3) of
                    {ok, S} ->
                        {some, S};

                    {error, _} ->
                        none
                end,
                gleam@erlang@process:send(Reply@1, Subject_opt),
                gleam@otp@actor:continue(State)
        end
    end,
    Started@1 = case begin
        _pipe = gleam@otp@actor:new({maps:new(), 1}),
        _pipe@1 = gleam@otp@actor:on_message(_pipe, Loop),
        gleam@otp@actor:start(_pipe@1)
    end of
        {ok, Started} -> Started;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"mcp_toolkit/transport/sse"/utf8>>,
                        function => <<"start_registry"/utf8>>,
                        line => 56,
                        value => _assert_fail,
                        start => 1357,
                        'end' => 1462,
                        pattern_start => 1368,
                        pattern_end => 1379})
    end,
    erlang:element(3, Started@1).

-file("src/mcp_toolkit/transport/sse.gleam", 64).
-spec handle_get(
    gleam@http@request:request(mist@internal@http:connection()),
    gleam@erlang@process:subject(registry_msg())
) -> gleam@http@response:response(mist:response_data()).
handle_get(Req, Registry) ->
    Id_reply = gleam@erlang@process:new_subject(),
    gleam@erlang@process:send(Registry, {alloc, Id_reply}),
    Id@1 = case gleam@erlang@process:'receive'(Id_reply, 500) of
        {ok, Id} -> Id;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"mcp_toolkit/transport/sse"/utf8>>,
                        function => <<"handle_get"/utf8>>,
                        line => 70,
                        value => _assert_fail,
                        start => 1711,
                        'end' => 1769,
                        pattern_start => 1722,
                        pattern_end => 1728})
    end,
    Initial = begin
        _pipe = gleam@http@response:new(200),
        gleam@http@response:set_header(_pipe, <<"X-Conn-Id"/utf8>>, Id@1)
    end,
    Init = fun(Subject) ->
        gleam@erlang@process:send(Registry, {put, Id@1, Subject}),
        {ok, gleam@otp@actor:initialised(Id@1)}
    end,
    Loop = fun(State, Message, Conn) -> case Message of
            {push, Text} ->
                Event = begin
                    _pipe@1 = gleam_stdlib:identity(Text),
                    _pipe@2 = mist:event(_pipe@1),
                    mist:event_name(_pipe@2, <<"mcp-message"/utf8>>)
                end,
                _ = mist:send_event(Conn, Event),
                gleam@otp@actor:continue(State);

            stop ->
                gleam@otp@actor:stop()
        end end,
    mist:server_sent_events(Req, Initial, Init, Loop).

-file("src/mcp_toolkit/transport/sse.gleam", 101).
-spec handle_post(
    gleam@http@request:request(mist@internal@http:connection()),
    gleam@erlang@process:subject(registry_msg()),
    mcp_toolkit@core@server:server()
) -> gleam@http@response:response(mist:response_data()).
handle_post(Req, Registry, Srv) ->
    Id = case gleam@http@request:get_query(Req) of
        {ok, Qs} ->
            _pipe = Qs,
            _pipe@1 = gleam@list:find(
                _pipe,
                fun(Pair) ->
                    {K, _} = Pair,
                    K =:= <<"id"/utf8>>
                end
            ),
            _pipe@2 = gleam@result:map(
                _pipe@1,
                fun(Pair@1) ->
                    {_, V} = Pair@1,
                    V
                end
            ),
            gleam@result:unwrap(_pipe@2, <<""/utf8>>);

        {error, _} ->
            <<""/utf8>>
    end,
    case Id of
        <<""/utf8>> ->
            _pipe@3 = gleam@http@response:new(400),
            gleam@http@response:set_body(
                _pipe@3,
                {bytes, gleam_stdlib:wrap_list(<<"missing id"/utf8>>)}
            );

        _ ->
            case mist:read_body(Req, 1000000) of
                {ok, Req@1} ->
                    Body_bits = erlang:element(4, Req@1),
                    Body = case gleam@bit_array:to_string(Body_bits) of
                        {ok, S} ->
                            S;

                        {error, _} ->
                            <<""/utf8>>
                    end,
                    Out = case mcp_toolkit@core@server:handle_message(Srv, Body) of
                        {ok, {some, J}} ->
                            gleam@json:to_string(J);

                        {error, J@1} ->
                            gleam@json:to_string(J@1);

                        _ ->
                            <<""/utf8>>
                    end,
                    Reply = gleam@erlang@process:new_subject(),
                    gleam@erlang@process:send(Registry, {get, Id, Reply}),
                    Subject_opt = begin
                        _pipe@4 = gleam@erlang@process:'receive'(Reply, 200),
                        gleam@result:unwrap(_pipe@4, none)
                    end,
                    _ = case Subject_opt of
                        {some, Subj} ->
                            gleam@erlang@process:send(Subj, {push, Out});

                        none ->
                            nil
                    end,
                    _pipe@5 = gleam@http@response:new(200),
                    _pipe@6 = gleam@http@response:set_header(
                        _pipe@5,
                        <<"Content-Type"/utf8>>,
                        <<"application/json"/utf8>>
                    ),
                    gleam@http@response:set_body(
                        _pipe@6,
                        {bytes, gleam_stdlib:wrap_list(Out)}
                    );

                {error, _} ->
                    _pipe@7 = gleam@http@response:new(400),
                    gleam@http@response:set_body(
                        _pipe@7,
                        {bytes, gleam_stdlib:wrap_list(<<"invalid body"/utf8>>)}
                    )
            end
    end.