glitch

-module(glitch@eventsub@websocket_server).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([start/1, new/1]).
-export_type([web_socker_server_state/0, status/0, message/0]).

-opaque web_socker_server_state() :: {state,
        gleam@erlang@process:subject(message()),
        gleam@option:option(gleam@erlang@process:subject(stratus:internal_message(nil))),
        status()}.

-type status() :: running | stopped.

-type message() :: start |
    shutdown |
    {web_socket_message, glitch@eventsub@websocket_message:web_socket_message()}.

-spec start(gleam@erlang@process:subject(message())) -> nil.
start(Websocket_server) ->
    gleam@otp@actor:send(Websocket_server, start).

-spec handle_start(web_socker_server_state()) -> gleam@otp@actor:next(any(), web_socker_server_state()).
handle_start(State) ->
    _assert_subject = gleam@http@request:to(
        <<"https://eventsub.wss.twitch.tv/ws"/utf8>>
    ),
    {ok, Req} = 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 => <<"glitch/eventsub/websocket_server"/utf8>>,
                        function => <<"handle_start"/utf8>>,
                        line => 70})
    end,
    _assert_subject@1 = begin
        _pipe@2 = stratus:websocket(
            Req,
            fun() -> {State, none} end,
            fun(Message, State@1, _) -> case Message of
                    {text, Message@1} ->
                        Decoded_message = begin
                            _pipe = glitch@eventsub@websocket_message:from_json(
                                Message@1
                            ),
                            _pipe@1 = gleam@result:map(
                                _pipe,
                                fun(Field@0) -> {web_socket_message, Field@0} end
                            ),
                            gleam@result:unwrap(
                                _pipe@1,
                                {web_socket_message,
                                    {unhandled_message, Message@1}}
                            )
                        end,
                        gleam@otp@actor:send(
                            erlang:element(2, State@1),
                            Decoded_message
                        ),
                        gleam@otp@actor:continue(State@1);

                    _ ->
                        gleam@io:println(
                            <<"Received unexpected message:"/utf8>>
                        ),
                        gleam@otp@actor:continue(State@1)
                end end
        ),
        _pipe@3 = stratus:on_close(
            _pipe@2,
            fun(State@2) ->
                gleam@erlang@process:send(
                    erlang:element(2, State@2),
                    {web_socket_message, close}
                )
            end
        ),
        stratus:initialize(_pipe@3)
    end,
    {ok, Websocket_client_subject} = 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 => <<"glitch/eventsub/websocket_server"/utf8>>,
                        function => <<"handle_start"/utf8>>,
                        line => 72})
    end,
    gleam@otp@actor:continue(
        erlang:setelement(
            4,
            erlang:setelement(3, State, {some, Websocket_client_subject}),
            running
        )
    ).

-spec handle_message(message(), web_socker_server_state()) -> gleam@otp@actor:next(any(), web_socker_server_state()).
handle_message(Message, State) ->
    case Message of
        shutdown ->
            {stop, normal};

        start ->
            handle_start(State);

        {web_socket_message, _} ->
            gleam@otp@actor:continue(State)
    end.

-spec new(gleam@erlang@process:subject(gleam@erlang@process:subject(message()))) -> {ok,
        gleam@erlang@process:subject(message())} |
    {error, gleam@otp@actor:start_error()}.
new(Parent_subject) ->
    gleam@otp@actor:start_spec(
        {spec,
            fun() ->
                Self = gleam@erlang@process:new_subject(),
                gleam@erlang@process:send(Parent_subject, Self),
                Selector = gleam@erlang@process:selecting(
                    gleam_erlang_ffi:new_selector(),
                    Self,
                    fun gleam@function:identity/1
                ),
                Initial_state = {state, Self, none, stopped},
                {ready, Initial_state, Selector}
            end,
            1000,
            fun handle_message/2}
    ).