gserde

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

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

-file("/Users/cdaringe/src/gserde/src/gserde.gleam", 15).
-spec gen(request:request()) -> {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("/Users/cdaringe/src/gserde/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("/Users/cdaringe/src/gserde/src/gserde.gleam", 51).
-spec process_single(binary(), boolean()) -> nil.
process_single(Src_filename, Is_debug) ->
    gleam@bool:guard(
        not Is_debug,
        nil,
        fun() ->
            gleam@io:debug({<<"Processing"/utf8>>, Src_filename}),
            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),
    _assert_subject = simplifile:read(Src_filename),
    {ok, Code} = case _assert_subject of
        {ok, _} -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        value => _assert_fail,
                        module => <<"gserde"/utf8>>,
                        function => <<"process_single"/utf8>>,
                        line => 64})
    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 => 70})
            end
        )
    end,
    {ok, Parsed} = case _assert_subject@1 of
        {ok, _} -> _assert_subject@1;
        _assert_fail@1 ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        value => _assert_fail@1,
                        module => <<"gserde"/utf8>>,
                        function => <<"process_single"/utf8>>,
                        line => 66})
    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_stdlib:string_ends_with(
                    erlang:element(2, 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>>,
                    module => <<"gserde"/utf8>>,
                    function => <<"process_single"/utf8>>,
                    line => 80}) 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),
                            Parsed,
                            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.

-file("/Users/cdaringe/src/gserde/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:with_entry_filter(
        _pipe@1,
        fun(It) ->
            gleam_stdlib:string_ends_with(
                erlang:element(2, It),
                <<".gleam"/utf8>>
            )
            andalso fswalk:only_files(It)
        end
    ),
    _pipe@3 = fswalk:walk(_pipe@2),
    _pipe@4 = fswalk:map(
        _pipe@3,
        fun(V) ->
            erlang:element(2, evil:expect(V, <<"failed to walk"/utf8>>))
        end
    ),
    fswalk:each(_pipe@4, fun(F) -> process_single(F, Is_debug) end).