sprocket

-module(tools@html_transform).
-compile([no_auto_import, nowarn_unused_vars]).

-export([snake_case/1, main/0]).

-spec template_for(binary(), binary(), binary()) -> list(binary()).
template_for(Original, Tag, Template) ->
    case gleam@string:lowercase(Template) of
        <<"elements"/utf8>> ->
            [<<<<<<<<"/// The [SVG `<"/utf8, Original/binary>>/binary,
                            ">` element](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/"/utf8>>/binary,
                        Original/binary>>/binary,
                    ")"/utf8>>,
                <<<<"pub fn "/utf8, Tag/binary>>/binary,
                    "(attrs: List(Attribute), children: List(Element)) {"/utf8>>,
                <<<<"  el(\""/utf8, Original/binary>>/binary,
                    "\", attrs, children)"/utf8>>,
                <<"}"/utf8>>];

        <<"attributes"/utf8>> ->
            [<<<<<<<<"/// The [SVG `"/utf8, Original/binary>>/binary,
                            "` attribute](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/"/utf8>>/binary,
                        Original/binary>>/binary,
                    ")"/utf8>>,
                <<<<"pub fn "/utf8, Tag/binary>>/binary,
                    "(value: String) -> Attribute {"/utf8>>,
                <<<<"  attribute(\""/utf8, Original/binary>>/binary,
                    "\", value)"/utf8>>,
                <<"}"/utf8>>];

        _ ->
            gleam@io:print(
                <<"Error: No template provided. Use `--template=elements` or `--template=attributes`\n\n"/utf8>>
            ),
            erlang:error(#{gleam_error => panic,
                    message => <<"panic expression evaluated"/utf8>>,
                    module => <<"tools/html_transform"/utf8>>,
                    function => <<"template_for"/utf8>>,
                    line => 101})
    end.

-spec snake_case_helper(binary(), binary()) -> binary().
snake_case_helper(Input, Acc) ->
    case gleam@string:pop_grapheme(Input) of
        {error, nil} ->
            Acc;

        {ok, {C, Rest}} ->
            _assert_subject = gleam@regex:from_string(<<"[A-Z]"/utf8>>),
            {ok, Re} = case _assert_subject of
                {ok, _} -> _assert_subject;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Assertion pattern match failed"/utf8>>,
                                value => _assert_fail,
                                module => <<"tools/html_transform"/utf8>>,
                                function => <<"snake_case_helper"/utf8>>,
                                line => 117})
            end,
            case gleam@regex:check(Re, C) of
                true ->
                    snake_case_helper(
                        Rest,
                        <<<<Acc/binary, "_"/utf8>>/binary,
                            (gleam@string:lowercase(C))/binary>>
                    );

                false ->
                    snake_case_helper(
                        Rest,
                        <<Acc/binary, (gleam@string:lowercase(C))/binary>>
                    )
            end
    end.

-spec snake_case(binary()) -> binary().
snake_case(Input) ->
    snake_case_helper(Input, <<""/utf8>>).

-spec transform(glint:command_input()) -> {ok, nil} |
    {error, gleam@erlang@file:reason()}.
transform(Input) ->
    _assert_subject = glint@flag:get(
        erlang:element(3, Input),
        <<"template"/utf8>>
    ),
    {ok, {s, Template}} = case _assert_subject of
        {ok, {s, _}} -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"tools/html_transform"/utf8>>,
                        function => <<"transform"/utf8>>,
                        line => 40})
    end,
    _assert_subject@1 = gleam@list:at(erlang:element(2, Input), 0),
    {ok, Filepath} = case _assert_subject@1 of
        {ok, _} -> _assert_subject@1;
        _assert_fail@1 ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail@1,
                        module => <<"tools/html_transform"/utf8>>,
                        function => <<"transform"/utf8>>,
                        line => 41})
    end,
    _assert_subject@2 = gleam@erlang@file:read(Filepath),
    {ok, Contents} = case _assert_subject@2 of
        {ok, _} -> _assert_subject@2;
        _assert_fail@2 ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail@2,
                        module => <<"tools/html_transform"/utf8>>,
                        function => <<"transform"/utf8>>,
                        line => 43})
    end,
    Lines = gleam@string:split(Contents, <<"\n"/utf8>>),
    Result = begin
        _pipe = Lines,
        _pipe@7 = gleam@list:filter_map(
            _pipe,
            fun(Line) -> case gleam@string:trim(Line) of
                    <<""/utf8>> ->
                        {error, nil};

                    Original ->
                        case begin
                            _pipe@1 = Original,
                            gleam@string:starts_with(_pipe@1, <<"//"/utf8>>)
                        end of
                            true ->
                                {error, nil};

                            false ->
                                Tag = begin
                                    _pipe@2 = Original,
                                    _pipe@3 = gleam@string:replace(
                                        _pipe@2,
                                        <<"-"/utf8>>,
                                        <<"_"/utf8>>
                                    ),
                                    _pipe@4 = gleam@string:replace(
                                        _pipe@3,
                                        <<":"/utf8>>,
                                        <<"_"/utf8>>
                                    ),
                                    snake_case(_pipe@4)
                                end,
                                _pipe@5 = template_for(Original, Tag, Template),
                                _pipe@6 = gleam@string:join(
                                    _pipe@5,
                                    <<"\n"/utf8>>
                                ),
                                {ok, _pipe@6}
                        end
                end end
        ),
        gleam@string:join(_pipe@7, <<"\n\n"/utf8>>)
    end,
    _assert_subject@3 = gleam@erlang@file:write(
        Result,
        <<Filepath/binary, ".gleam"/utf8>>
    ),
    {ok, _} = case _assert_subject@3 of
        {ok, _} -> _assert_subject@3;
        _assert_fail@3 ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail@3,
                        module => <<"tools/html_transform"/utf8>>,
                        function => <<"transform"/utf8>>,
                        line => 80})
    end.

-spec main() -> nil.
main() ->
    _pipe = glint:new(),
    _pipe@1 = glint:with_pretty_help(_pipe, glint:default_pretty_help()),
    _pipe@2 = glint:add_command(
        _pipe@1,
        [],
        fun transform/1,
        [glint@flag:string(
                <<"template"/utf8>>,
                <<""/utf8>>,
                <<"Template to use for the transformation"/utf8>>
            )],
        <<"transforms a list of html tags into sprocket elements"/utf8>>
    ),
    glint:run(_pipe@2, gleam@erlang:start_arguments()).