glitr_wisp

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

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

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

-type route_options(TGL, TGM, TGN) :: {route_options, TGL, TGM, TGN}.

-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(TIP, any(), any(), any()),
    fun((TIP) -> {ok, gleam@http@response:response(wisp:body())} | {error, nil})
) -> {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} ->
            Callback(Path);

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

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

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

-spec handle_body(
    gleam@http@request:request(wisp@internal:connection()),
    glitr:route(any(), any(), TJP, any()),
    fun((TJP) -> gleam@http@response:response(wisp:body()))
) -> {ok, gleam@http@response:response(wisp:body())} | {error, nil}.
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,
    Body = case erlang:element(6, Route) of
        false ->
            _pipe@1 = gleam_stdlib:identity(nil),
            _pipe@2 = (erlang:element(3, erlang:element(9, Route)))(_pipe@1),
            Call_callback(_pipe@2);

        true ->
            wisp:require_json(Req, fun(Json) -> _pipe@3 = Json,
                    _pipe@4 = (erlang:element(3, erlang:element(9, Route)))(
                        _pipe@3
                    ),
                    Call_callback(_pipe@4) end)
    end,
    {ok, Body}.

-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);

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

-spec 'receive'(
    gleam@http@request:request(wisp@internal:connection()),
    glitr:route(TIA, TIB, TIC, TID),
    fun((route_options(TIA, TIB, TIC)) -> {ok, TID} |
        {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_query(
                        Req,
                        Route,
                        fun(Query) ->
                            handle_body(
                                Req,
                                Route,
                                fun(Body) ->
                                    handle_result(
                                        fun() ->
                                            Result = Handler(
                                                {route_options,
                                                    Path,
                                                    Query,
                                                    Body}
                                            ),
                                            _pipe = Result,
                                            _pipe@1 = gleam@result:map(
                                                _pipe,
                                                erlang:element(
                                                    2,
                                                    erlang:element(10, Route)
                                                )
                                            ),
                                            gleam@result:map(
                                                _pipe@1,
                                                fun gleam@json:to_string_builder/1
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-spec 'try'(
    {ok, router()} | {error, gleam@http@response:response(wisp:body())},
    glitr:route(TGS, TGT, TGU, TGV),
    fun((route_options(TGS, TGT, TGU)) -> {ok, TGV} |
        {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
    ).

-spec try_map(
    {ok, router()} | {error, gleam@http@response:response(wisp:body())},
    glitr:route(THJ, THK, THL, THM),
    fun((route_options(THJ, THK, THL)) -> {ok, THM} |
        {error, glitr_wisp@errors:app_error()}),
    fun((gleam@http@response:response(wisp:body())) -> gleam@http@response:response(wisp:body()))
) -> {ok, router()} | {error, gleam@http@response:response(wisp:body())}.
try_map(Router_res, Route, Handler, Map_fn) ->
    gleam@result:'try'(
        Router_res,
        fun(Router) ->
            Result = 'receive'(erlang:element(2, Router), Route, Handler),
            case Result of
                {ok, Response} ->
                    {error,
                        begin
                            _pipe = Response,
                            Map_fn(_pipe)
                        end};

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