-module(gserde).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gserde.gleam").
-export([gen/1, process_single/2, main/0]).

-file("src/gserde.gleam", 15).
-spec gen(gserde@request:request()) -> {gserde@request:request(), binary()}.
gen(Req) ->
    Ser = gleam@bool:guard(
        erlang:element(6, Req),
        internal@serializer:from(Req),
        fun() -> <<""/utf8>> end
    ),
    De = gleam@bool:guard(
        erlang:element(7, Req),
        internal@deserializer:to(Req),
        fun() -> <<""/utf8>> end
    ),
    {Req,
        begin
            _pipe = [Ser, De],
            gleam@string:join(_pipe, <<"\n\n"/utf8>>)
        end}.

-file("src/gserde.gleam", 32).
-spec to_output_filename(binary()) -> binary().
to_output_filename(Src_filename) ->
    gleam@string:replace(
        Src_filename,
        <<".gleam"/utf8>>,
        <<"_json.gleam"/utf8>>
    ).

-file("src/gserde.gleam", 54).
-spec process_single(binary(), boolean()) -> nil.
process_single(Src_filename, Is_debug) ->
    gleam@bool:guard(
        not Is_debug,
        nil,
        fun() ->
            gleam_stdlib:println(<<"Processing: "/utf8, Src_filename/binary>>),
            nil
        end
    ),
    Src_module_name = begin
        _pipe = Src_filename,
        _pipe@1 = gleam@string:replace(_pipe, <<"src/"/utf8>>, <<""/utf8>>),
        gleam@string:replace(_pipe@1, <<".gleam"/utf8>>, <<""/utf8>>)
    end,
    Dest_filename = to_output_filename(Src_filename),
    Code@1 = case simplifile:read(Src_filename) of
        {ok, Code} -> Code;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"gserde"/utf8>>,
                        function => <<"process_single"/utf8>>,
                        line => 67,
                        value => _assert_fail,
                        start => 1466,
                        'end' => 1523,
                        pattern_start => 1477,
                        pattern_end => 1485})
    end,
    Parsed@1 = case begin
        _pipe@2 = glance:module(Code@1),
        gleam@result:map_error(
            _pipe@2,
            fun(Err) ->
                gleam_stdlib:print_error(gleam@string:inspect(Err)),
                erlang:error(#{gleam_error => panic,
                        message => <<"`panic` expression evaluated."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"gserde"/utf8>>,
                        function => <<"process_single"/utf8>>,
                        line => 73})
            end
        )
    end of
        {ok, Parsed} -> Parsed;
        _assert_fail@1 ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"gserde"/utf8>>,
                        function => <<"process_single"/utf8>>,
                        line => 69,
                        value => _assert_fail@1,
                        start => 1527,
                        'end' => 1669,
                        pattern_start => 1538,
                        pattern_end => 1548})
    end,
    Custom_types = begin
        _pipe@3 = gleam@list:map(
            erlang:element(3, Parsed@1),
            fun(Def) -> erlang:element(3, Def) end
        ),
        gleam@list:filter(
            _pipe@3,
            fun(X) ->
                gleam_stdlib:string_ends_with(
                    erlang:element(3, X),
                    <<"Json"/utf8>>
                )
            end
        )
    end,
    gleam@bool:guard(
        erlang:length(Custom_types) =< 1,
        nil,
        fun() -> erlang:error(#{gleam_error => panic,
                    message => <<"Only one json type is allowed per file"/utf8>>,
                    file => <<?FILEPATH/utf8>>,
                    module => <<"gserde"/utf8>>,
                    function => <<"process_single"/utf8>>,
                    line => 83}) end
    ),
    Requests = begin
        _pipe@4 = Custom_types,
        gleam@list:flat_map(
            _pipe@4,
            fun(Custom_type) ->
                gleam@list:map(
                    erlang:element(7, Custom_type),
                    fun(Variant) ->
                        {request,
                            Src_module_name,
                            erlang:element(3, Custom_type),
                            Parsed@1,
                            Variant,
                            true,
                            true}
                    end
                )
            end
        )
    end,
    Filecontent = begin
        _pipe@5 = gleam@list:map(Requests, fun gen/1),
        _pipe@6 = gleam@list:map(_pipe@5, fun(It) -> erlang:element(2, It) end),
        gleam@string:join(_pipe@6, <<"\n\n"/utf8>>)
    end,
    case Filecontent of
        <<""/utf8>> ->
            nil;

        _ ->
            _pipe@8 = simplifile:write(
                Dest_filename,
                begin
                    _pipe@7 = [<<"// This file was generated using gserde"/utf8>>,
                        <<"import gleam/json"/utf8>>,
                        <<"import gleam/dynamic/decode"/utf8>>,
                        <<"import "/utf8, Src_module_name/binary>>,
                        Filecontent],
                    gleam@string:join(_pipe@7, <<"\n"/utf8>>)
                end
            ),
            gleam@result:unwrap(_pipe@8, nil)
    end.

-file("src/gserde.gleam", 36).
-spec main() -> nil.
main() ->
    Is_debug = case dot_env@env:get_bool(<<"DEBUG"/utf8>>) of
        {ok, _} ->
            true;

        _ ->
            false
    end,
    _pipe = fswalk:builder(),
    _pipe@1 = fswalk:with_path(_pipe, <<"src"/utf8>>),
    _pipe@2 = fswalk:walk(_pipe@1),
    _pipe@3 = gleam@yielder:map(
        _pipe@2,
        fun(Res) ->
            Entry@1 = case Res of
                {ok, Entry} -> Entry;
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"failed to walk"/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"gserde"/utf8>>,
                                function => <<"main"/utf8>>,
                                line => 45,
                                value => _assert_fail,
                                start => 892,
                                'end' => 918,
                                pattern_start => 903,
                                pattern_end => 912})
            end,
            Entry@1
        end
    ),
    _pipe@4 = gleam@yielder:filter(
        _pipe@3,
        fun(Entry@2) ->
            gleam_stdlib:string_ends_with(
                erlang:element(2, Entry@2),
                <<".gleam"/utf8>>
            )
            andalso not erlang:element(2, erlang:element(3, Entry@2))
        end
    ),
    gleam@yielder:each(
        _pipe@4,
        fun(Entry@3) -> process_single(erlang:element(2, Entry@3), Is_debug) end
    ).