shimmer

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

-export([from_json_string/1]).
-export_type([packet/0]).

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

-spec from_json_string(binary()) -> {ok, packet()} |
    {error, shimmer@internal@error:shimmer_error()}.
from_json_string(Encoded) ->
    case begin
        _pipe = gleam@json:decode(Encoded),
        gleam@result:map_error(_pipe, fun(A) -> {invalid_json, A} end)
    end of
        {error, _try} -> {error, _try};
        {ok, Data} ->
            Data@1 = gleam@dynamic:from(Data),
            case begin
                _pipe@1 = case gleam@dynamic:field(Data@1, <<"op"/utf8>>) of
                    {error, _try@1} -> {error, _try@1};
                    {ok, Op_code} ->
                        case gleam@dynamic:int(Op_code) of
                            {error, _try@2} -> {error, _try@2};
                            {ok, Op_code@1} ->
                                Sequence = case gleam@dynamic:field(
                                    Data@1,
                                    <<"s"/utf8>>
                                ) of
                                    {ok, Seq} ->
                                        case gleam@dynamic:int(Seq) of
                                            {ok, Seq@1} ->
                                                {some, Seq@1};

                                            {error, _@1} ->
                                                none
                                        end;

                                    {error, _@2} ->
                                        none
                                end,
                                Name = case gleam@dynamic:field(
                                    Data@1,
                                    <<"t"/utf8>>
                                ) of
                                    {ok, T} ->
                                        case gleam@dynamic:string(T) of
                                            {ok, T@1} ->
                                                {some, T@1};

                                            {error, _@3} ->
                                                none
                                        end;

                                    {error, _@4} ->
                                        none
                                end,
                                Data@2 = case gleam@dynamic:field(
                                    Data@1,
                                    <<"d"/utf8>>
                                ) of
                                    {ok, D} ->
                                        {some, D};

                                    {error, _@5} ->
                                        none
                                end,
                                {ok,
                                 {packet, Op_code@1, Sequence, Name, Data@2}}
                        end
                end,
                gleam@result:map_error(
                    _pipe@1,
                    fun(A) -> {invalid_format, A} end
                )
            end of
                {error, _try@3} -> {error, _try@3};
                {ok, Packet} ->
                    {ok, Packet}
            end
    end.