gramps

-module(gramps).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([frame_from_message/1, frame_to_bytes_builder/2, to_text_frame/2, to_binary_frame/2, parse_websocket_key/1]).
-export_type([data_frame/0, control_frame/0, frame/0, frame_parse_error/0, parsed_frame/0, sha_hash/0]).

-type data_frame() :: {text_frame, integer(), bitstring()} |
    {binary_frame, integer(), bitstring()}.

-type control_frame() :: {close_frame, integer(), bitstring()} |
    {ping_frame, integer(), bitstring()} |
    {pong_frame, integer(), bitstring()}.

-type frame() :: {data, data_frame()} |
    {control, control_frame()} |
    {continuation, integer(), bitstring()}.

-type frame_parse_error() :: {need_more_data, bitstring()} | invalid_frame.

-type parsed_frame() :: {complete, frame()} | {incomplete, frame()}.

-type sha_hash() :: sha.

-spec unmask_data(bitstring(), list(bitstring()), integer(), bitstring()) -> bitstring().
unmask_data(Data, Masks, Index, Resp) ->
    case Data of
        <<Masked:8/bitstring, Rest/bitstring>> ->
            _assert_subject = gleam@list:at(Masks, Index rem 4),
            {ok, Mask_value} = 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 => <<"gramps"/utf8>>,
                                function => <<"unmask_data"/utf8>>,
                                line => 37})
            end,
            Unmasked = crypto:exor(Mask_value, Masked),
            unmask_data(
                Rest,
                Masks,
                Index + 1,
                <<Resp/bitstring, Unmasked/bitstring>>
            );

        _ ->
            Resp
    end.

-spec frame_from_message(bitstring()) -> {ok, {parsed_frame(), bitstring()}} |
    {error, frame_parse_error()}.
frame_from_message(Message) ->
    case Message of
        <<Complete:1,
            _:3,
            Opcode:4/integer,
            Mask:1,
            Payload_length:7/integer,
            Rest/bitstring>> ->
            Payload_size = case Payload_length of
                126 ->
                    16;

                127 ->
                    64;

                _ ->
                    0
            end,
            Masked = case Mask of
                1 ->
                    true;

                0 ->
                    false;

                _ ->
                    erlang:error(#{gleam_error => panic,
                            message => <<"Somehow a bit wasn't 0 or 1"/utf8>>,
                            module => <<"gramps"/utf8>>,
                            function => <<"frame_from_message"/utf8>>,
                            line => 75})
            end,
            case {Masked, Rest} of
                {true,
                    <<Length:Payload_size/integer,
                        Mask1:1/binary,
                        Mask2:1/binary,
                        Mask3:1/binary,
                        Mask4:1/binary,
                        Rest@1/bitstring>>} ->
                    Payload_byte_size = case Length of
                        0 ->
                            Payload_length;

                        N ->
                            N
                    end,
                    case Rest@1 of
                        <<Payload:Payload_byte_size/binary, Rest@2/bitstring>> ->
                            Data = unmask_data(
                                Payload,
                                [Mask1, Mask2, Mask3, Mask4],
                                0,
                                <<>>
                            ),
                            _pipe = case Opcode of
                                0 ->
                                    {ok, {continuation, Payload_length, Data}};

                                1 ->
                                    {ok,
                                        {data,
                                            {text_frame, Payload_length, Data}}};

                                2 ->
                                    {ok,
                                        {data,
                                            {binary_frame, Payload_length, Data}}};

                                8 ->
                                    {ok,
                                        {control,
                                            {close_frame, Payload_length, Data}}};

                                9 ->
                                    {ok,
                                        {control,
                                            {ping_frame, Payload_length, Data}}};

                                10 ->
                                    {ok,
                                        {control,
                                            {pong_frame, Payload_length, Data}}};

                                _ ->
                                    {error, invalid_frame}
                            end,
                            gleam@result:then(
                                _pipe,
                                fun(Frame) -> case Complete of
                                        1 ->
                                            {ok, {{complete, Frame}, Rest@2}};

                                        0 ->
                                            {ok, {{incomplete, Frame}, Rest@2}};

                                        _ ->
                                            {error, invalid_frame}
                                    end end
                            );

                        _ ->
                            {error, {need_more_data, Message}}
                    end;

                {false, <<Length@1:Payload_size/integer, Rest@3/bitstring>>} ->
                    Payload_byte_size@1 = case Length@1 of
                        0 ->
                            Payload_length;

                        N@1 ->
                            N@1
                    end,
                    case Rest@3 of
                        <<Payload@1:Payload_byte_size@1/binary,
                            Rest@4/bitstring>> ->
                            _pipe@1 = case Opcode of
                                0 ->
                                    {ok,
                                        {continuation,
                                            Payload_length,
                                            Payload@1}};

                                1 ->
                                    {ok,
                                        {data,
                                            {text_frame,
                                                Payload_length,
                                                Payload@1}}};

                                2 ->
                                    {ok,
                                        {data,
                                            {binary_frame,
                                                Payload_length,
                                                Payload@1}}};

                                8 ->
                                    {ok,
                                        {control,
                                            {close_frame,
                                                Payload_length,
                                                Payload@1}}};

                                9 ->
                                    {ok,
                                        {control,
                                            {ping_frame,
                                                Payload_length,
                                                Payload@1}}};

                                10 ->
                                    {ok,
                                        {control,
                                            {pong_frame,
                                                Payload_length,
                                                Payload@1}}};

                                _ ->
                                    {error, invalid_frame}
                            end,
                            gleam@result:then(
                                _pipe@1,
                                fun(Frame@1) -> case Complete of
                                        1 ->
                                            {ok, {{complete, Frame@1}, Rest@4}};

                                        0 ->
                                            {ok,
                                                {{incomplete, Frame@1}, Rest@4}};

                                        _ ->
                                            {error, invalid_frame}
                                    end end
                            );

                        _ ->
                            {error, {need_more_data, Message}}
                    end;

                {_, _} ->
                    {error, invalid_frame}
            end;

        _ ->
            {error, invalid_frame}
    end.

-spec make_frame(
    integer(),
    integer(),
    bitstring(),
    gleam@option:option(bitstring())
) -> gleam@bytes_builder:bytes_builder().
make_frame(Opcode, Length, Payload, Mask) ->
    Length_section = case Length of
        Length@1 when Length@1 > 65535 ->
            <<127:7, Length@1:64/integer>>;

        Length@2 when Length@2 >= 126 ->
            <<126:7, Length@2:16/integer>>;

        _ ->
            <<Length:7>>
    end,
    Masked = case gleam@option:is_some(Mask) of
        true ->
            1;

        false ->
            0
    end,
    Mask_key = gleam@option:unwrap(Mask, <<>>),
    _pipe = <<1:1,
        0:3,
        Opcode:4,
        Masked:1,
        Length_section/bitstring,
        Mask_key/bitstring,
        Payload/bitstring>>,
    gleam_stdlib:wrap_list(_pipe).

-spec frame_to_bytes_builder(frame(), gleam@option:option(bitstring())) -> gleam@bytes_builder:bytes_builder().
frame_to_bytes_builder(Frame, Mask) ->
    case Frame of
        {data, {text_frame, Payload_length, Payload}} ->
            make_frame(1, Payload_length, Payload, Mask);

        {control, {close_frame, Payload_length@1, Payload@1}} ->
            make_frame(8, Payload_length@1, Payload@1, Mask);

        {data, {binary_frame, Payload_length@2, Payload@2}} ->
            make_frame(2, Payload_length@2, Payload@2, Mask);

        {control, {pong_frame, Payload_length@3, Payload@3}} ->
            make_frame(10, Payload_length@3, Payload@3, Mask);

        {control, {ping_frame, Payload_length@4, Payload@4}} ->
            make_frame(9, Payload_length@4, Payload@4, Mask);

        {continuation, Length, Payload@5} ->
            make_frame(0, Length, Payload@5, Mask)
    end.

-spec to_text_frame(binary(), boolean()) -> gleam@bytes_builder:bytes_builder().
to_text_frame(Data, Mask) ->
    Msg = gleam_stdlib:identity(Data),
    Size = erlang:byte_size(Msg),
    {Maybe_masked_data, Mask@2} = case Mask of
        true ->
            Mask@1 = crypto:strong_rand_bytes(4),
            <<Mask1:1/binary, Mask2:1/binary, Mask3:1/binary, Mask4:1/binary>> = case Mask@1 of
                <<_:1/binary, _:1/binary, _:1/binary, _:1/binary>> -> Mask@1;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Assertion pattern match failed"/utf8>>,
                                value => _assert_fail,
                                module => <<"gramps"/utf8>>,
                                function => <<"to_text_frame"/utf8>>,
                                line => 215})
            end,
            {unmask_data(Msg, [Mask1, Mask2, Mask3, Mask4], 0, <<>>),
                {some, Mask@1}};

        _ ->
            {Msg, none}
    end,
    frame_to_bytes_builder(
        {data, {text_frame, Size, Maybe_masked_data}},
        Mask@2
    ).

-spec to_binary_frame(bitstring(), boolean()) -> gleam@bytes_builder:bytes_builder().
to_binary_frame(Data, Mask) ->
    Size = erlang:byte_size(Data),
    {Maybe_masked_data, Mask@2} = case Mask of
        true ->
            Mask@1 = crypto:strong_rand_bytes(4),
            <<Mask1:1/binary, Mask2:1/binary, Mask3:1/binary, Mask4:1/binary>> = case Mask@1 of
                <<_:1/binary, _:1/binary, _:1/binary, _:1/binary>> -> Mask@1;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Assertion pattern match failed"/utf8>>,
                                value => _assert_fail,
                                module => <<"gramps"/utf8>>,
                                function => <<"to_binary_frame"/utf8>>,
                                line => 233})
            end,
            {unmask_data(Data, [Mask1, Mask2, Mask3, Mask4], 0, <<>>),
                {some, Mask@1}};

        _ ->
            {Data, none}
    end,
    frame_to_bytes_builder(
        {data, {binary_frame, Size, Maybe_masked_data}},
        Mask@2
    ).

-spec parse_websocket_key(binary()) -> binary().
parse_websocket_key(Key) ->
    _pipe = Key,
    _pipe@1 = gleam@string:append(
        _pipe,
        <<"258EAFA5-E914-47DA-95CA-C5AB0DC85B11"/utf8>>
    ),
    _pipe@2 = crypto:hash(sha, _pipe@1),
    base64:encode(_pipe@2).