#pragma once

#include "ddkit/base/ThreadInline.hpp"
#include "ddkit/access/ConfigLoaderDds.hpp"
#include "ddkit/actors/CallbackInfo.hpp"

#include <memory>
#include <mutex>
#include <vector>
#include <map>

namespace ddkit {
namespace actors {

class SessionImpl;
typedef std::shared_ptr<SessionImpl> SessionImplPtr;
typedef std::weak_ptr<SessionImpl> SessionImplWeakPtr;

class SessionManager {

public:
    static SessionManager& instance();

    SessionImplPtr createSessionImpl(int domain, bool isMonitor); // called from SessionImpl

    SessionImplPtr findSession(const std::string& sessionId); // called from BackwardManager

    void removeExpiredSessions(); // called from BackwardManager, MonitorSession, Session
    void removeSession(const std::string& sessionId);

    void setCallbackInfo(const CallbackInfo& callbackInfo); // called from ActorImpl
    void resetCallbackInfo(); // called from ActorImpl, generated Code
    CallbackInfo callbackInfo(); // called from ActorImpl, BackwardManager, CallbackInfo, generated Code

    bool isClean() const;

private:
    std::shared_ptr<access::ConfigLoaderDds> m_configLoaderDds;

    std::mutex m_sessionMutex;
    std::map<std::string, SessionImplWeakPtr> m_sessionId2sessionImpl; // holding map for sessions

    std::mutex m_callbackMutex;
    std::map<std::string, CallbackInfo> m_threadId2callbackInfo; // per thread (typically one entry - while callback)

    SessionManager();
    ~SessionManager();

    bool hasSession(const std::string& sessionId);
    bool hasSessions();

    // no copying
    SessionManager(SessionManager const&) = delete;
    SessionManager(SessionManager&&)      = delete;
    void operator=(SessionManager const&) = delete;
};

} // namespace actors
} // namespace ddkit