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

-export([get_session/2, delete_session/2, get/4, set/5, delete/3, replace_session/4, middleware/3]).

-spec get_session_with_cache(
    wisp_kv_sessions@session:session_id(),
    wisp_kv_sessions@session_config:config(),
    boolean()
) -> {ok, gleam@option:option(wisp_kv_sessions@session:session())} |
    {error, wisp_kv_sessions@session:session_error()}.
get_session_with_cache(Session_id, Config, Cache) ->
    case {Cache, erlang:element(5, Config)} of
        {true, {some, Cache@1}} ->
            case (erlang:element(2, Cache@1))(Session_id) of
                {ok, {some, Session}} ->
                    {ok, {some, Session}};

                _ ->
                    get_session_with_cache(Session_id, Config, false)
            end;

        {_, _} ->
            (erlang:element(2, erlang:element(4, Config)))(Session_id)
    end.

-spec save_session(
    wisp_kv_sessions@session_config:config(),
    wisp_kv_sessions@session:session()
) -> {ok, wisp_kv_sessions@session:session()} |
    {error, wisp_kv_sessions@session:session_error()}.
save_session(Config, Session) ->
    _pipe = erlang:element(5, Config),
    gleam@option:map(
        _pipe,
        fun(Cache) -> (erlang:element(3, Cache))(Session) end
    ),
    (erlang:element(3, erlang:element(4, Config)))(Session).

-spec get_session(
    wisp_kv_sessions@session_config:config(),
    gleam@http@request:request(wisp:connection())
) -> {ok, wisp_kv_sessions@session:session()} |
    {error, wisp_kv_sessions@session:session_error()}.
get_session(Config, Req) ->
    gleam@result:'try'(
        wisp_kv_sessions@internal@utils:get_session_id(
            erlang:element(3, Config),
            Req
        ),
        fun(Session_id) ->
            gleam@result:'try'(
                get_session_with_cache(Session_id, Config, true),
                fun(Maybe_session) -> case Maybe_session of
                        {some, Session} ->
                            case wisp_kv_sessions@internal@utils:is_session_expired(
                                Session
                            ) of
                                true ->
                                    {error, session_expired_error};

                                false ->
                                    {ok, Session}
                            end;

                        none ->
                            Session@1 = begin
                                _pipe = wisp_kv_sessions@session:builder(),
                                _pipe@1 = wisp_kv_sessions@session:with_id(
                                    _pipe,
                                    Session_id
                                ),
                                _pipe@2 = wisp_kv_sessions@session:with_expiry(
                                    _pipe@1,
                                    erlang:element(2, Config)
                                ),
                                wisp_kv_sessions@session:build(_pipe@2)
                            end,
                            save_session(Config, Session@1)
                    end end
            )
        end
    ).

-spec delete_session(
    wisp_kv_sessions@session_config:config(),
    gleam@http@request:request(wisp:connection())
) -> {ok, nil} | {error, wisp_kv_sessions@session:session_error()}.
delete_session(Config, Req) ->
    gleam@result:'try'(
        wisp_kv_sessions@internal@utils:get_session_id(
            erlang:element(3, Config),
            Req
        ),
        fun(Session_id) ->
            _pipe = erlang:element(5, Config),
            gleam@option:map(
                _pipe,
                fun(Cache) -> (erlang:element(4, Cache))(Session_id) end
            ),
            (erlang:element(4, erlang:element(4, Config)))(Session_id)
        end
    ).

-spec get(
    wisp_kv_sessions@session_config:config(),
    gleam@http@request:request(wisp:connection()),
    binary(),
    fun((gleam@dynamic:dynamic_()) -> {ok, SDJ} |
        {error, list(gleam@dynamic:decode_error())})
) -> {ok, gleam@option:option(SDJ)} |
    {error, wisp_kv_sessions@session:session_error()}.
get(Config, Req, Key, Decoder) ->
    gleam@result:'try'(
        get_session(Config, Req),
        fun(Session) ->
            case begin
                _pipe = gleam@dict:get(erlang:element(4, Session), Key),
                gleam@option:from_result(_pipe)
            end of
                none ->
                    {ok, none};

                {some, Data} ->
                    _pipe@1 = gleam@json:decode(Data, Decoder),
                    _pipe@2 = gleam@result:replace_error(_pipe@1, decode_error),
                    gleam@result:map(_pipe@2, fun(D) -> {some, D} end)
            end
        end
    ).

-spec set(
    wisp_kv_sessions@session_config:config(),
    gleam@http@request:request(wisp:connection()),
    binary(),
    SDM,
    fun((SDM) -> binary())
) -> {ok, SDM} | {error, wisp_kv_sessions@session:session_error()}.
set(Config, Req, Key, Data, Encoder) ->
    gleam@result:'try'(
        get_session(Config, Req),
        fun(Session) ->
            Json_data = Encoder(Data),
            New_session = begin
                _pipe = wisp_kv_sessions@session:builder_from(Session),
                _pipe@1 = wisp_kv_sessions@session:set_key_value(
                    _pipe,
                    Key,
                    Json_data
                ),
                wisp_kv_sessions@session:build(_pipe@1)
            end,
            gleam@result:map(
                save_session(Config, New_session),
                fun(_) -> Data end
            )
        end
    ).

-spec delete(
    wisp_kv_sessions@session_config:config(),
    gleam@http@request:request(wisp:connection()),
    binary()
) -> {ok, wisp_kv_sessions@session:session()} |
    {error, wisp_kv_sessions@session:session_error()}.
delete(Config, Req, Key) ->
    gleam@result:'try'(
        get_session(Config, Req),
        fun(Session) ->
            save_session(
                Config,
                erlang:setelement(
                    4,
                    Session,
                    gleam@dict:delete(erlang:element(4, Session), Key)
                )
            )
        end
    ).

-spec replace_session(
    wisp_kv_sessions@session_config:config(),
    gleam@http@response:response(wisp:body()),
    gleam@http@request:request(wisp:connection()),
    wisp_kv_sessions@session:session()
) -> {ok, gleam@http@response:response(wisp:body())} |
    {error, wisp_kv_sessions@session:session_error()}.
replace_session(Config, Res, Req, New_session) ->
    gleam@result:'try'(
        delete_session(Config, Req),
        fun(_) ->
            gleam@result:map(
                save_session(Config, New_session),
                fun(_) ->
                    wisp_kv_sessions@internal@utils:set_session_cookie(
                        erlang:element(3, Config),
                        Res,
                        Req,
                        New_session
                    )
                end
            )
        end
    ).

-spec middleware(
    wisp_kv_sessions@session_config:config(),
    gleam@http@request:request(wisp:connection()),
    fun((gleam@http@request:request(wisp:connection())) -> gleam@http@response:response(wisp:body()))
) -> gleam@http@response:response(wisp:body()).
middleware(Config, Req, Handle_request) ->
    case wisp_kv_sessions@internal@utils:get_session_id(
        erlang:element(3, Config),
        Req
    ) of
        {ok, _} ->
            Handle_request(Req);

        {error, _} ->
            Session = begin
                _pipe = wisp_kv_sessions@session:builder(),
                _pipe@1 = wisp_kv_sessions@session:with_expiry(
                    _pipe,
                    erlang:element(2, Config)
                ),
                wisp_kv_sessions@session:build(_pipe@1)
            end,
            _ = (erlang:element(3, erlang:element(4, Config)))(Session),
            Res = begin
                _pipe@2 = wisp_kv_sessions@internal@utils:inject_session_cookie(
                    erlang:element(3, Config),
                    Req,
                    erlang:element(2, Session),
                    signed
                ),
                Handle_request(_pipe@2)
            end,
            _pipe@3 = Res,
            _pipe@4 = gleam@http@response:get_cookies(_pipe@3),
            _pipe@5 = gleam@list:key_find(_pipe@4, erlang:element(3, Config)),
            (fun(Cookie) -> case Cookie of
                    {ok, _} ->
                        Res;

                    {error, _} ->
                        wisp_kv_sessions@internal@utils:set_session_cookie(
                            erlang:element(3, Config),
                            Res,
                            Req,
                            Session
                        )
                end end)(_pipe@5)
    end.