#pragma once
/*
 * auth_session.h - In-memory + SQLite dual-layer session management
 * 
 * Sessions are cached in memory for fast lookup, with SQLite as backing store.
 * Idle timeout: 30 minutes (1800s)
 * Absolute timeout: 8 hours (28800s), or 7 days if "remember me"
 */

#include "auth_db.h"
#include <string>
#include <unordered_map>
#include <mutex>
#include <ctime>

namespace auth {

class SessionManager {
public:
    SessionManager();

    void init(AuthDB *db, int idle_timeout_sec = 1800,
              int absolute_timeout_sec = 28800,
              int remember_timeout_sec = 604800);

    /* Create a new session for a user. Returns session_id. */
    std::string create_session(int user_id, const std::string &username,
                               const std::string &remote_ip, bool remember = false,
                               int user_role = 0);

    /* Validate a session. Returns true if valid. Updates last_active. */
    bool validate_session(const std::string &session_id, Session &sess);

    /* Destroy a session (logout) */
    void destroy_session(const std::string &session_id);

    /* Destroy all sessions for a user */
    void destroy_user_sessions(int user_id);

    /* Get CSRF token for a session */
    std::string get_csrf_token(const std::string &session_id);

    /* Periodic cleanup of expired sessions */
    void cleanup();

    /* Get active session count */
    int active_count();

private:
    AuthDB *db_ = nullptr;
    int idle_timeout_ = 1800;
    int absolute_timeout_ = 28800;
    int remember_timeout_ = 604800;

    /* In-memory cache: session_id -> Session */
    std::unordered_map<std::string, Session> cache_;
    std::mutex cache_mutex_;

    bool is_expired(const Session &sess, time_t now);
};

} // namespace auth