-module(gleamx@codegen).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gleamx/codegen.gleam").
-export([generate/1]).

-file("src/gleamx/codegen.gleam", 87).
-spec generate_args(binary(), list(gleamx@ast:arg())) -> {binary(),
    list({integer(), gleamx@lineinfo:line_info()})}.
generate_args(Code, Args) ->
    case Args of
        [Arg | Args@1] ->
            Mapping = {string:length(Code), erlang:element(2, Arg)},
            Code@1 = <<<<<<Code/binary, "attribute."/utf8>>/binary,
                    (erlang:element(3, Arg))/binary>>/binary,
                "("/utf8>>,
            Code@2 = case Arg of
                {bool_arg, _, _} ->
                    <<Code@1/binary, "True"/utf8>>;

                {lit_arg, _, _, Value} ->
                    <<<<<<Code@1/binary, "\""/utf8>>/binary, Value/binary>>/binary,
                        "\""/utf8>>;

                {expr_arg, _, _, Value@1} ->
                    <<Code@1/binary, Value@1/binary>>
            end,
            {Code@3, Source_map} = generate_args(
                <<Code@2/binary, "),"/utf8>>,
                Args@1
            ),
            {Code@3, [Mapping | Source_map]};

        [] ->
            {Code, []}
    end.

-file("src/gleamx/codegen.gleam", 29).
-spec generate_from_glx(binary(), gleamx@ast:ast()) -> {ok,
        {binary(), list({integer(), gleamx@lineinfo:line_info()})}} |
    {error, gleamx@ast:syntax_error()}.
generate_from_glx(Code, Ast) ->
    Mapping = {string:length(Code), erlang:element(2, Ast)},
    case Ast of
        {void_element, _, Tag, Args} ->
            Code@1 = <<<<<<Code/binary, "html."/utf8>>/binary, Tag/binary>>/binary,
                "(["/utf8>>,
            {Code@2, Source_map} = generate_args(Code@1, Args),
            {ok, {<<Code@2/binary, "])"/utf8>>, [Mapping | Source_map]}};

        {container_element, _, Tag@1, Args@1, Children} ->
            Code@3 = <<<<<<Code/binary, "html."/utf8>>/binary, Tag@1/binary>>/binary,
                "(["/utf8>>,
            {Code@4, Args_source_map} = generate_args(Code@3, Args@1),
            Code@5 = <<Code@4/binary, "],"/utf8>>,
            gleam@result:'try'(case Children of
                    [{spread, _, Child}] ->
                        generate_from_glx(Code@5, Child);

                    _ ->
                        case gleam@list:contains(
                            [<<"option"/utf8>>,
                                <<"script"/utf8>>,
                                <<"style"/utf8>>,
                                <<"textarea"/utf8>>,
                                <<"title"/utf8>>],
                            Tag@1
                        ) of
                            true ->
                                case Children of
                                    [{code_block, _, _} = Child@1] ->
                                        generate_from_glx(Code@5, Child@1);

                                    _ ->
                                        {error,
                                            {syntax_error,
                                                erlang:element(2, Ast),
                                                <<Tag@1/binary,
                                                    " elements should only contain exactly one text child"/utf8>>}}
                                end;

                            false ->
                                gleam@result:'try'(
                                    gleam@list:fold(
                                        Children,
                                        {ok,
                                            {<<Code@5/binary, "["/utf8>>,
                                                [Mapping]}},
                                        fun(Acc, Child@2) ->
                                            gleam@result:'try'(
                                                Acc,
                                                fun(_use0) ->
                                                    {Code@6, Source_map@1} = _use0,
                                                    gleam@result:'try'(
                                                        generate_from_glx(
                                                            Code@6,
                                                            Child@2
                                                        ),
                                                        fun(_use0@1) ->
                                                            {Code@7,
                                                                New_mappings} = _use0@1,
                                                            {ok,
                                                                {<<Code@7/binary,
                                                                        ","/utf8>>,
                                                                    lists:append(
                                                                        New_mappings,
                                                                        Source_map@1
                                                                    )}}
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    ),
                                    fun(_use0@2) ->
                                        {Code@8, Source_map@2} = _use0@2,
                                        {ok,
                                            {<<Code@8/binary, "]"/utf8>>,
                                                Source_map@2}}
                                    end
                                )
                        end
                end, fun(_use0@3) ->
                    {Code@9, Children_source_map} = _use0@3,
                    Code@10 = <<Code@9/binary, ")"/utf8>>,
                    {ok,
                        {Code@10,
                            lists:append(Children_source_map, Args_source_map)}}
                end);

        {spread, _, Children@1} ->
            generate_from_glx(<<Code/binary, ".."/utf8>>, Children@1);

        {code_block, _, Gleam_code} ->
            {ok, {<<Code/binary, Gleam_code/binary>>, [Mapping]}}
    end.

-file("src/gleamx/codegen.gleam", 13).
-spec generate(list(gleamx@ast:chunk())) -> {ok,
        {binary(), list({integer(), gleamx@lineinfo:line_info()})}} |
    {error, gleamx@ast:syntax_error()}.
generate(Chunks) ->
    gleam@list:fold(
        Chunks,
        {ok, {<<""/utf8>>, []}},
        fun(Acc, Chunk) ->
            gleam@result:'try'(
                Acc,
                fun(_use0) ->
                    {Code, Source_map} = _use0,
                    case Chunk of
                        {gleam_code, Pos, New_code} ->
                            {ok,
                                {<<Code/binary, New_code/binary>>,
                                    [{string:length(Code), Pos} | Source_map]}};

                        {glx_code, Ast} ->
                            gleam@result:'try'(
                                generate_from_glx(Code, Ast),
                                fun(_use0@1) ->
                                    {Code@1, New_source_map} = _use0@1,
                                    {ok,
                                        {Code@1,
                                            lists:append(
                                                New_source_map,
                                                Source_map
                                            )}}
                                end
                            )
                    end
                end
            )
        end
    ).