-module(glean@middleware).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/glean/middleware.gleam").
-export([request_middleware/1, result_middleware/1, apply/2, chain/1]).
-export_type([middleware/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-type middleware() :: {middleware,
        gleam@option:option(fun((glean@provider:generate_request()) -> glean@provider:generate_request())),
        gleam@option:option(fun((glean@provider:generate_result()) -> glean@provider:generate_result()))}.

-file("src/glean/middleware.gleam", 23).
?DOC(" Create a middleware that only transforms requests.\n").
-spec request_middleware(
    fun((glean@provider:generate_request()) -> glean@provider:generate_request())
) -> middleware().
request_middleware(Transform) ->
    {middleware, {some, Transform}, none}.

-file("src/glean/middleware.gleam", 30).
?DOC(" Create a middleware that only transforms results.\n").
-spec result_middleware(
    fun((glean@provider:generate_result()) -> glean@provider:generate_result())
) -> middleware().
result_middleware(Transform) ->
    {middleware, none, {some, Transform}}.

-file("src/glean/middleware.gleam", 81).
-spec identity_middleware() -> middleware().
identity_middleware() ->
    {middleware, none, none}.

-file("src/glean/middleware.gleam", 85).
-spec apply_transform(JAE, gleam@option:option(fun((JAE) -> JAE))) -> JAE.
apply_transform(Value, Transform) ->
    case Transform of
        none ->
            Value;

        {some, F} ->
            F(Value)
    end.

-file("src/glean/middleware.gleam", 49).
?DOC(" Wrap a provider with middleware, producing a new provider.\n").
-spec apply(glean@provider:provider(), middleware()) -> glean@provider:provider().
apply(Provider, Middleware) ->
    Transform_req = erlang:element(2, Middleware),
    Transform_res = erlang:element(3, Middleware),
    New_generate = fun(Request) ->
        Request@1 = apply_transform(Request, Transform_req),
        case (erlang:element(4, Provider))(Request@1) of
            {ok, Result} ->
                {ok, apply_transform(Result, Transform_res)};

            {error, Err} ->
                {error, Err}
        end
    end,
    New_stream = fun(Request@2, On_event) ->
        Request@3 = apply_transform(Request@2, Transform_req),
        case (erlang:element(5, Provider))(Request@3, On_event) of
            {ok, Result@1} ->
                {ok, apply_transform(Result@1, Transform_res)};

            {error, Err@1} ->
                {error, Err@1}
        end
    end,
    {provider,
        erlang:element(2, Provider),
        erlang:element(3, Provider),
        New_generate,
        New_stream}.

-file("src/glean/middleware.gleam", 92).
-spec compose_option(
    gleam@option:option(fun((JAG) -> JAG)),
    gleam@option:option(fun((JAG) -> JAG))
) -> gleam@option:option(fun((JAG) -> JAG)).
compose_option(First, Second) ->
    case {First, Second} of
        {none, none} ->
            none;

        {{some, F}, none} ->
            {some, F};

        {none, {some, G}} ->
            {some, G};

        {{some, F@1}, {some, G@1}} ->
            {some, fun(X) -> G@1(F@1(X)) end}
    end.

-file("src/glean/middleware.gleam", 39).
?DOC(
    " Chain multiple middlewares into one. Applied left-to-right:\n"
    " first middleware's request transform runs first,\n"
    " last middleware's result transform runs last.\n"
).
-spec chain(list(middleware())) -> middleware().
chain(Middlewares) ->
    gleam@list:fold(
        Middlewares,
        identity_middleware(),
        fun(Acc, Mw) ->
            {middleware,
                compose_option(erlang:element(2, Acc), erlang:element(2, Mw)),
                compose_option(erlang:element(3, Acc), erlang:element(3, Mw))}
        end
    ).