glitr_wisp

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

-export([for/1, unwrap/1, 'try'/3]).
-export_type([router/0, route_options/2]).

-type router() :: {router,
        gleam@http@request:request(wisp@internal:connection())}.

-type route_options(TED, TEE) :: {route_options, TED, TEE}.

-spec for(gleam@http@request:request(wisp@internal:connection())) -> {ok,
        router()} |
    {error, gleam@http@response:response(wisp:body())}.
for(Req) ->
    {ok, {router, Req}}.

-spec unwrap(
    {ok, router()} | {error, gleam@http@response:response(wisp:body())}
) -> gleam@http@response:response(wisp:body()).
unwrap(Router_res) ->
    case Router_res of
        {ok, _} ->
            wisp:not_found();

        {error, Response} ->
            Response
    end.

-spec handle_path(
    gleam@http@request:request(wisp@internal:connection()),
    glitr:route(TFJ, any(), any()),
    fun((TFJ) -> gleam@http@response:response(wisp:body()))
) -> {ok, gleam@http@response:response(wisp:body())} | {error, nil}.
handle_path(Req, Route, Callback) ->
    Path_result = begin
        _pipe = Req,
        _pipe@1 = fun gleam@http@request:path_segments/1(_pipe),
        (erlang:element(3, erlang:element(7, Route)))(_pipe@1)
    end,
    case Path_result of
        {ok, Path} ->
            {ok, Callback(Path)};

        {error, _} ->
            {error, nil}
    end.

-spec handle_body(
    gleam@http@request:request(wisp@internal:connection()),
    glitr:route(any(), TFS, any()),
    fun((TFS) -> gleam@http@response:response(wisp:body()))
) -> gleam@http@response:response(wisp:body()).
handle_body(Req, Route, Callback) ->
    Call_callback = fun(Res) -> case Res of
            {ok, Value} ->
                Callback(Value);

            {error, _} ->
                _pipe = wisp:bad_request(),
                wisp:string_body(
                    _pipe,
                    <<"Error while decoding body as JSON"/utf8>>
                )
        end end,
    case erlang:element(6, Route) of
        false ->
            Call_callback(
                (erlang:element(3, erlang:element(8, Route)))(
                    gleam_stdlib:identity(nil)
                )
            );

        true ->
            wisp:require_json(Req, fun(Json) -> _pipe@1 = Json,
                    _pipe@2 = (erlang:element(3, erlang:element(8, Route)))(
                        _pipe@1
                    ),
                    Call_callback(_pipe@2) end)
    end.

-spec handle_result(
    fun(() -> {ok, gleam@string_builder:string_builder()} |
        {error, glitr_wisp@errors:app_error()})
) -> gleam@http@response:response(wisp:body()).
handle_result(Handler) ->
    Result = Handler(),
    case Result of
        {ok, Res} ->
            wisp:json_response(Res, 200);

        {error, {decoder_error, Msg}} ->
            wisp:json_response(gleam@string_builder:from_string(Msg), 400);

        {error, {db_error, Msg@1}} ->
            wisp:json_response(gleam@string_builder:from_string(Msg@1), 500)
    end.

-spec 'receive'(
    gleam@http@request:request(wisp@internal:connection()),
    glitr:route(TEX, TEY, TEZ),
    fun((route_options(TEX, TEY)) -> {ok, TEZ} |
        {error, glitr_wisp@errors:app_error()})
) -> {ok, gleam@http@response:response(wisp:body())} | {error, nil}.
'receive'(Req, Route, Handler) ->
    gleam@bool:guard(
        erlang:element(2, Req) /= erlang:element(2, Route),
        {error, nil},
        fun() ->
            handle_path(
                Req,
                Route,
                fun(Path) ->
                    handle_body(
                        Req,
                        Route,
                        fun(Body) ->
                            handle_result(
                                fun() ->
                                    Result = Handler(
                                        {route_options, Path, Body}
                                    ),
                                    _pipe = Result,
                                    _pipe@1 = gleam@result:map(
                                        _pipe,
                                        erlang:element(
                                            2,
                                            erlang:element(9, Route)
                                        )
                                    ),
                                    gleam@result:map(
                                        _pipe@1,
                                        fun gleam@json:to_string_builder/1
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-spec 'try'(
    {ok, router()} | {error, gleam@http@response:response(wisp:body())},
    glitr:route(TEJ, TEK, TEL),
    fun((route_options(TEJ, TEK)) -> {ok, TEL} |
        {error, glitr_wisp@errors:app_error()})
) -> {ok, router()} | {error, gleam@http@response:response(wisp:body())}.
'try'(Router_res, Route, Handler) ->
    gleam@result:'try'(
        Router_res,
        fun(Router) ->
            Result = 'receive'(erlang:element(2, Router), Route, Handler),
            case Result of
                {ok, Response} ->
                    {error, Response};

                {error, nil} ->
                    {ok, Router}
            end
        end
    ).