derived

-module(derived).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/derived.gleam").
-export([parse/1, generate/3]).
-export_type([generate_error/1]).

-type generate_error(EOD) :: {parse_error, derived@ast:parse_error()} |
    {generation_error, EOD}.

-file("src/derived.gleam", 12).
-spec parse(binary()) -> {ok, list(derived@ast:derived_type())} |
    {error, derived@ast:parse_error()}.
parse(Input) ->
    derived@ast:parse(Input).

-file("src/derived.gleam", 98).
-spec insert_after_type(binary(), derived@ast:derived_type(), binary()) -> binary().
insert_after_type(Source, Derived_type, Content) ->
    {_, End} = erlang:element(2, Derived_type),
    Before = gleam@string:slice(Source, 0, End + 1),
    After = gleam@string:slice(
        Source,
        End + 1,
        (string:length(Source) - End) - 1
    ),
    <<<<<<Before/binary, "\n\n"/utf8>>/binary, Content/binary>>/binary,
        After/binary>>.

-file("src/derived.gleam", 110).
-spec start_marker(binary(), binary()) -> binary().
start_marker(Derived_name, Type_name) ->
    <<<<<<<<"// ---- BEGIN DERIVED "/utf8, Derived_name/binary>>/binary,
                " for "/utf8>>/binary,
            Type_name/binary>>/binary,
        " DO NOT MODIFY ---- //"/utf8>>.

-file("src/derived.gleam", 118).
-spec end_marker(binary(), binary()) -> binary().
end_marker(Derived_name, Type_name) ->
    <<<<<<<<"// ---- END DERIVED "/utf8, Derived_name/binary>>/binary,
                " for "/utf8>>/binary,
            Type_name/binary>>/binary,
        " //"/utf8>>.

-file("src/derived.gleam", 71).
-spec find_and_replace_markers(binary(), binary(), binary(), binary()) -> {ok,
        binary()} |
    {error, nil}.
find_and_replace_markers(Source, Derived_name, Type_name, New_content) ->
    Pattern = <<<<(start_marker(Derived_name, Type_name))/binary,
            "[\\s\\S]*?"/utf8>>/binary,
        (end_marker(Derived_name, Type_name))/binary>>,
    case gleam@regexp:compile(Pattern, {options, false, true}) of
        {ok, Regex} ->
            case gleam_regexp_ffi:replace(Regex, Source, New_content) of
                Result when Result =/= Source ->
                    {ok, Result};

                _ ->
                    {error, nil}
            end;

        {error, _} ->
            {error, nil}
    end.

-file("src/derived.gleam", 47).
-spec create_derived_content(
    binary(),
    binary(),
    binary(),
    derived@ast:derived_type()
) -> binary().
create_derived_content(Generated_code, Derived_name, Source, Derived_type) ->
    New_content = <<<<<<<<(start_marker(
                        Derived_name,
                        erlang:element(2, erlang:element(7, Derived_type))
                    ))/binary,
                    "\n"/utf8>>/binary,
                Generated_code/binary>>/binary,
            "\n"/utf8>>/binary,
        (end_marker(
            Derived_name,
            erlang:element(2, erlang:element(7, Derived_type))
        ))/binary>>,
    _pipe = find_and_replace_markers(
        Source,
        Derived_name,
        erlang:element(2, erlang:element(7, Derived_type)),
        New_content
    ),
    gleam@result:lazy_unwrap(
        _pipe,
        fun() -> insert_after_type(Source, Derived_type, New_content) end
    ).

-file("src/derived.gleam", 16).
-spec generate(
    binary(),
    binary(),
    fun((derived@ast:derived_type()) -> {ok, binary()} | {error, EOH})
) -> {ok, binary()} | {error, generate_error(EOH)}.
generate(Input, Derived_name, Callback) ->
    gleam@result:'try'(
        begin
            _pipe = parse(Input),
            gleam@result:map_error(
                _pipe,
                fun(Field@0) -> {parse_error, Field@0} end
            )
        end,
        fun(Derived_types) ->
            Filtered_types = begin
                _pipe@1 = Derived_types,
                _pipe@3 = gleam@list:filter(
                    _pipe@1,
                    fun(Derived_type) ->
                        _pipe@2 = erlang:element(8, Derived_type),
                        gleam@list:contains(_pipe@2, Derived_name)
                    end
                ),
                lists:reverse(_pipe@3)
            end,
            gleam@list:fold_until(
                Filtered_types,
                {ok, Input},
                fun(Current, Derived_type@1) ->
                    Source@1 = case Current of
                        {ok, Source} -> Source;
                        _assert_fail ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                        file => <<?FILEPATH/utf8>>,
                                        module => <<"derived"/utf8>>,
                                        function => <<"generate"/utf8>>,
                                        line => 31,
                                        value => _assert_fail,
                                        start => 815,
                                        'end' => 846,
                                        pattern_start => 826,
                                        pattern_end => 836})
                    end,
                    case Callback(Derived_type@1) of
                        {ok, Generated_section} ->
                            {continue,
                                {ok,
                                    create_derived_content(
                                        Generated_section,
                                        Derived_name,
                                        Source@1,
                                        Derived_type@1
                                    )}};

                        {error, Error} ->
                            {stop, {error, {generation_error, Error}}}
                    end
                end
            )
        end
    ).