#pragma once

#include "ddkit/utils/Logger.hpp"


namespace ddkit {
namespace actors {

//
// IComponent, IObserver, ISender
//

// IObserver or ISender
class IComponent {

public:
    virtual std::string module()     = 0;
    virtual bool        isService()  = 0; // caution: these method-names refer to Service and Client (Actor),
    virtual bool        isObserver() = 0; //          in which the Sender/Observer live, not to IService/IClient!

    // exceptionally we have (very lightweight) convenience-methods in the interface as well
    inline bool isClient() { return !isService(); }
    inline bool isSender() { return !isObserver(); }

    virtual ~IComponent() = default;
};

class IObserver : public IComponent {

public:
    // IComponent
    std::string module() override    = 0;
    bool        isService() override = 0;
    bool        isObserver() override { return true; }

    virtual void clearCallbacks() {}

    virtual ~IObserver() = default;
};
typedef std::shared_ptr<IObserver> IObserverPtr;

class ISender : public IComponent {

public:
    // IComponent
    std::string module() override    = 0;
    bool        isService() override = 0;
    bool        isObserver() override { return false; }

    virtual ~ISender() = default;
};
typedef std::shared_ptr<ISender> ISenderPtr;


//
// static_asserts to be included in every template-function
//
// observer w/o object - call checkTypeOfObserver<Observer>();
template <typename Observer>
void checkObserverType() {
    DDKIT_LOG_TRACE;
    static_assert(std::is_base_of<IObserver, Observer>::value, "Observer not derived from IObserver");
    static_assert(!std::is_same<IObserver, Observer>::value, "Observer same class as IObserver");
}

// observer with object - simply call checkTypeOfObserver(observer);
template <typename Observer>
void checkTypeOfObserver(Observer* observer) {
    DDKIT_LOG_TRACE << DDKIT_LOG_VAR_VALUE(observer);
    checkObserverType<Observer>();
}

// sender w/o object - call checkSenderType<Sender>();
template <typename Sender>
void checkSenderType() {
    DDKIT_LOG_TRACE;
    static_assert(std::is_base_of<ISender, Sender>::value, "Sender not derived from ISender");
    static_assert(!std::is_same<ISender, Sender>::value, "Sender same class as ISender");
    static_assert(std::is_base_of<typename Sender::TypeUser, Sender>::value, "Sender not derived from TypeUser");
}

// sender with object - simply call checkTypeOfSender(sender);
template <typename Sender>
void checkTypeOfSender(Sender* sender) {
    DDKIT_LOG_TRACE << DDKIT_LOG_VAR_VALUE(sender);
    checkSenderType<Sender>();
}

} // namespace actors
} // namespace ddkit