app.hpp

#pragma once
 
#include <litefx/app_api.hpp>
#include <litefx/app_formatters.hpp>
 
namespace LiteFX {
    using namespace LiteFX::Logging;
 
    class LITEFX_APPMODEL_API IBackend {
        friend class App;
 
    private:
        BackendState m_state = BackendState::Inactive;
 
    protected:
        IBackend() noexcept = default;
        IBackend(const IBackend&) = default;
        IBackend(IBackend&&) noexcept = default;
        IBackend& operator=(const IBackend&) = default;
        IBackend& operator=(IBackend&&) noexcept = default;
 
    public:
        virtual ~IBackend() noexcept = default;
 
    public:
        virtual BackendType type() const noexcept = 0;
 
        const BackendState& state() const noexcept { return m_state; }
 
        virtual StringView name() const noexcept = 0;
 
    protected:
        BackendState& state() noexcept { return m_state; }
 
        virtual void activate() = 0;
 
        virtual void deactivate() = 0;
 
    private:
        std::type_index typeId() const noexcept { return typeid(*this); }
    };
 
    template <typename T>
    concept backend = meta::implements<T, IBackend>;
 
    class LITEFX_APPMODEL_API EventArgs {
    public:
        EventArgs() = default;
 
        EventArgs(const EventArgs&) = default;
        EventArgs(EventArgs&&) noexcept = default;
        EventArgs& operator=(const EventArgs&) = default;
        EventArgs& operator=(EventArgs&&) noexcept = default;
        virtual ~EventArgs() noexcept = default;
    };
 
    template <typename TResult, typename... TArgs>
    class Delegate final {
    public:
        using function_type = std::function<TResult(TArgs...)>;
        using token_type = size_t;
 
    private:
        function_type m_target;
        token_type m_token;
 
    public:
        inline Delegate(function_type fn, token_type t) noexcept : 
            m_target(std::move(fn)), m_token(t) { }
 
    public:
        inline TResult invoke(TArgs... args) const {
            return m_target(std::move(args)...);
        }
 
        inline token_type token() const {
            return m_token;
        }
 
    public:
        inline TResult operator()(TArgs... args) const {
            return this->invoke(std::move(args)...);
        }
    };
 
    template <typename TEventArgs>
    class Event final {
    public:
        using event_args_type = TEventArgs;
        using delegate_type = Delegate<void, const void*, TEventArgs>;
        using function_type = typename delegate_type::function_type;
        using event_token_type = typename delegate_type::token_type;
 
    private:
        Array<delegate_type> m_subscribers{};
 
    public:
        constexpr Event() = default;
 
        constexpr Event([[maybe_unused]] const Event& _other) { }
 
        constexpr Event(Event&& _other) noexcept = default;
 
        constexpr Event& operator=([[maybe_unused]] const Event& _other) {
            m_subscribers.clear();
            return *this;
        }
 
        constexpr Event& operator=(Event&& _other) noexcept = default;
 
        constexpr ~Event() noexcept = default;
 
    public:
        event_token_type add(const function_type& subscriber) {
            const auto match = std::max_element(m_subscribers.begin(), m_subscribers.end(), [](const auto& lhs, const auto& rhs) { return lhs.token() < rhs.token(); });
            event_token_type token = match == m_subscribers.end() ? 0 : match->token() + 1;
            m_subscribers.emplace_back(subscriber, token);
            return token;
        }
 
        bool remove(const delegate_type& subscriber) noexcept {
            return this->remove(subscriber.token());
        }
 
        bool remove(event_token_type token) noexcept {
            const auto last = std::remove_if(m_subscribers.begin(), m_subscribers.end(), [&token](const auto& s) { return s.token() == token; });
 
            if (last == m_subscribers.end())
                return false;
 
            m_subscribers.erase(last, m_subscribers.end());
            return true;
        }
 
        void clear() noexcept {
            m_subscribers.clear();
        }
 
        void invoke(const void* sender, const TEventArgs& args) const {
            for (const auto& handler : m_subscribers)
                handler(sender, args);
        }
 
        bool contains(event_token_type token) const noexcept {
            return std::find_if(m_subscribers.begin(), m_subscribers.end(), [&token](const auto& d) { return d.token() == token; }) != m_subscribers.end();
        }
 
        const delegate_type& handler(event_token_type token) const {
            if (auto match = std::find_if(m_subscribers.begin(), m_subscribers.end(), [&token](const auto& d) { return d.token() == token; }); match != m_subscribers.end()) [[likely]]
                return *match;
 
            throw InvalidArgumentException("token", "The event does not contain the provided token.");
        }
 
    public:
        explicit operator bool() const noexcept {
            return !m_subscribers.empty();
        }
 
        event_token_type operator +=(const function_type& subscriber) {
            return this->add(subscriber);
        }
 
        bool operator -=(const delegate_type& subscriber) noexcept {
            return this->remove(subscriber);
        }
 
        bool operator -=(event_token_type token) noexcept {
            return this->remove(token);
        }
 
        void operator ()(const void* sender, const TEventArgs& args) const {
            this->invoke(sender, args);
        }
 
        const delegate_type& operator [](event_token_type token) const {
            return this->handler(token);
        }
    };
 
    struct LITEFX_APPMODEL_API ResizeEventArgs : public EventArgs {
    private:
        int m_width, m_height;
 
    public:
        ResizeEventArgs(int width, int height) noexcept : m_width(width), m_height(height) { }
        ResizeEventArgs(const ResizeEventArgs&) = default;
        ResizeEventArgs(ResizeEventArgs&&) noexcept = default;
        ~ResizeEventArgs() noexcept override = default;
 
    public:
        ResizeEventArgs& operator=(const ResizeEventArgs&) = default;
        ResizeEventArgs& operator=(ResizeEventArgs&&) noexcept = default;
 
    public:
        inline int width() const noexcept {
            return m_width;
        }
 
        inline int height() const noexcept {
            return m_height;
        }
    };
 
    class LITEFX_APPMODEL_API App {
        LITEFX_IMPLEMENTATION(AppImpl);
        LITEFX_BUILDER(AppBuilder);
 
    public:
        App();
        App(const App&) = delete;
        App(App&&) noexcept = delete;
        auto operator=(const App&) = delete;
        auto operator=(App&&) noexcept = delete;
 
        virtual ~App() noexcept;
 
    public:
        virtual StringView name() const noexcept = 0;
 
        virtual AppVersion version() const noexcept = 0;
 
        Platform platform() const noexcept;
 
        const IBackend* operator[](std::type_index type) const;
 
        const IBackend* getBackend(std::type_index type) const;
 
        Enumerable<const IBackend&> getBackends(const BackendType type) const;
 
    protected:
        IBackend* getBackend(std::type_index type);
 
        template <typename TBackend> requires
            meta::implements<TBackend, IBackend>
        TBackend* findBackend() {
            return dynamic_cast<TBackend*>(this->getBackend(typeid(TBackend)));
        }
 
        void startBackend(std::type_index type) const;
 
        void stopBackend(std::type_index type) const;
 
        void stopActiveBackends(BackendType type) const;
 
        IBackend* activeBackend(BackendType type) const;
 
        std::type_index activeBackendType(BackendType type) const;
 
    private:
        void registerStartCallback(std::type_index type, const std::function<bool()>& callback);
 
        void registerStopCallback(std::type_index type, const std::function<void()>& callback);
 
    public:
        mutable Event<const IBackend*> backendStarted; // NOLINT
 
        mutable Event<const IBackend*> backendStopped; // NOLINT
 
        template <typename TBackend> requires
            meta::implements<TBackend, IBackend>
        void onBackendStart(const std::function<bool(TBackend*)>& callback) {
            this->registerStartCallback(typeid(TBackend), [this, callback]() {
                auto backend = this->findBackend<TBackend>();
 
                if (backend == nullptr)
                    throw InvalidArgumentException("callback", "No backend of type {0} has been registered.", typeid(TBackend).name());
 
                if (backend->state() == BackendState::Active)
                    return true;
                else
                    return callback(backend);
            });
        }
 
        template <typename TBackend> requires
            meta::implements<TBackend, IBackend>
        void onBackendStop(const std::function<void(TBackend*)>& callback) {
            this->registerStopCallback(typeid(TBackend), [this, callback]() {
                auto backend = this->findBackend<TBackend>();
 
                if (backend == nullptr)
                    throw InvalidArgumentException("callback", "No backend of type {0} has been registered.", typeid(TBackend).name());
 
                if (backend->state() != BackendState::Inactive)
                    callback(backend);
            });
        }
 
    public:
        template <typename TBackend> requires
            meta::implements<TBackend, IBackend>
        const TBackend* findBackend() const {
            return dynamic_cast<const TBackend*>(this->getBackend(typeid(TBackend)));
        }
 
        template <typename TBackend> requires
            meta::implements<TBackend, IBackend>
        void startBackend() {
            this->startBackend(typeid(TBackend));
        }
 
        template <typename TBackend> requires
            meta::implements<TBackend, IBackend>
        void stopBackend() {
            this->stopBackend(typeid(TBackend));
        }
 
    public:
        mutable Event<EventArgs> startup; // NOLINT
 
        mutable Event<EventArgs> initializing; // NOLINT
 
        mutable Event<EventArgs> shutdown; // NOLINT
 
        virtual void use(UniquePtr<IBackend>&& backend);
 
        void run();
 
    public:
        mutable Event<ResizeEventArgs> resized; // NOLINT
 
        void resize(int width, int height);
 
    public:
        template <typename TApp, typename ...TArgs>
        [[nodiscard]] static AppBuilder build(TArgs&&... _args);
    };
 
    class LITEFX_APPMODEL_API [[nodiscard]] AppBuilder : public Builder<App> {
    public:
        using Builder<App>::Builder;
 
    public:
        void use(UniquePtr<IBackend>&& backend);
 
        template <typename TSink, typename ...TArgs> requires
            std::convertible_to<TSink*, ISink*>
        AppBuilder& logTo(TArgs&&... args) {
            auto sink = makeUnique<TSink>(std::forward<TArgs>(args)...);
            Logger::sinkTo(sink.get());
            return *this;
        }
 
        template <typename TBackend, typename ...TArgs> requires
            meta::implements<TBackend, IBackend>
        AppBuilder& useBackend(TArgs&&... args) {
            this->use(makeUnique<TBackend>(*this->instance(), std::forward<TArgs>(args)...));
            return *this;
        }
    };
 
    template<typename TApp, typename ...TArgs>
    inline AppBuilder App::build(TArgs && ..._args)
    {
        return AppBuilder(makeUnique<TApp>(std::forward<TArgs>(_args)...));
    }
 
}