glitch

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

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

-opaque web_socker_server() :: {state,
        gleam@erlang@process:subject(glitch@eventsub@websocket_message:web_socket_message()),
        gleam@option:option(gleam@erlang@process:subject(stratus:internal_message(nil))),
        status()}.

-type status() :: running | stopped.

-type message() :: start | shutdown.

-type msg() :: close | {time_updated, binary()}.

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

-spec handle_start(web_socker_server()) -> gleam@otp@actor:next(any(), web_socker_server()).
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 => 74})
    end,
    _assert_subject@1 = begin
        _pipe@1 = 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
                            ),
                            gleam@result:unwrap(
                                _pipe,
                                {unhandled_message, Message@1}
                            )
                        end,
                        gleam@erlang@process: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@2 = stratus:on_close(
            _pipe@1,
            fun(State@2) ->
                gleam@erlang@process:send(erlang:element(2, State@2), close)
            end
        ),
        stratus:initialize(_pipe@2)
    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 => 76})
    end,
    gleam@otp@actor:continue(
        erlang:setelement(
            4,
            erlang:setelement(3, State, {some, Websocket_client_subject}),
            running
        )
    ).

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

        start ->
            handle_start(State)
    end.

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