-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(ISN, ISO) :: {procedure,
        binary(),
        gleam@option:option(router()),
        procedure_type(),
        convert:converter(ISN),
        convert:converter(ISO)}.

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

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

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

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

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

-type procedure_client(ISR, ISS, IST) :: {procedure_client,
        fun((procedure(ISR, ISS), ISR, fun(({ok, ISS} |
            {error, gleam_rpc_error(IST)}) -> nil)) -> nil)}.

-type procedure_call(ISU, ISV, ISW) :: {procedure_call,
        procedure(ISU, ISV),
        procedure_client(ISU, ISV, ISW)}.

-type procedure_server(ISX, ISY, ISZ) :: {procedure_server,
        fun((ISX) -> {ok, procedure_identity()} |
            {error, gleam_rpc_server_error(ISZ)}),
        fun((ISX) -> fun((procedure_type(), convert:glitr_type()) -> {ok,
                convert:glitr_value()} |
            {error, gleam_rpc_server_error(ISZ)})),
        fun((gleam_rpc_server_error(ISZ)) -> ISY),
        fun((convert:glitr_value()) -> ISY)}.

-type procedure_server_instance(ITA, ITB, ITC, ITD) :: {procedure_server_instance,
        procedure_server(ITA, ITB, ITD),
        fun((procedure_identity(), fun((procedure_type(), convert:glitr_type()) -> {ok,
                convert:glitr_value()} |
            {error, gleam_rpc_server_error(ITD)}), ITC) -> {ok,
                convert:glitr_value()} |
            {error, gleam_rpc_server_error(ITD)}),
        fun((ITA) -> ITC)}.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 97).
-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", 101).
-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", 108).
-spec params(procedure(ITW, ITT), convert:converter(ITW)) -> procedure(ITW, ITT).
params(Procedure, Params_converter) ->
    erlang:setelement(5, Procedure, Params_converter).

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

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 122).
-spec with_client(procedure(IUI, IUJ), procedure_client(IUI, IUJ, IUM)) -> procedure_call(IUI, IUJ, IUM).
with_client(Procedure, Client) ->
    {procedure_call, Procedure, Client}.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 129).
-spec call(
    procedure_call(IUT, IUU, IUV),
    IUT,
    fun(({ok, IUU} | {error, gleam_rpc_error(IUV)}) -> 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", 144).
-spec with_server(procedure_server(IVC, IVD, IVE)) -> procedure_server_instance(IVC, IVD, IVC, IVE).
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", 154).
-spec with_context(
    procedure_server_instance(IVM, IVN, IVU, IVP),
    fun((IVM) -> IVU)
) -> procedure_server_instance(IVM, IVN, IVU, IVP).
with_context(Server, Context_factory) ->
    erlang:setelement(4, Server, Context_factory).

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 172).
-spec serve(procedure_server_instance(IWR, IWS, any(), any())) -> fun((IWR) -> IWS).
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", 192).
-spec add_procedure(
    fun((procedure_identity(), fun((procedure_type(), convert:glitr_type()) -> {ok,
            convert:glitr_value()} |
        {error, gleam_rpc_server_error(IXA)}), IWZ) -> {ok,
            convert:glitr_value()} |
        {error, gleam_rpc_server_error(IXA)}),
    procedure(IXD, IXE),
    fun((IXD, IWZ) -> {ok, IXE} | {error, procedure_error()})
) -> fun((procedure_identity(), fun((procedure_type(), convert:glitr_type()) -> {ok,
        convert:glitr_value()} |
    {error, gleam_rpc_server_error(IXA)}), IWZ) -> {ok, convert:glitr_value()} |
    {error, gleam_rpc_server_error(IXA)}).
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", 161).
-spec with_implementation(
    procedure_server_instance(IVZ, IWA, IWB, IWC),
    procedure(IWH, IWI),
    fun((IWH, IWB) -> {ok, IWI} | {error, procedure_error()})
) -> procedure_server_instance(IVZ, IWA, IWB, IWC).
with_implementation(Server, Procedure, Implementation) ->
    erlang:setelement(
        3,
        Server,
        add_procedure(erlang:element(3, Server), Procedure, Implementation)
    ).