-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]).

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

-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:route(UCV, any(), any(), any()),
    fun((UCV) -> {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),
        glitr@path:decode(erlang:element(3, 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:route(any(), UDI, any(), any()),
    fun((UDI) -> {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),
        glitr@query:decode(erlang:element(4, 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:route(any(), any(), UDV, any()),
    fun((UDV) -> 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 begin
        _pipe@1 = erlang:element(5, Route),
        glitr@body:get_type(_pipe@1)
    end of
        empty_body ->
            _pipe@2 = erlang:element(5, Route),
            _pipe@3 = glitr@body:decode(_pipe@2, <<""/utf8>>),
            Call_callback(_pipe@3);

        json_body ->
            wisp:require_string_body(
                Req,
                fun(Value@1) ->
                    gleam@bool:guard(
                        begin
                            _pipe@4 = erlang:element(3, Req),
                            gleam@list:key_find(
                                _pipe@4,
                                <<"content-type"/utf8>>
                            )
                        end
                        /= {ok, <<"application/json"/utf8>>},
                        wisp:unsupported_media_type(
                            [<<"application/json"/utf8>>]
                        ),
                        fun() -> _pipe@5 = erlang:element(5, Route),
                            _pipe@6 = glitr@body:decode(_pipe@5, Value@1),
                            Call_callback(_pipe@6) end
                    )
                end
            );

        string_body ->
            wisp:require_string_body(
                Req,
                fun(Value@2) -> _pipe@7 = erlang:element(5, Route),
                    _pipe@8 = glitr@body:decode(_pipe@7, Value@2),
                    Call_callback(_pipe@8) end
            )
    end,
    {ok, Body}.

-spec handle_result(
    glitr@route:route(any(), any(), any(), UEG),
    fun(() -> {ok, UEG} | {error, glitr_wisp@errors:app_error()})
) -> gleam@http@response:response(wisp:body()).
handle_result(Route, Handler) ->
    Result = Handler(),
    case Result of
        {error, {decoder_error, Msg}} ->
            _pipe = wisp:bad_request(),
            wisp:set_body(_pipe, {text, gleam@string_builder:from_string(Msg)});

        {error, {db_error, Msg@1}} ->
            _pipe@1 = wisp:internal_server_error(),
            wisp:set_body(
                _pipe@1,
                {text, gleam@string_builder:from_string(Msg@1)}
            );

        {error, {internal_error, Msg@2}} ->
            _pipe@2 = wisp:internal_server_error(),
            wisp:set_body(
                _pipe@2,
                {text, gleam@string_builder:from_string(Msg@2)}
            );

        {ok, Res} ->
            case begin
                _pipe@3 = erlang:element(6, Route),
                glitr@body:get_type(_pipe@3)
            end of
                json_body ->
                    _pipe@4 = erlang:element(6, Route),
                    _pipe@5 = glitr@body:encode(_pipe@4, Res),
                    wisp:json_response(_pipe@5, 200);

                string_body ->
                    _pipe@6 = wisp:ok(),
                    wisp:set_body(
                        _pipe@6,
                        {text,
                            begin
                                _pipe@7 = erlang:element(6, Route),
                                glitr@body:encode(_pipe@7, Res)
                            end}
                    );

                empty_body ->
                    wisp:ok()
            end
    end.

-spec 'receive'(
    gleam@http@request:request(wisp@internal:connection()),
    glitr@route:route(UCG, UCH, UCI, UCJ),
    fun((glitr:route_options(UCG, UCH, UCI)) -> {ok, UCJ} |
        {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(
                                        Route,
                                        fun() ->
                                            Handler(
                                                {route_options,
                                                    Path,
                                                    Query,
                                                    Body}
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-spec 'try'(
    {ok, router()} | {error, gleam@http@response:response(wisp:body())},
    glitr@route:route(UAY, UAZ, UBA, UBB),
    fun((glitr:route_options(UAY, UAZ, UBA)) -> {ok, UBB} |
        {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:route(UBP, UBQ, UBR, UBS),
    fun((glitr:route_options(UBP, UBQ, UBR)) -> {ok, UBS} |
        {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
    ).