ewe

-module(ewe@internal@websocket).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/ewe/internal/websocket.gleam").
-export([send_binary_frame/3, send_text_frame/3, start/4]).
-export_type([exit_reason/0, next/1, state/1, websocket_connection/0, valid_glisten_message/0, glisten_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.

?MODULEDOC(false).

-type exit_reason() :: normal | {abnormal, binary()}.

-type next(KOG) :: {continue, KOG} | {stop, exit_reason()}.

-type state(KOH) :: {state, websocket_connection(), KOH, bitstring()}.

-type websocket_connection() :: {websocket_connection,
        glisten@transport:transport(),
        glisten@socket:socket()}.

-type valid_glisten_message() :: {packet, bitstring()} | close.

-type glisten_message() :: {valid, valid_glisten_message()} | invalid.

-file("src/ewe/internal/websocket.gleam", 49).
?DOC(false).
-spec select_valid_record(
    gleam@erlang@process:selector(glisten_message()),
    binary()
) -> gleam@erlang@process:selector(glisten_message()).
select_valid_record(Selector, Binary_atom) ->
    gleam@erlang@process:select_record(
        Selector,
        erlang:binary_to_atom(Binary_atom),
        2,
        fun(Record) ->
            _pipe = gleam@dynamic@decode:run(
                Record,
                begin
                    gleam@dynamic@decode:field(
                        2,
                        {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
                        fun(Data) ->
                            gleam@dynamic@decode:success(
                                {valid, {packet, Data}}
                            )
                        end
                    )
                end
            ),
            gleam@result:unwrap(_pipe, invalid)
        end
    ).

-file("src/ewe/internal/websocket.gleam", 62).
?DOC(false).
-spec glisten_selector() -> gleam@erlang@process:selector(glisten_message()).
glisten_selector() ->
    _pipe = gleam_erlang_ffi:new_selector(),
    _pipe@1 = select_valid_record(_pipe, <<"tcp"/utf8>>),
    _pipe@2 = select_valid_record(_pipe@1, <<"ssl"/utf8>>),
    _pipe@3 = gleam@erlang@process:select_record(
        _pipe@2,
        erlang:binary_to_atom(<<"tcp_closed"/utf8>>),
        1,
        fun(_) -> {valid, close} end
    ),
    gleam@erlang@process:select_record(
        _pipe@3,
        erlang:binary_to_atom(<<"ssl_closed"/utf8>>),
        1,
        fun(_) -> {valid, close} end
    ).

-file("src/ewe/internal/websocket.gleam", 137).
?DOC(false).
-spec loop_by_frames(
    list(gramps@websocket:frame()),
    websocket_connection(),
    fun((websocket_connection(), KOX, gramps@websocket:frame()) -> next(KOX)),
    next(KOX)
) -> next(KOX).
loop_by_frames(Frames, Conn, Handler, Next) ->
    case {Frames, Next} of
        {_, {stop, normal}} ->
            {stop, normal};

        {_, {stop, {abnormal, Reason}}} ->
            {stop, {abnormal, Reason}};

        {[], Next@1} ->
            Next@1;

        {[{control, {ping_frame, Payload}}], {continue, User_state}} ->
            Sent = glisten@transport:send(
                erlang:element(2, Conn),
                erlang:element(3, Conn),
                gramps@websocket:encode_pong_frame(Payload, none)
            ),
            case Sent of
                {ok, nil} ->
                    {continue, User_state};

                {error, _} ->
                    {stop, {abnormal, <<"Failed to send PONG frame"/utf8>>}}
            end;

        {[{control, {close_frame, Reason@1}}], {continue, _}} ->
            _ = glisten@transport:send(
                erlang:element(2, Conn),
                erlang:element(3, Conn),
                gramps@websocket:encode_close_frame(Reason@1, none)
            ),
            {stop, normal};

        {[Frame | Rest], {continue, User_state@1}} ->
            case ewe_ffi:rescue(fun() -> Handler(Conn, User_state@1, Frame) end) of
                {ok, {continue, New_user_state}} ->
                    loop_by_frames(
                        Rest,
                        Conn,
                        Handler,
                        {continue, New_user_state}
                    );

                {ok, Stop} ->
                    Stop;

                {error, _} ->
                    {stop, {abnormal, <<"Crash in websocket handler"/utf8>>}}
            end
    end.

-file("src/ewe/internal/websocket.gleam", 209).
?DOC(false).
-spec send_binary_frame(
    glisten@transport:transport(),
    glisten@socket:socket(),
    bitstring()
) -> {ok, nil} | {error, glisten@socket:socket_reason()}.
send_binary_frame(Transport, Socket, Bits) ->
    _pipe = gramps@websocket:encode_binary_frame(Bits, none, none),
    glisten@transport:send(Transport, Socket, _pipe).

-file("src/ewe/internal/websocket.gleam", 218).
?DOC(false).
-spec send_text_frame(
    glisten@transport:transport(),
    glisten@socket:socket(),
    binary()
) -> {ok, nil} | {error, glisten@socket:socket_reason()}.
send_text_frame(Transport, Socket, Text) ->
    _pipe = gramps@websocket:encode_text_frame(Text, none, none),
    glisten@transport:send(Transport, Socket, _pipe).

-file("src/ewe/internal/websocket.gleam", 228).
?DOC(false).
-spec set_socket_active_once(
    glisten@transport:transport(),
    glisten@socket:socket()
) -> nil.
set_socket_active_once(Transport, Socket) ->
    _ = glisten@transport:set_opts(Transport, Socket, [{active_mode, once}]),
    nil.

-file("src/ewe/internal/websocket.gleam", 188).
?DOC(false).
-spec after_start(
    gleam@otp@actor:started(gleam@erlang@process:subject(glisten_message())),
    glisten@transport:transport(),
    glisten@socket:socket()
) -> gleam@erlang@process:selector(gleam@erlang@process:down()).
after_start(Started, Transport, Socket) ->
    Pid@1 = case gleam@erlang@process:subject_owner(erlang:element(3, Started)) of
        {ok, Pid} -> Pid;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"ewe/internal/websocket"/utf8>>,
                        function => <<"after_start"/utf8>>,
                        line => 194,
                        value => _assert_fail,
                        start => 5450,
                        'end' => 5506,
                        pattern_start => 5461,
                        pattern_end => 5468})
    end,
    _ = glisten@transport:controlling_process(Transport, Socket, Pid@1),
    set_socket_active_once(Transport, Socket),
    Selector = gleam@erlang@process:select_specific_monitor(
        gleam_erlang_ffi:new_selector(),
        gleam@erlang@process:monitor(Pid@1),
        fun gleam@function:identity/1
    ),
    Selector.

-file("src/ewe/internal/websocket.gleam", 104).
?DOC(false).
-spec handle_valid_packet(
    state(KOQ),
    bitstring(),
    glisten@transport:transport(),
    glisten@socket:socket(),
    fun((websocket_connection(), KOQ, gramps@websocket:frame()) -> next(KOQ))
) -> gleam@otp@actor:next(state(KOQ), glisten_message()).
handle_valid_packet(State, Data, Transport, Socket, Handler) ->
    {Frames, Rest} = gramps@websocket:decode_many_frames(
        <<(erlang:element(4, State))/bitstring, Data/bitstring>>,
        none,
        []
    ),
    Next = begin
        _pipe = gramps@websocket:aggregate_frames(Frames, none, []),
        gleam@result:map(
            _pipe,
            fun(_capture) ->
                loop_by_frames(
                    _capture,
                    erlang:element(2, State),
                    Handler,
                    {continue, erlang:element(3, State)}
                )
            end
        )
    end,
    case Next of
        {ok, {continue, New_user_state}} ->
            set_socket_active_once(Transport, Socket),
            gleam@otp@actor:continue(
                {state, erlang:element(2, State), New_user_state, Rest}
            );

        {ok, {stop, normal}} ->
            gleam@otp@actor:stop();

        {ok, {stop, {abnormal, Reason}}} ->
            gleam@otp@actor:stop_abnormal(Reason);

        {error, nil} ->
            gleam@otp@actor:stop_abnormal(<<"Received malformed message"/utf8>>)
    end.

-file("src/ewe/internal/websocket.gleam", 76).
?DOC(false).
-spec start(
    glisten@transport:transport(),
    glisten@socket:socket(),
    fun((websocket_connection()) -> KOL),
    fun((websocket_connection(), KOL, gramps@websocket:frame()) -> next(KOL))
) -> {ok, gleam@erlang@process:selector(gleam@erlang@process:down())} |
    {error, gleam@otp@actor:start_error()}.
start(Transport, Socket, On_init, Handler) ->
    _pipe@3 = gleam@otp@actor:new_with_initialiser(
        1000,
        fun(Subject) ->
            Conn = {websocket_connection, Transport, Socket},
            User_state = On_init(Conn),
            _pipe = gleam@otp@actor:initialised({state, Conn, User_state, <<>>}),
            _pipe@1 = gleam@otp@actor:selecting(_pipe, glisten_selector()),
            _pipe@2 = gleam@otp@actor:returning(_pipe@1, Subject),
            {ok, _pipe@2}
        end
    ),
    _pipe@4 = gleam@otp@actor:on_message(_pipe@3, fun(State, Msg) -> case Msg of
                {valid, {packet, Data}} ->
                    handle_valid_packet(State, Data, Transport, Socket, Handler);

                {valid, close} ->
                    gleam@otp@actor:stop();

                invalid ->
                    gleam@otp@actor:stop_abnormal(
                        <<"Received malformed message"/utf8>>
                    )
            end end),
    _pipe@5 = gleam@otp@actor:start(_pipe@4),
    gleam@result:map(
        _pipe@5,
        fun(_capture) -> after_start(_capture, Transport, Socket) end
    ).