//-----------------------------------------------------------------------------
//     ___                      __ _       _
//    / _ \__ _ _ __ ___  ___  / /(_)_ __ | | __
//   / /_)/ _` | '__/ __|/ _ \/ / | | '_ \| |/ /
//  / ___/ (_| | |  \__ \  __/ /__| | | | |   <
//  \/    \__,_|_|  |___/\___\____/_|_| |_|_|\_\ .
//
//-----------------------------------------------------------------------------
// Author: Kurt Sassenrath
// Module: Server
//
// Simple in-memory session manager.
//
// Copyright (c) 2023 Kurt Sassenrath.
//
// License TBD.
//-----------------------------------------------------------------------------
#include <parselink/logging.h>
#include <parselink/server/memory_session_manager.h>

#include <fmt/chrono.h>

using namespace parselink;
using namespace std::chrono_literals;

namespace {

logging::logger logger("memory_session_manager");

constexpr std::size_t max_open_sessions = 1000;
constexpr auto expires_time = 1min;

} // namespace

memory_session_manager::memory_session_manager(boost::asio::io_context& ctx)
        : ctx_(ctx)
        , strand_(ctx) {
    logger.trace("Creating: {}", this);
}

memory_session_manager::~memory_session_manager() {
    logger.trace("Destroying: {}", this);
}

tl::expected<proto::session*, proto::error>
memory_session_manager::create_session(std::string_view user_id) {
    auto [itr, inserted] = sessions_.try_emplace(std::string{user_id}, user_id);
    if (!inserted) {
        logger.debug("Session already found for {}, last activity"
                     " {:%Y-%m-%d %H:%M:%S}",
                user_id, fmt::gmtime(itr->second.last_activity()));
        if (itr->second.last_activity() + expires_time
                < std::chrono::system_clock::now()) {
            logger.debug("Session expired. Creating new session");
            itr->second = proto::session{user_id};
        }
        return &itr->second;
    }
    lookup_by_sid_.emplace(itr->second.id(), &itr->second);
    return &itr->second;
}

tl::expected<tl::monostate, proto::error>
memory_session_manager::destroy_session(proto::session* s) {
    return tl::make_unexpected(proto::error::unsupported);
}

tl::expected<proto::session*, proto::error> memory_session_manager::find(
        std::string_view user_id) {
    auto x = sessions_.find(user_id);
    if (x != sessions_.end()) {
        return &x->second;
    }
    return tl::make_unexpected(proto::error::unsupported);
}

tl::expected<proto::session*, proto::error> memory_session_manager::find(
        proto::session_id const& sid) {
    auto x = lookup_by_sid_.find(sid);
    if (x != lookup_by_sid_.end()) {
        return x->second;
    }
    return tl::make_unexpected(proto::error::unsupported);
}