xmljson

-module(xmljson@internal@xml).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([dict_from_list/1, parse_attributes/1, merge_namespaces/2, namespace_lookup_dict/1, namespace_prefix/2, parse_xml/4]).

-file("/home/edwin/Documents/code/gleam/badgerfish/src/xmljson/internal/xml.gleam", 10).
-spec dict_from_list(list({KID, simplejson@jsonvalue:json_value()})) -> gleam@dict:dict(KID, simplejson@jsonvalue:json_value()).
dict_from_list(Xs) ->
    _pipe = Xs,
    gleam@list:fold(
        _pipe,
        maps:new(),
        fun(Acc, A) ->
            {K, V} = A,
            case gleam_stdlib:map_get(Acc, K) of
                {ok, {json_array, X}} ->
                    Xs@1 = [V | X],
                    gleam@dict:insert(Acc, K, {json_array, Xs@1});

                {ok, X@1} ->
                    Xs@2 = [V, X@1],
                    gleam@dict:insert(Acc, K, {json_array, Xs@2});

                {error, _} ->
                    gleam@dict:insert(Acc, K, V)
            end
        end
    ).

-file("/home/edwin/Documents/code/gleam/badgerfish/src/xmljson/internal/xml.gleam", 30).
-spec parse_attributes(list(xmlm:attribute())) -> {list({binary(),
        simplejson@jsonvalue:json_value()}),
    list({binary(), simplejson@jsonvalue:json_value()})}.
parse_attributes(Attr) ->
    Upsert_fn = fun(X, Key, Value) -> case X of
            {some, {json_object, Dct}} ->
                {json_object, gleam@dict:insert(Dct, Key, {json_string, Value})};

            none ->
                {json_object, maps:from_list([{Key, {json_string, Value}}])};

            _ ->
                erlang:error(#{gleam_error => panic,
                        message => <<"`panic` expression evaluated."/utf8>>,
                        module => <<"xmljson/internal/xml"/utf8>>,
                        function => <<"parse_attributes"/utf8>>,
                        line => 41})
        end end,
    Dct@1 = begin
        _pipe = Attr,
        gleam@list:fold(_pipe, maps:new(), fun(Acc, X@1) -> case X@1 of
                    {attribute,
                        {name,
                            <<"http://www.w3.org/2000/xmlns/"/utf8>>,
                            <<"xmlns"/utf8>>},
                        Value@1} ->
                        gleam@dict:upsert(
                            Acc,
                            <<"@xmlns"/utf8>>,
                            fun(_capture) ->
                                Upsert_fn(_capture, <<"$"/utf8>>, Value@1)
                            end
                        );

                    {attribute,
                        {name, <<"http://www.w3.org/2000/xmlns/"/utf8>>, Key@1},
                        Value@2} ->
                        gleam@dict:upsert(
                            Acc,
                            <<"@xmlns"/utf8>>,
                            fun(_capture@1) ->
                                Upsert_fn(_capture@1, Key@1, Value@2)
                            end
                        );

                    {attribute, {name, _, Name}, Value@3} ->
                        gleam@dict:insert(
                            Acc,
                            <<"@"/utf8, Name/binary>>,
                            {json_string, Value@3}
                        )
                end end)
    end,
    Attrs = begin
        _pipe@1 = gleam@dict:delete(Dct@1, <<"@xmlns"/utf8>>),
        maps:to_list(_pipe@1)
    end,
    Inherit = (case gleam_stdlib:map_get(Dct@1, <<"@xmlns"/utf8>>) of
        {error, _} ->
            [];

        {ok, Value@4} ->
            [{<<"@xmlns"/utf8>>, Value@4}]
    end),
    {Attrs, Inherit}.

-file("/home/edwin/Documents/code/gleam/badgerfish/src/xmljson/internal/xml.gleam", 67).
-spec merge_namespaces(
    list({KLL, simplejson@jsonvalue:json_value()}),
    list({KLL, simplejson@jsonvalue:json_value()})
) -> list({KLL, simplejson@jsonvalue:json_value()}).
merge_namespaces(Nms1, Nms2) ->
    case {Nms1, Nms2} of
        {[], []} ->
            [];

        {Nms1@1, []} ->
            Nms1@1;

        {[], Nms2@1} ->
            Nms2@1;

        {[{Key, {json_object, Orig}}], [{_, {json_object, Dct}}]} ->
            [{Key, {json_object, maps:merge(Orig, Dct)}}];

        {_, _} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"`panic` expression evaluated."/utf8>>,
                    module => <<"xmljson/internal/xml"/utf8>>,
                    function => <<"merge_namespaces"/utf8>>,
                    line => 75})
    end.

-file("/home/edwin/Documents/code/gleam/badgerfish/src/xmljson/internal/xml.gleam", 79).
-spec namespace_lookup_dict(list({any(), simplejson@jsonvalue:json_value()})) -> gleam@dict:dict(binary(), binary()).
namespace_lookup_dict(Nms) ->
    case Nms of
        [] ->
            maps:new();

        [{_, {json_object, Dct}}] ->
            _pipe = maps:to_list(Dct),
            _pipe@1 = gleam@list:map(
                _pipe,
                fun(Elem) ->
                    {Key, {json_string, Value}} = case Elem of
                        {_, {json_string, _}} -> Elem;
                        _assert_fail ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                        value => _assert_fail,
                                        module => <<"xmljson/internal/xml"/utf8>>,
                                        function => <<"namespace_lookup_dict"/utf8>>,
                                        line => 85})
                    end,
                    {Value, Key}
                end
            ),
            maps:from_list(_pipe@1);

        _ ->
            erlang:error(#{gleam_error => panic,
                    message => <<"`panic` expression evaluated."/utf8>>,
                    module => <<"xmljson/internal/xml"/utf8>>,
                    function => <<"namespace_lookup_dict"/utf8>>,
                    line => 90})
    end.

-file("/home/edwin/Documents/code/gleam/badgerfish/src/xmljson/internal/xml.gleam", 94).
-spec namespace_prefix(KIO, gleam@dict:dict(KIO, binary())) -> binary().
namespace_prefix(Namespace, Lookup) ->
    Pre = begin
        _pipe = gleam_stdlib:map_get(Lookup, Namespace),
        gleam@result:unwrap(_pipe, <<"$"/utf8>>)
    end,
    case Pre of
        <<"$"/utf8>> ->
            <<""/utf8>>;

        Pre@1 ->
            <<Pre@1/binary, ":"/utf8>>
    end.

-file("/home/edwin/Documents/code/gleam/badgerfish/src/xmljson/internal/xml.gleam", 104).
-spec parse_xml(
    xmlm:input(),
    list({binary(), simplejson@jsonvalue:json_value()}),
    list({binary(), simplejson@jsonvalue:json_value()}),
    gleam@dict:dict(binary(), binary())
) -> {list({binary(), simplejson@jsonvalue:json_value()}), xmlm:input()}.
parse_xml(Input, Key_value, Inherit, Namespace_lookup) ->
    case xmlm:signal(Input) of
        {ok, {{element_start, {tag, {name, Namespace, Name}, Attr}}, Input@1}} ->
            {Attrs, Inherit_new} = parse_attributes(Attr),
            New_namespaces = merge_namespaces(Inherit, Inherit_new),
            New_lookup = namespace_lookup_dict(New_namespaces),
            Name@1 = <<(namespace_prefix(Namespace, New_lookup))/binary,
                Name/binary>>,
            {List, Input@2} = parse_xml(
                Input@1,
                Attrs,
                New_namespaces,
                New_lookup
            ),
            Json = {json_object, dict_from_list(List)},
            parse_xml(
                Input@2,
                [{Name@1, Json} | Key_value],
                Inherit,
                Namespace_lookup
            );

        {ok, {element_end, Input@3}} ->
            {lists:append(Inherit, Key_value), Input@3};

        {error, _} ->
            case xmlm:eoi(Input) of
                {ok, {true, Input@4}} ->
                    {lists:append(Inherit, Key_value), Input@4};

                _ ->
                    erlang:error(#{gleam_error => panic,
                            message => <<"`panic` expression evaluated."/utf8>>,
                            module => <<"xmljson/internal/xml"/utf8>>,
                            function => <<"parse_xml"/utf8>>,
                            line => 126})
            end;

        {ok, {{data, Data}, Input@5}} ->
            parse_xml(
                Input@5,
                [{<<"$"/utf8>>, {json_string, Data}} | Key_value],
                Inherit,
                Namespace_lookup
            );

        Value ->
            _ = gleam@io:debug(Value),
            erlang:error(#{gleam_error => panic,
                    message => <<"`panic` expression evaluated."/utf8>>,
                    module => <<"xmljson/internal/xml"/utf8>>,
                    function => <<"parse_xml"/utf8>>,
                    line => 138})
    end.