-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([start/3]).
-export_type([exit_reason/0, next/0, state/0, 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() :: continue | {stop, exit_reason()}.

-type state() :: {state, websocket_connection(), 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", 48).
?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", 61).
?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", 127).
?DOC(false).
-spec loop_by_frames(
    list(gramps@websocket:frame()),
    glisten@transport:transport(),
    glisten@socket:socket(),
    fun((gramps@websocket:frame()) -> next()),
    next()
) -> next().
loop_by_frames(Frames, Transport, Socket, 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} ->
            Sent = glisten@transport:send(
                Transport,
                Socket,
                gramps@websocket:encode_pong_frame(Payload, none)
            ),
            case Sent of
                {ok, nil} ->
                    continue;

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

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

        {[Frame | Rest], continue} ->
            case ewe_ffi:rescue(fun() -> Handler(Frame) end) of
                {ok, continue} ->
                    loop_by_frames(Rest, Transport, Socket, Handler, continue);

                {ok, Stop} ->
                    Stop;

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

-file("src/ewe/internal/websocket.gleam", 193).
?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", 171).
?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 => 177,
                        value => _assert_fail,
                        start => 4859,
                        'end' => 4915,
                        pattern_start => 4870,
                        pattern_end => 4877})
    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", 99).
?DOC(false).
-spec handle_valid_packet(
    state(),
    bitstring(),
    glisten@transport:transport(),
    glisten@socket:socket(),
    fun((gramps@websocket:frame()) -> next())
) -> gleam@otp@actor:next(state(), glisten_message()).
handle_valid_packet(State, Data, Transport, Socket, Handler) ->
    {Frames, Rest} = gramps@websocket:decode_many_frames(
        <<(erlang:element(3, State))/bitstring, Data/bitstring>>,
        none,
        []
    ),
    Next = begin
        _pipe = gramps@websocket:aggregate_frames(Frames, none, []),
        gleam@result:map(
            _pipe,
            fun(_capture) ->
                loop_by_frames(_capture, Transport, Socket, Handler, continue)
            end
        )
    end,
    case Next of
        {ok, continue} ->
            set_socket_active_once(Transport, Socket),
            gleam@otp@actor:continue({state, erlang:element(2, 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", 75).
?DOC(false).
-spec start(
    glisten@transport:transport(),
    glisten@socket:socket(),
    fun((gramps@websocket:frame()) -> next())
) -> {ok, gleam@erlang@process:selector(gleam@erlang@process:down())} |
    {error, gleam@otp@actor:start_error()}.
start(Transport, Socket, Handler) ->
    _pipe@3 = gleam@otp@actor:new_with_initialiser(
        1000,
        fun(Subject) ->
            Conn = {websocket_connection, Transport, Socket},
            _pipe = gleam@otp@actor:initialised({state, Conn, <<>>}),
            _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
    ).