gserde

-module(gserde).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

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

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

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

-spec expect({ok, JOT} | {error, any()}, binary()) -> JOT.
expect(X, Msg) ->
    case X of
        {ok, V} ->
            V;

        {error, _} ->
            gleam@io:print_error(Msg),
            erlang:error(#{gleam_error => panic,
                    message => <<"panic expression evaluated"/utf8>>,
                    module => <<"gserde"/utf8>>,
                    function => <<"expect"/utf8>>,
                    line => 39})
    end.

-spec process_single(binary()) -> nil.
process_single(Src_filename) ->
    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),
    _assert_subject = simplifile:read(Src_filename),
    {ok, Code} = 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 => <<"gserde"/utf8>>,
                        function => <<"process_single"/utf8>>,
                        line => 60})
    end,
    _assert_subject@1 = begin
        _pipe@2 = glance:module(Code),
        gleam@result:map_error(
            _pipe@2,
            fun(Err) ->
                gleam@io:debug(Err),
                erlang:error(#{gleam_error => panic,
                        message => <<"panic expression evaluated"/utf8>>,
                        module => <<"gserde"/utf8>>,
                        function => <<"process_single"/utf8>>,
                        line => 66})
            end
        )
    end,
    {ok, Parsed} = 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 => <<"gserde"/utf8>>,
                        function => <<"process_single"/utf8>>,
                        line => 62})
    end,
    Custom_types = begin
        _pipe@3 = gleam@list:map(
            erlang:element(3, Parsed),
            fun(Def) -> erlang:element(3, Def) end
        ),
        gleam@list:filter(
            _pipe@3,
            fun(X) ->
                gleam@string:ends_with(erlang:element(2, X), <<"JSON"/utf8>>)
            end
        )
    end,
    Requests = begin
        _pipe@4 = Custom_types,
        gleam@list:flat_map(
            _pipe@4,
            fun(Custom_type) ->
                gleam@list:map(
                    erlang:element(6, Custom_type),
                    fun(Variant) ->
                        {request,
                            Src_module_name,
                            erlang:element(2, Custom_type),
                            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 = [<<"import gleam/json"/utf8>>,
                        <<"import gleam/dynamic"/utf8>>,
                        <<"import "/utf8, Src_module_name/binary>>,
                        Filecontent],
                    gleam@string:join(_pipe@7, <<"\n"/utf8>>)
                end
            ),
            gleam@result:unwrap(_pipe@8, nil)
    end.

-spec main() -> nil.
main() ->
    _pipe = fswalk:builder(),
    _pipe@1 = fswalk:with_path(_pipe, <<"src"/utf8>>),
    _pipe@2 = fswalk:with_entry_filter(_pipe@1, fun fswalk:only_files/1),
    _pipe@3 = fswalk:walk(_pipe@2),
    _pipe@4 = fswalk:map(
        _pipe@3,
        fun(V) -> erlang:element(2, expect(V, <<"failed to walk"/utf8>>)) end
    ),
    fswalk:each(_pipe@4, fun process_single/1).