-module(gwr@parser@types_parser).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([parse_value_type/1, parse_limits/1, parse_function_type/1, parse_global_type/1]).

-spec parse_value_type(gwr@parser@binary_reader:binary_reader()) -> {ok,
        {gwr@parser@binary_reader:binary_reader(),
            gwr@syntax@types:value_type()}} |
    {error, binary()}.
parse_value_type(Reader) ->
    gleam@result:'try'(case gwr@parser@binary_reader:read(Reader, 1) of
            {ok, {Reader@1, <<Value_type_id>>}} ->
                {ok, {Reader@1, Value_type_id}};

            {error, Reason} ->
                {error,
                    <<"gwr/parser/types_parser.parse_value_type: couldn't read value type id: "/utf8,
                        Reason/binary>>};

            _ ->
                {error,
                    <<"gwr/parser/types_parser.parse_value_type: unknown error reading value type id"/utf8>>}
        end, fun(_use0) ->
            {Reader@2, Value_type_id@1} = _use0,
            gleam@result:'try'(case Value_type_id@1 of
                    16#7f ->
                        {ok, {number, integer32}};

                    16#7e ->
                        {ok, {number, integer64}};

                    16#7d ->
                        {ok, {number, float32}};

                    16#7c ->
                        {ok, {number, float64}};

                    16#7b ->
                        {ok, {vector, vector128}};

                    16#70 ->
                        {ok, {reference, function_reference}};

                    16#6f ->
                        {ok, {reference, extern_reference}};

                    Unknown ->
                        {error,
                            <<<<"gwr/parser/types_parser.parse_value_type: unknown value type \""/utf8,
                                    (gleam@int:to_string(Unknown))/binary>>/binary,
                                "\""/utf8>>}
                end, fun(Value_type) -> {ok, {Reader@2, Value_type}} end)
        end).

-spec parse_limits(gwr@parser@binary_reader:binary_reader()) -> {ok,
        {gwr@parser@binary_reader:binary_reader(), gwr@syntax@types:limits()}} |
    {error, binary()}.
parse_limits(Reader) ->
    gleam@result:'try'(case gwr@parser@binary_reader:read(Reader, 1) of
            {ok, {Reader@1, <<16#00>>}} ->
                {ok, {Reader@1, false}};

            {ok, {Reader@2, <<16#01>>}} ->
                {ok, {Reader@2, true}};

            {ok, {_, <<Unknown>>}} ->
                {error,
                    <<<<"gwr/parser/types_parser.parse_limits: unexpected flag value \""/utf8,
                            (gleam@int:to_string(Unknown))/binary>>/binary,
                        "\""/utf8>>};

            {error, Reason} ->
                {error,
                    <<"gwr/parser/types_parser.parse_limits: couldn't read flag value: "/utf8,
                        Reason/binary>>};

            _ ->
                {error,
                    <<"gwr/parser/types_parser.parse_limits: unknown error reading flag value"/utf8>>}
        end, fun(_use0) ->
            {Reader@3, Has_max} = _use0,
            gleam@result:'try'(
                gwr@parser@value_parser:parse_unsigned_leb128_integer(Reader@3),
                fun(_use0@1) ->
                    {Reader@4, Min} = _use0@1,
                    gleam@result:'try'(case Has_max of
                            true ->
                                gleam@result:'try'(
                                    gwr@parser@value_parser:parse_unsigned_leb128_integer(
                                        Reader@4
                                    ),
                                    fun(_use0@2) ->
                                        {Reader@5, Max} = _use0@2,
                                        {ok, {Reader@5, {some, Max}}}
                                    end
                                );

                            false ->
                                {ok, {Reader@4, none}}
                        end, fun(_use0@3) ->
                            {Reader@6, Max@1} = _use0@3,
                            {ok, {Reader@6, {limits, Min, Max@1}}}
                        end)
                end
            )
        end).

-spec parse_function_type(gwr@parser@binary_reader:binary_reader()) -> {ok,
        {gwr@parser@binary_reader:binary_reader(),
            gwr@syntax@types:function_type()}} |
    {error, binary()}.
parse_function_type(Reader) ->
    gleam@result:'try'(case gwr@parser@binary_reader:read(Reader, 1) of
            {ok, {Reader@1, <<16#60>>}} ->
                gleam@result:'try'(
                    gwr@parser@convention_parser:parse_vector(
                        Reader@1,
                        fun parse_value_type/1
                    ),
                    fun(_use0) ->
                        {Reader@2, Parameters_vec} = _use0,
                        gleam@result:'try'(
                            gwr@parser@convention_parser:parse_vector(
                                Reader@2,
                                fun parse_value_type/1
                            ),
                            fun(_use0@1) ->
                                {Reader@3, Results_vec} = _use0@1,
                                {ok,
                                    {Reader@3,
                                        {function_type,
                                            Parameters_vec,
                                            Results_vec}}}
                            end
                        )
                    end
                );

            {ok, {_, <<Unkown>>}} ->
                {error,
                    <<<<"gwr/parser/types_parser.parse_function_type: unexpected function type id \""/utf8,
                            (gleam@int:to_string(Unkown))/binary>>/binary,
                        "\""/utf8>>};

            {error, Reason} ->
                {error,
                    <<"gwr/parser/types_parser.parse_function_type: couldn't read function type id: "/utf8,
                        Reason/binary>>};

            _ ->
                {error,
                    <<"gwr/parser/types_parser.parse_function_type: unknown error reading function type id"/utf8>>}
        end, fun(_use0@2) ->
            {Reader@4, Function_type} = _use0@2,
            {ok, {Reader@4, Function_type}}
        end).

-spec parse_global_type(gwr@parser@binary_reader:binary_reader()) -> {ok,
        {gwr@parser@binary_reader:binary_reader(),
            gwr@syntax@types:global_type()}} |
    {error, binary()}.
parse_global_type(Reader) ->
    gleam@result:'try'(
        parse_value_type(Reader),
        fun(_use0) ->
            {Reader@1, Value_type} = _use0,
            gleam@result:'try'(
                case gwr@parser@binary_reader:read(Reader@1, 1) of
                    {ok, {Reader@2, <<16#00>>}} ->
                        {ok, {Reader@2, constant}};

                    {ok, {Reader@3, <<16#01>>}} ->
                        {ok, {Reader@3, variable}};

                    {ok, {_, <<Unkown>>}} ->
                        {error,
                            <<<<"gwr/parser/types_parser.parse_global_type: unexpected mutability flag value \""/utf8,
                                    (gleam@int:to_string(Unkown))/binary>>/binary,
                                "\""/utf8>>};

                    {error, Reason} ->
                        {error,
                            <<"gwr/parser/types_parser.parse_global_type: couldn't read mutability flag value: "/utf8,
                                Reason/binary>>};

                    _ ->
                        {error,
                            <<"gwr/parser/types_parser.parse_global_type: unknown error reading mutability flag value"/utf8>>}
                end,
                fun(_use0@1) ->
                    {Reader@4, Mutability} = _use0@1,
                    {ok, {Reader@4, {global_type, Mutability, Value_type}}}
                end
            )
        end
    ).