dagger_gleam

-module(dagger@interpreter).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/dagger/interpreter.gleam").
-export([run/2]).

-file("src/dagger/interpreter.gleam", 28).
-spec check_errors(gleam@dynamic:dynamic_()) -> {ok, nil} |
    {error, dagger@types:query_error()}.
check_errors(Dyn) ->
    Errors_decoder = gleam@dynamic@decode:at(
        [<<"errors"/utf8>>],
        gleam@dynamic@decode:list(
            gleam@dynamic@decode:at(
                [<<"message"/utf8>>],
                {decoder, fun gleam@dynamic@decode:decode_string/1}
            )
        )
    ),
    case gleam@dynamic@decode:run(Dyn, Errors_decoder) of
        {ok, [_ | _] = Msgs} ->
            {error,
                {execution_error,
                    gleam@list:map(Msgs, fun(M) -> {graph_q_l_error, M, []} end)}};

        _ ->
            {ok, nil}
    end.

-file("src/dagger/interpreter.gleam", 76).
-spec run_id_resolver(
    dagger@types:dagger_op(list(dagger@types:field())),
    dagger@types:client()
) -> {ok, binary()} | {error, dagger@types:query_error()}.
run_id_resolver(Op, Client) ->
    Fields = dagger@types:get_query(Op),
    Query_string = dagger@types:serialize(Fields),
    dagger@logger:report(
        {debug,
            <<"ID RESOLVER: "/utf8, (dagger@types:serialize(Fields))/binary>>}
    ),
    gleam@result:'try'(
        dagger@client:raw_query(Client, Query_string),
        fun(Dynamic_data) ->
            gleam@result:'try'(
                check_errors(Dynamic_data),
                fun(_) ->
                    Path = dagger@types:make_path(Fields),
                    _pipe = gleam@dynamic@decode:run(
                        Dynamic_data,
                        gleam@dynamic@decode:at(
                            Path,
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        )
                    ),
                    gleam@result:map_error(
                        _pipe,
                        fun(_) ->
                            {decoding_error,
                                <<"Impossibile decodificare ID dall'oggetto"/utf8>>}
                        end
                    )
                end
            )
        end
    ).

-file("src/dagger/interpreter.gleam", 57).
-spec resolve_value(dagger@types:value(), dagger@types:client()) -> dagger@types:value().
resolve_value(Val, Client) ->
    case Val of
        {g_deferred, Op} ->
            Id_op = dagger@types:bind(
                Op,
                fun(Fields) ->
                    {pure,
                        lists:append(Fields, [{field, <<"id"/utf8>>, [], []}])}
                end
            ),
            case run_id_resolver(Id_op, Client) of
                {ok, Id} ->
                    {g_string, Id};

                {error, _} ->
                    erlang:error(#{gleam_error => panic,
                            message => <<"Fallita risoluzione ID Dagger"/utf8>>,
                            file => <<?FILEPATH/utf8>>,
                            module => <<"dagger/interpreter"/utf8>>,
                            function => <<"resolve_value"/utf8>>,
                            line => 66})
            end;

        {g_list, Items} ->
            {g_list,
                gleam@list:map(
                    Items,
                    fun(_capture) -> resolve_value(_capture, Client) end
                )};

        {g_object, Fields@1} ->
            {g_object,
                gleam@list:map(
                    Fields@1,
                    fun(F) ->
                        {erlang:element(1, F),
                            resolve_value(erlang:element(2, F), Client)}
                    end
                )};

        _ ->
            Val
    end.

-file("src/dagger/interpreter.gleam", 42).
-spec resolve_fields(list(dagger@types:field()), dagger@types:client()) -> list(dagger@types:field()).
resolve_fields(Fields, Client) ->
    gleam@list:map(
        Fields,
        fun(Field) ->
            {field,
                erlang:element(2, Field),
                gleam@list:map(
                    erlang:element(3, Field),
                    fun(Arg) ->
                        {erlang:element(1, Arg),
                            resolve_value(erlang:element(2, Arg), Client)}
                    end
                ),
                resolve_fields(erlang:element(4, Field), Client)}
        end
    ).

-file("src/dagger/interpreter.gleam", 11).
-spec run(
    dagger@types:dagger_op({ok, FSX} | {error, dagger@types:query_error()}),
    dagger@types:client()
) -> {ok, FSX} | {error, dagger@types:query_error()}.
run(Op, Client) ->
    case Op of
        {pure, Result} ->
            Result;

        {fetch, Fields, _, Next} ->
            Resolved_fields = resolve_fields(Fields, Client),
            Query_string = dagger@types:serialize(Resolved_fields),
            gleam@result:'try'(
                dagger@client:raw_query(Client, Query_string),
                fun(Dynamic_data) ->
                    gleam@result:'try'(
                        check_errors(Dynamic_data),
                        fun(_) ->
                            Next_op = Next(Dynamic_data),
                            run(Next_op, Client)
                        end
                    )
                end
            )
    end.