-module(touch_grass@decode_json).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/touch_grass/decode_json.gleam").
-export([lift/0, lower/0, encode/1, sync/1]).

-file("src/touch_grass/decode_json.gleam", 11).
-spec lift() -> eyg@analysis@type_@isomorphic:type(any()).
lift() ->
    binary.

-file("src/touch_grass/decode_json.gleam", 15).
-spec lower() -> eyg@analysis@type_@isomorphic:type(any()).
lower() ->
    eyg@analysis@type_@isomorphic:result(
        {list,
            eyg@analysis@type_@isomorphic:record(
                [{<<"term"/utf8>>,
                        eyg@analysis@type_@isomorphic:union(
                            [{<<"True"/utf8>>, {record, empty}},
                                {<<"False"/utf8>>, {record, empty}},
                                {<<"Null"/utf8>>, {record, empty}},
                                {<<"Integer"/utf8>>, integer},
                                {<<"String"/utf8>>, string},
                                {<<"Array"/utf8>>, {record, empty}},
                                {<<"Object"/utf8>>, {record, empty}},
                                {<<"Field"/utf8>>, string}]
                        )},
                    {<<"depth"/utf8>>, integer}]
            )},
        string
    ).

-file("src/touch_grass/decode_json.gleam", 41).
-spec encode({ok, list({julienne:term_(), integer()})} | {error, binary()}) -> eyg@interpreter@value:value(any(), any()).
encode(Result) ->
    case Result of
        {ok, Parsed} ->
            List = {linked_list,
                gleam@list:map(
                    Parsed,
                    fun(Item) ->
                        {Term, Depth} = Item,
                        Term@1 = case Term of
                            {boolean, true} ->
                                eyg@interpreter@value:true();

                            {boolean, false} ->
                                eyg@interpreter@value:false();

                            null ->
                                {tagged,
                                    <<"Null"/utf8>>,
                                    eyg@interpreter@value:unit()};

                            {string, Value} ->
                                {tagged, <<"String"/utf8>>, {string, Value}};

                            {integer, I} ->
                                {tagged, <<"Integer"/utf8>>, {integer, I}};

                            {number, Sign, Integer, Decimal, Exponent} ->
                                {tagged,
                                    <<"Number"/utf8>>,
                                    {record,
                                        maps:from_list(
                                            [{<<"sign"/utf8>>, case Sign of
                                                        positive ->
                                                            {tagged,
                                                                <<"Positive"/utf8>>,
                                                                eyg@interpreter@value:unit(
                                                                    
                                                                )};

                                                        negative ->
                                                            {tagged,
                                                                <<"Negative"/utf8>>,
                                                                eyg@interpreter@value:unit(
                                                                    
                                                                )}
                                                    end}, {<<"integer"/utf8>>,
                                                    {integer, Integer}}, {<<"decimal"/utf8>>,
                                                    {record,
                                                        maps:from_list(
                                                            [{<<"numerator"/utf8>>,
                                                                    {integer,
                                                                        erlang:element(
                                                                            1,
                                                                            Decimal
                                                                        )}},
                                                                {<<"size"/utf8>>,
                                                                    {integer,
                                                                        erlang:element(
                                                                            2,
                                                                            Decimal
                                                                        )}}]
                                                        )}}, {<<"exponent"/utf8>>,
                                                    {integer, Exponent}}]
                                        )}};

                            array ->
                                {tagged,
                                    <<"Array"/utf8>>,
                                    eyg@interpreter@value:unit()};

                            object ->
                                {tagged,
                                    <<"Object"/utf8>>,
                                    eyg@interpreter@value:unit()};

                            {field, F} ->
                                {tagged, <<"Field"/utf8>>, {string, F}}
                        end,
                        {record,
                            maps:from_list(
                                [{<<"term"/utf8>>, Term@1},
                                    {<<"depth"/utf8>>, {integer, Depth}}]
                            )}
                    end
                )},
            eyg@interpreter@value:ok(List);

        {error, Reason} ->
            eyg@interpreter@value:error({string, Reason})
    end.

-file("src/touch_grass/decode_json.gleam", 92).
-spec sync(bitstring()) -> eyg@interpreter@value:value(any(), any()).
sync(Raw) ->
    Result = begin
        _pipe = julienne:parse_bits(Raw),
        gleam@result:map_error(_pipe, fun julienne:describe_reason/1)
    end,
    encode(Result).