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

-export(['query'/2, mutation/2, params/2, returns/2, with_client/2, call/3, with_server/1, with_context/2, serve/1, with_implementation/3]).
-export_type([procedure_type/0, procedure/2, procedure_identity/0, gleam_rpc_error/1, procedure_error/0, gleam_rpc_server_error/1, router/0, procedure_client/3, procedure_call/3, procedure_server/3, procedure_server_instance/4]).

-type procedure_type() :: 'query' | mutation.

-type procedure(FWJ, FWK) :: {procedure,
        binary(),
        gleam@option:option(router()),
        procedure_type(),
        convert:converter(FWJ),
        convert:converter(FWK)}.

-type procedure_identity() :: {procedure_identity,
        binary(),
        gleam@option:option(router()),
        procedure_type()}.

-type gleam_rpc_error(FWL) :: {gleam_rpc_error, FWL}.

-type procedure_error() :: {procedure_error, binary()}.

-type gleam_rpc_server_error(FWM) :: wrong_procedure |
    {procedure_exec_error, procedure_error()} |
    {get_identity_error, FWM} |
    {get_params_error, list(gleam@dynamic:decode_error())}.

-type router() :: {router, binary(), gleam@option:option(router())}.

-type procedure_client(FWN, FWO, FWP) :: {procedure_client,
        fun((procedure(FWN, FWO), FWN, fun(({ok, FWO} |
            {error, gleam_rpc_error(FWP)}) -> nil)) -> nil)}.

-type procedure_call(FWQ, FWR, FWS) :: {procedure_call,
        procedure(FWQ, FWR),
        procedure_client(FWQ, FWR, FWS)}.

-type procedure_server(FWT, FWU, FWV) :: {procedure_server,
        fun((FWT) -> {ok, procedure_identity()} |
            {error, gleam_rpc_server_error(FWV)}),
        fun((FWT) -> fun((procedure_type(), convert:glitr_type()) -> {ok,
                convert:glitr_value()} |
            {error, gleam_rpc_server_error(FWV)})),
        fun((gleam_rpc_server_error(FWV)) -> FWU),
        fun((convert:glitr_value()) -> FWU)}.

-type procedure_server_instance(FWW, FWX, FWY, FWZ) :: {procedure_server_instance,
        procedure_server(FWW, FWX, FWZ),
        fun((procedure_identity(), fun((procedure_type(), convert:glitr_type()) -> {ok,
                convert:glitr_value()} |
            {error, gleam_rpc_server_error(FWZ)}), FWY) -> {ok,
                convert:glitr_value()} |
            {error, gleam_rpc_server_error(FWZ)}),
        fun((FWW) -> FWY)}.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 117).
-spec 'query'(binary(), gleam@option:option(router())) -> procedure(nil, nil).
'query'(Name, Router) ->
    {procedure, Name, Router, 'query', convert:null(), convert:null()}.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 122).
-spec mutation(binary(), gleam@option:option(router())) -> procedure(nil, nil).
mutation(Name, Router) ->
    {procedure, Name, Router, mutation, convert:null(), convert:null()}.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 130).
-spec params(procedure(FXS, FXP), convert:converter(FXS)) -> procedure(FXS, FXP).
params(Procedure, Params_converter) ->
    erlang:setelement(5, Procedure, Params_converter).

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 138).
-spec returns(procedure(FXW, FYA), convert:converter(FYA)) -> procedure(FXW, FYA).
returns(Procedure, Return_converter) ->
    erlang:setelement(6, Procedure, Return_converter).

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 146).
-spec with_client(procedure(FYE, FYF), procedure_client(FYE, FYF, FYI)) -> procedure_call(FYE, FYF, FYI).
with_client(Procedure, Client) ->
    {procedure_call, Procedure, Client}.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 165).
-spec call(
    procedure_call(FYP, FYQ, FYR),
    FYP,
    fun(({ok, FYQ} | {error, gleam_rpc_error(FYR)}) -> nil)
) -> nil.
call(Procedure_call, Params, Callback) ->
    (erlang:element(2, erlang:element(3, Procedure_call)))(
        erlang:element(2, Procedure_call),
        Params,
        Callback
    ).

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 181).
-spec with_server(procedure_server(FYY, FYZ, FZA)) -> procedure_server_instance(FYY, FYZ, FYY, FZA).
with_server(Server) ->
    {procedure_server_instance,
        Server,
        fun(_, _, _) -> {error, wrong_procedure} end,
        fun gleam@function:identity/1}.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 192).
-spec with_context(
    procedure_server_instance(FZI, FZJ, FZQ, FZL),
    fun((FZI) -> FZQ)
) -> procedure_server_instance(FZI, FZJ, FZQ, FZL).
with_context(Server, Context_factory) ->
    erlang:setelement(4, Server, Context_factory).

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 222).
-spec serve(procedure_server_instance(GAN, GAO, any(), any())) -> fun((GAN) -> GAO).
serve(Server) ->
    fun(In) ->
        Result = (gleam@result:'try'(
            (erlang:element(2, erlang:element(2, Server)))(In),
            fun(Identity) ->
                Params_fn = (erlang:element(3, erlang:element(2, Server)))(In),
                Context = (erlang:element(4, Server))(In),
                _pipe = (erlang:element(3, Server))(
                    Identity,
                    Params_fn,
                    Context
                ),
                gleam@result:map(
                    _pipe,
                    erlang:element(5, erlang:element(2, Server))
                )
            end
        )),
        case Result of
            {ok, Out} ->
                Out;

            {error, Err} ->
                (erlang:element(4, erlang:element(2, Server)))(Err)
        end
    end.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 242).
-spec add_procedure(
    fun((procedure_identity(), fun((procedure_type(), convert:glitr_type()) -> {ok,
            convert:glitr_value()} |
        {error, gleam_rpc_server_error(GAW)}), GAV) -> {ok,
            convert:glitr_value()} |
        {error, gleam_rpc_server_error(GAW)}),
    procedure(GAZ, GBA),
    fun((GAZ, GAV) -> {ok, GBA} | {error, procedure_error()})
) -> fun((procedure_identity(), fun((procedure_type(), convert:glitr_type()) -> {ok,
        convert:glitr_value()} |
    {error, gleam_rpc_server_error(GAW)}), GAV) -> {ok, convert:glitr_value()} |
    {error, gleam_rpc_server_error(GAW)}).
add_procedure(Handler, Procedure, Implementation) ->
    fun(Identity, Params_fn, Context) ->
        case Handler(Identity, Params_fn, Context) of
            {error, wrong_procedure} ->
                case Identity of
                    {procedure_identity, Name, Router, Type_} when ((Name =:= erlang:element(
                        2,
                        Procedure
                    )) andalso (Router =:= erlang:element(3, Procedure))) andalso (Type_ =:= erlang:element(
                        4,
                        Procedure
                    )) ->
                        gleam@result:'try'(
                            Params_fn(
                                erlang:element(4, Procedure),
                                begin
                                    _pipe = erlang:element(5, Procedure),
                                    convert:type_def(_pipe)
                                end
                            ),
                            fun(Params) -> _pipe@1 = Params,
                                _pipe@2 = (convert:decode(
                                    erlang:element(5, Procedure)
                                ))(_pipe@1),
                                _pipe@3 = gleam@result:map_error(
                                    _pipe@2,
                                    fun(Field@0) -> {get_params_error, Field@0} end
                                ),
                                _pipe@5 = gleam@result:then(
                                    _pipe@3,
                                    fun(Params@1) ->
                                        _pipe@4 = Implementation(
                                            Params@1,
                                            Context
                                        ),
                                        gleam@result:map_error(
                                            _pipe@4,
                                            fun(Field@0) -> {procedure_exec_error, Field@0} end
                                        )
                                    end
                                ),
                                gleam@result:map(
                                    _pipe@5,
                                    convert:encode(erlang:element(6, Procedure))
                                ) end
                        );

                    _ ->
                        {error, wrong_procedure}
                end;

            _ = Result ->
                Result
        end
    end.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 200).
-spec with_implementation(
    procedure_server_instance(FZV, FZW, FZX, FZY),
    procedure(GAD, GAE),
    fun((GAD, FZX) -> {ok, GAE} | {error, procedure_error()})
) -> procedure_server_instance(FZV, FZW, FZX, FZY).
with_implementation(Server, Procedure, Implementation) ->
    erlang:setelement(
        3,
        Server,
        add_procedure(erlang:element(3, Server), Procedure, Implementation)
    ).