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

-export([http_server/0, init_mist/2, cors_middleware/1]).
-export_type([http_server_error/0, cors_origins/0]).

-type http_server_error() :: {method_unsupported, gleam@http:method()} |
    no_name_error |
    {wrong_prefix, binary()}.

-type cors_origins() :: all_origins | {cors_origins, list(binary())}.

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 52).
-spec extract_procedure_type(gleam@http@request:request(any())) -> {ok,
        gleamrpc:procedure_type()} |
    {error, gleamrpc:gleam_rpc_server_error(http_server_error())}.
extract_procedure_type(In_request) ->
    case erlang:element(2, In_request) of
        get ->
            {ok, 'query'};

        post ->
            {ok, mutation};

        _ = Method ->
            {error, {get_identity_error, {method_unsupported, Method}}}
    end.

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 77).
-spec build_name_and_router(
    list(binary()),
    gleam@option:option(gleamrpc:router())
) -> {ok, {binary(), gleam@option:option(gleamrpc:router())}} |
    {error, gleamrpc:gleam_rpc_server_error(http_server_error())}.
build_name_and_router(Segments, Router) ->
    case Segments of
        [Name] ->
            {ok, {Name, Router}};

        [Name@1 | Rest] ->
            build_name_and_router(Rest, {some, {router, Name@1, Router}});

        [] ->
            {error, {get_identity_error, no_name_error}}
    end.

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 65).
-spec extract_procedure_name_and_router(gleam@http@request:request(any())) -> {ok,
        {binary(), gleam@option:option(gleamrpc:router())}} |
    {error, gleamrpc:gleam_rpc_server_error(http_server_error())}.
extract_procedure_name_and_router(In_request) ->
    case begin
        _pipe = In_request,
        gleam@http@request:path_segments(_pipe)
    end of
        [<<"api"/utf8>>, <<"gleamRPC"/utf8>> | Rest] ->
            build_name_and_router(Rest, none);

        _ ->
            {error,
                {get_identity_error,
                    {wrong_prefix, erlang:element(8, In_request)}}}
    end.

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 39).
-spec get_identity(gleam@http@request:request(any())) -> {ok,
        gleamrpc:procedure_identity()} |
    {error, gleamrpc:gleam_rpc_server_error(http_server_error())}.
get_identity(In_request) ->
    gleam@result:'try'(
        extract_procedure_type(In_request),
        fun(Type_) ->
            gleam@result:'try'(
                extract_procedure_name_and_router(In_request),
                fun(_use0) ->
                    {Name, Router} = _use0,
                    {ok, {procedure_identity, Name, Router, Type_}}
                end
            )
        end
    ).

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 105).
-spec get_params_query(
    gleam@http@request:request(mist@internal@http:connection()),
    convert:glitr_type()
) -> {ok, convert:glitr_value()} |
    {error, gleamrpc:gleam_rpc_server_error(http_server_error())}.
get_params_query(Request, Params_type) ->
    _pipe = gleam@http@request:get_query(Request),
    _pipe@1 = gleam@result:replace_error(
        _pipe,
        {get_params_error,
            [{decode_error, <<"A valid query"/utf8>>, <<""/utf8>>, []}]}
    ),
    gleam@result:then(_pipe@1, fun(Query_value) -> _pipe@2 = Query_value,
            _pipe@3 = (convert@http@query:decode_value(Params_type))(_pipe@2),
            gleam@result:map_error(
                _pipe@3,
                fun(Field@0) -> {get_params_error, Field@0} end
            ) end).

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 130).
-spec mist_read_error_to_get_params_error(mist:read_error()) -> gleamrpc:gleam_rpc_server_error(any()).
mist_read_error_to_get_params_error(Err) ->
    case Err of
        excess_body ->
            {get_params_error,
                [{decode_error, <<"Body size <= 65000"/utf8>>, <<""/utf8>>, []}]};

        malformed_body ->
            {get_params_error,
                [{decode_error,
                        <<"A valid body"/utf8>>,
                        <<"Malformed body"/utf8>>,
                        []}]}
    end.

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 145).
-spec decode_bit_array_request(
    gleam@http@request:request(bitstring()),
    convert:glitr_type()
) -> {ok, convert:glitr_value()} |
    {error, gleamrpc:gleam_rpc_server_error(http_server_error())}.
decode_bit_array_request(Request, Params_type) ->
    _pipe = erlang:element(4, Request),
    _pipe@1 = gleam@json:decode_bits(
        _pipe,
        convert@json:decode_value(Params_type)
    ),
    gleam@result:map_error(_pipe@1, fun(Err) -> case Err of
                {unable_to_decode, Decode_err} ->
                    _pipe@2 = Decode_err,
                    _pipe@3 = gleam@list:map(
                        _pipe@2,
                        fun(Err@1) ->
                            {decode_error,
                                erlang:element(2, Err@1),
                                erlang:element(3, Err@1),
                                erlang:element(4, Err@1)}
                        end
                    ),
                    {get_params_error, _pipe@3};

                {unexpected_byte, Byte} ->
                    {get_params_error,
                        [{decode_error,
                                <<"A valid JSON"/utf8>>,
                                <<"Unexpected byte : "/utf8, Byte/binary>>,
                                []}]};

                unexpected_end_of_input ->
                    {get_params_error,
                        [{decode_error,
                                <<"A valid JSON"/utf8>>,
                                <<"Unexpected end of input"/utf8>>,
                                []}]};

                {unexpected_format, Decode_err@1} ->
                    {get_params_error, Decode_err@1};

                {unexpected_sequence, Seq} ->
                    {get_params_error,
                        [{decode_error,
                                <<"A valid JSON"/utf8>>,
                                <<"Unexpected sequence : "/utf8, Seq/binary>>,
                                []}]}
            end end).

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 120).
-spec get_params_mutation(
    gleam@http@request:request(mist@internal@http:connection()),
    convert:glitr_type()
) -> {ok, convert:glitr_value()} |
    {error, gleamrpc:gleam_rpc_server_error(http_server_error())}.
get_params_mutation(Request, Params_type) ->
    _pipe = Request,
    _pipe@1 = mist:read_body(_pipe, 65000),
    _pipe@2 = gleam@result:map_error(
        _pipe@1,
        fun mist_read_error_to_get_params_error/1
    ),
    gleam@result:then(
        _pipe@2,
        fun(_capture) -> decode_bit_array_request(_capture, Params_type) end
    ).

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 93).
-spec get_params(gleam@http@request:request(mist@internal@http:connection())) -> fun((gleamrpc:procedure_type(), convert:glitr_type()) -> {ok,
        convert:glitr_value()} |
    {error, gleamrpc:gleam_rpc_server_error(http_server_error())}).
get_params(Request) ->
    fun(Procedure_type, Params_type) -> case Procedure_type of
            mutation ->
                get_params_mutation(Request, Params_type);

            'query' ->
                get_params_query(Request, Params_type)
        end end.

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 221).
-spec response_from_string(integer(), binary()) -> gleam@http@response:response(mist:response_data()).
response_from_string(Response_code, Body) ->
    {response,
        Response_code,
        [],
        {bytes,
            begin
                _pipe = Body,
                gleam_stdlib:wrap_list(_pipe)
            end}}.

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 191).
-spec recover_http_server_error(http_server_error()) -> gleam@http@response:response(mist:response_data()).
recover_http_server_error(Error) ->
    case Error of
        {method_unsupported, Method} ->
            response_from_string(
                405,
                <<(begin
                        _pipe = Method,
                        gleam@http:method_to_string(_pipe)
                    end)/binary,
                    " not allowed"/utf8>>
            );

        no_name_error ->
            response_from_string(
                400,
                <<"Couldn't extract procedure name"/utf8>>
            );

        {wrong_prefix, Path} ->
            response_from_string(400, <<"Wrong prefix: "/utf8, Path/binary>>)
    end.

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 205).
-spec recover_decode_errors(list(gleam@dynamic:decode_error())) -> gleam@http@response:response(mist:response_data()).
recover_decode_errors(Errors) ->
    _pipe = Errors,
    _pipe@1 = gleam@list:map(
        _pipe,
        fun(Error) ->
            <<<<<<<<<<"Expected : "/utf8, (erlang:element(2, Error))/binary>>/binary,
                            ", got : "/utf8>>/binary,
                        (erlang:element(3, Error))/binary>>/binary,
                    " at "/utf8>>/binary,
                (gleam@string:join(erlang:element(4, Error), <<"."/utf8>>))/binary>>
        end
    ),
    _pipe@2 = gleam@string:join(_pipe@1, <<"\n"/utf8>>),
    response_from_string(400, _pipe@2).

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 180).
-spec recover_error(gleamrpc:gleam_rpc_server_error(http_server_error())) -> gleam@http@response:response(mist:response_data()).
recover_error(Error) ->
    case Error of
        {get_identity_error, Err} ->
            recover_http_server_error(Err);

        {get_params_error, Errors} ->
            recover_decode_errors(Errors);

        {procedure_exec_error, Err@1} ->
            response_from_string(500, erlang:element(2, Err@1));

        wrong_procedure ->
            response_from_string(404, <<"Procedure not found"/utf8>>)
    end.

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 232).
-spec encode_result(convert:glitr_value()) -> gleam@http@response:response(mist:response_data()).
encode_result(Result) ->
    Body = begin
        _pipe = convert@json:encode_value(Result),
        _pipe@1 = gleam@json:to_string(_pipe),
        _pipe@2 = gleam_stdlib:wrap_list(_pipe@1),
        {bytes, _pipe@2}
    end,
    _pipe@3 = gleam@http@response:new(200),
    gleam@http@response:set_body(_pipe@3, Body).

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 26).
-spec http_server() -> gleamrpc:procedure_server(gleam@http@request:request(mist@internal@http:connection()), gleam@http@response:response(mist:response_data()), http_server_error()).
http_server() ->
    {procedure_server,
        fun get_identity/1,
        fun get_params/1,
        fun recover_error/1,
        fun encode_result/1}.

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 256).
-spec init_mist(
    gleamrpc:procedure_server_instance(gleam@http@request:request(mist@internal@http:connection()), gleam@http@response:response(mist:response_data()), any(), http_server_error()),
    integer()
) -> mist:builder(mist@internal@http:connection(), mist:response_data()).
init_mist(Server, Port) ->
    _pipe = Server,
    _pipe@1 = gleamrpc:serve(_pipe),
    _pipe@2 = mist:new(_pipe@1),
    mist:port(_pipe@2, Port).

-file("/home/runner/work/gleamrpc_http_server/gleamrpc_http_server/src/gleamrpc/http/server.gleam", 279).
-spec cors_middleware(cors_origins()) -> fun((gleam@http@request:request(mist@internal@http:connection()), fun((gleam@http@request:request(mist@internal@http:connection())) -> gleam@http@response:response(mist:response_data()))) -> gleam@http@response:response(mist:response_data())).
cors_middleware(Origins) ->
    fun(In, Next) ->
        Response = Next(In),
        case Origins of
            all_origins ->
                _pipe = Response,
                gleam@http@response:set_header(
                    _pipe,
                    <<"Access-Control-Allow-Origin"/utf8>>,
                    <<"*"/utf8>>
                );

            {cors_origins, Origins@1} ->
                case {gleam@list:key_find(
                        erlang:element(3, In),
                        <<"origin"/utf8>>
                    ),
                    gleam@list:key_find(
                        erlang:element(3, In),
                        <<"Origin"/utf8>>
                    )} of
                    {{error, _}, {error, _}} ->
                        Response;

                    {{ok, Origin}, _} ->
                        case gleam@list:contains(Origins@1, Origin) of
                            false ->
                                Response;

                            true ->
                                _pipe@1 = Response,
                                gleam@http@response:set_header(
                                    _pipe@1,
                                    <<"Access-Control-Allow-Origin"/utf8>>,
                                    Origin
                                )
                        end;

                    {_, {ok, Origin}} ->
                        case gleam@list:contains(Origins@1, Origin) of
                            false ->
                                Response;

                            true ->
                                _pipe@1 = Response,
                                gleam@http@response:set_header(
                                    _pipe@1,
                                    <<"Access-Control-Allow-Origin"/utf8>>,
                                    Origin
                                )
                        end
                end
        end
    end.