shimmer

-module(shimmer@ws@packet).
-compile(no_auto_import).

-export([from_json_string/1, get_data_as_json/1, json_string/1]).
-export_type([hello_packet_data/0, ready_packet_data/0, identify_packet_data/0, packet/0]).

-type hello_packet_data() :: {hello_packet_data, integer()}.

-type ready_packet_data() :: {ready_packet_data, shimmer@types@user:user()}.

-type identify_packet_data() :: {identify_packet_data,
                                 binary(),
                                 integer(),
                                 gleam@option:option(gleam@dynamic:dynamic())}.

-type packet() :: {raw_packet,
                   integer(),
                   gleam@option:option(integer()),
                   gleam@option:option(binary()),
                   gleam@option:option(gleam@dynamic:dynamic())} |
    {hello_packet,
     integer(),
     gleam@option:option(integer()),
     gleam@option:option(binary()),
     hello_packet_data()} |
    {ready_packet,
     integer(),
     gleam@option:option(integer()),
     gleam@option:option(binary()),
     ready_packet_data()} |
    {identify_packet,
     integer(),
     gleam@option:option(integer()),
     gleam@option:option(binary()),
     identify_packet_data()}.

-spec hello_packet_data_from_dynamic(
    gleam@option:option(gleam@dynamic:dynamic())
) -> {ok, hello_packet_data()} | {error, shimmer@internal@error:shimmer_error()}.
hello_packet_data_from_dynamic(Data) ->
    case Data of
        {some, Raw_data} ->
            case begin
                _pipe = Raw_data,
                _pipe@1 = (gleam@dynamic:field(
                    <<"heartbeat_interval"/utf8>>,
                    fun gleam@dynamic:int/1
                ))(_pipe),
                gleam@result:map_error(
                    _pipe@1,
                    fun(A) -> {invalid_dynamic_list, A} end
                )
            end of
                {error, _try} -> {error, _try};
                {ok, Heartbeat_interval} ->
                    {ok, {hello_packet_data, Heartbeat_interval}}
            end;

        none ->
            {error, empty_option_when_required}
    end.

-spec from_json_string(binary()) -> {ok, packet()} |
    {error, shimmer@internal@error:shimmer_error()}.
from_json_string(Encoded) ->
    Packet_decoded = gleam@dynamic:decode4(
        fun(A, B, C, D) -> {raw_packet, A, B, C, D} end,
        gleam@dynamic:field(<<"op"/utf8>>, fun gleam@dynamic:int/1),
        gleam@dynamic:field(
            <<"s"/utf8>>,
            gleam@dynamic:optional(fun gleam@dynamic:int/1)
        ),
        gleam@dynamic:field(
            <<"t"/utf8>>,
            gleam@dynamic:optional(fun gleam@dynamic:string/1)
        ),
        gleam@dynamic:field(
            <<"d"/utf8>>,
            gleam@dynamic:optional(fun gleam@dynamic:dynamic/1)
        )
    ),
    case begin
        _pipe = gleam@json:decode(Encoded, Packet_decoded),
        gleam@result:map_error(_pipe, fun(A) -> {invalid_json, A} end)
    end of
        {error, _try} -> {error, _try};
        {ok, Packet} ->
            case erlang:element(2, Packet) of
                10 ->
                    case Packet of
                        {raw_packet, _@1, _@2, _@3, D} ->
                            case hello_packet_data_from_dynamic(D) of
                                {error, _try@1} -> {error, _try@1};
                                {ok, Data} ->
                                    {ok,
                                     {hello_packet,
                                      erlang:element(2, Packet),
                                      erlang:element(3, Packet),
                                      erlang:element(4, Packet),
                                      Data}}
                            end;

                        _@4 ->
                            {ok, Packet}
                    end;

                _@5 ->
                    {ok, Packet}
            end
    end.

-spec get_data_as_json(packet()) -> gleam@json:json().
get_data_as_json(Packet) ->
    case Packet of
        {identify_packet, _@1, _@2, _@3, D} ->
            gleam@json:object(
                [{<<"token"/utf8>>, gleam@json:string(erlang:element(2, D))},
                 {<<"intents"/utf8>>, gleam@json:int(erlang:element(3, D))},
                 {<<"properties"/utf8>>,
                  gleam@json:object(
                      [{<<"os"/utf8>>, gleam@json:string(<<"Windows"/utf8>>)},
                       {<<"broswer"/utf8>>,
                        gleam@json:string(<<"Shimmer/0.1.0"/utf8>>)},
                       {<<"device"/utf8>>,
                        gleam@json:string(<<"Shimmer/0.1.0"/utf8>>)}]
                  )}]
            );

        _@4 ->
            gleam@json:object([])
    end.

-spec json_string(packet()) -> binary().
json_string(Packet) ->
    Data = get_data_as_json(Packet),
    _pipe = gleam@json:object(
        [{<<"op"/utf8>>, gleam@json:int(erlang:element(2, Packet))},
         {<<"s"/utf8>>,
          gleam@json:nullable(erlang:element(3, Packet), fun gleam@json:int/1)},
         {<<"t"/utf8>>,
          gleam@json:nullable(
              erlang:element(4, Packet),
              fun gleam@json:string/1
          )},
         {<<"d"/utf8>>, Data}]
    ),
    gleam@json:to_string(_pipe).