-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, 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 gleam_rpc_server_error(ISQ) :: wrong_procedure |
    {procedure_error, ISQ} |
    {get_identity_error, ISQ} |
    {get_params_error, ISQ} |
    {decode_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) -> {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(), convert:glitr_value(), ITC) -> {ok,
                convert:glitr_value()} |
            {error, gleam_rpc_server_error(ITD)}),
        fun((ITA) -> ITC)}.

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

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

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

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 120).
-spec call(
    procedure_call(IUQ, IUR, IUS),
    IUQ,
    fun(({ok, IUR} | {error, gleam_rpc_error(IUS)}) -> 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", 135).
-spec with_server(procedure_server(IUZ, IVA, IVB)) -> procedure_server_instance(IUZ, IVA, IUZ, IVB).
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", 145).
-spec with_context(
    procedure_server_instance(IVJ, IVK, IVR, IVM),
    fun((IVJ) -> IVR)
) -> procedure_server_instance(IVJ, IVK, IVR, IVM).
with_context(Server, Context_factory) ->
    erlang:setelement(4, Server, Context_factory).

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 164).
-spec serve(procedure_server_instance(IWP, IWQ, any(), any())) -> fun((IWP) -> IWQ).
serve(Server) ->
    fun(In) ->
        Result = (gleam@result:'try'(
            (erlang:element(2, erlang:element(2, Server)))(In),
            fun(Identity) ->
                gleam@result:'try'(
                    (erlang:element(3, erlang:element(2, Server)))(In),
                    fun(Params) ->
                        Context = (erlang:element(4, Server))(In),
                        _pipe = (erlang:element(3, Server))(
                            Identity,
                            Params,
                            Context
                        ),
                        gleam@result:map(
                            _pipe,
                            erlang:element(5, erlang:element(2, Server))
                        )
                    end
                )
            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", 184).
-spec add_procedure(
    fun((procedure_identity(), convert:glitr_value(), IWX) -> {ok,
            convert:glitr_value()} |
        {error, gleam_rpc_server_error(IWY)}),
    procedure(IXB, IXC),
    fun((IXB, IWX) -> {ok, IXC} | {error, gleam_rpc_server_error(IWY)})
) -> fun((procedure_identity(), convert:glitr_value(), IWX) -> {ok,
        convert:glitr_value()} |
    {error, gleam_rpc_server_error(IWY)}).
add_procedure(Handler, Procedure, Implementation) ->
    fun(Identity, Params, Context) -> case Handler(Identity, Params, 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
                    )) ->
                        _pipe = Params,
                        _pipe@1 = (convert:decode(erlang:element(5, Procedure)))(
                            _pipe
                        ),
                        _pipe@2 = gleam@result:map_error(
                            _pipe@1,
                            fun(Field@0) -> {decode_error, Field@0} end
                        ),
                        _pipe@3 = gleam@result:then(
                            _pipe@2,
                            fun(_capture) ->
                                Implementation(_capture, Context)
                            end
                        ),
                        gleam@result:map(
                            _pipe@3,
                            convert:encode(erlang:element(6, Procedure))
                        );

                    _ ->
                        {error, wrong_procedure}
                end;

            _ = Result ->
                Result
        end end.

-file("/home/runner/work/gleamrpc/gleamrpc/src/gleamrpc.gleam", 152).
-spec with_implementation(
    procedure_server_instance(IVW, IVX, IVY, IVZ),
    procedure(IWE, IWF),
    fun((IWE, IVY) -> {ok, IWF} | {error, gleam_rpc_server_error(IVZ)})
) -> procedure_server_instance(IVW, IVX, IVY, IVZ).
with_implementation(Server, Procedure, Implementation) ->
    erlang:setelement(
        3,
        Server,
        add_procedure(erlang:element(3, Server), Procedure, Implementation)
    ).