Showcase.hpp

#pragma once

#include <type_traits>
#include <Radiant/Singleton.hpp>

#include <QString>

#include <MultiWidgets/Widget.hpp>

#include "Export.hpp"

#include "CachedGraph.hpp"
#include "Graph.hpp"
#include "GraphGenerators.hpp"
#include "ShowcaseTypes.hpp"
#include "Configuration.hpp"
#include "UserInterface.hpp"
#include "UIComponent.hpp"
#include "ServiceProvider.hpp"
#include "RemoteControl.hpp"
#include "Package.hpp"

#include <boost/expected/expected.hpp>

namespace WebBrowserCef
{
  class BrowserSessionManager;
}
namespace Luminous
{
  class PDFManager;
}

namespace Showcase
{
  class ShowcaseLicense;
  class WidgetInstance;
  class ScheduleManager;
  class AppSchedule;
  INTRUSIVE_PTR_FORWARD_DECL(, ErrorPageWidget);

  enum class ShowcaseExitCodes
  {
    NORMAL_EXIT = 0,
    NO_LICENSE = 50
  };

  class SHOWCASE_API Showcase
  {
    DECLARE_SINGLETON(Showcase);
  public:
    ~Showcase();

    void tearDown();

    GraphPtr graph();

    UserInterfacePtr ui();

    ServiceProviderPtr services();

    RemoteControlPtr remoteControl();

    std::shared_ptr<ScheduleManager> scheduleManager();

    void init();

    PackagePtr packageOfComponent(const QString& componentName);

    void addCSSFiles(const std::vector<QString>& filePaths);

    void addCSSFile(const QString& filePath);

    void removeCSSFiles(const std::vector<QString>& filePaths);

    void removeCSSFile(const QString& filePath);

    static void setAssetsPath(const QString & path);

    void run();

    bool hasRunConfiguration() const;

    RunConfigurationPtr runConfiguration();

    void reloadRunConfiguration(bool showLoadingOverlay = false);

    void runConfigurationChanged(int id);

    void reloadSchedule();
    void scheduleChanged(int id);

    void updateRemoteConnectionState(bool hasConnection);
    void updateRunConfigurationState(bool hasRunConf);

    // Want to add overloads of registering factories to Showcase-class
    // also, so that we do not need to have multiple implementations
    // of FactoryRegistrant
    FactoryKey<GraphGenerator>
    registerFactory(const QString& name, GraphGenFactoryPtr factory);

    FactoryKey<PropertyGenerator>
    registerFactory(const QString& name, PropGenFactoryPtr factory);

    FactoryKey<UIComponent>
    registerFactory(const QString &name, UIComponentFactoryPtr factory);

    FactoryKey<ServiceComponent>
    registerFactory(const QString &name, ServiceComponentFactoryPtr factory);

    // Same for unregister-functions
    bool unregisterFactory(FactoryKey<GraphGenerator> key);
    bool unregisterFactory(FactoryKey<PropertyGenerator> key);
    bool unregisterFactory(FactoryKey<UIComponent> key);
    bool unregisterFactory(FactoryKey<ServiceComponent> key);

    static std::weak_ptr<Showcase> weakInstance();

    static const QString& version();

    static QByteArray showcaseGitHash();

    void registerWidgetInstance(Valuable::Node::Uuid widgetId, std::weak_ptr<WidgetInstance> instance);
    void unregisterWidgetInstance(Valuable::Node::Uuid widgetId);
    std::shared_ptr<WidgetInstance> widgetInstance(Valuable::Node::Uuid widgetId);

    void showErrorScreen(const QByteArray & css = "", const QString & error = "");

    void removeErrorScreen();

    QString editorAddress(bool hideDefaultPort = true) const;

    static boost::expected<QString, QString> showcaseRoot();

    void minimize();

    void resume();

    static QString localDataDirectory();

    static QString localCacheDirectory();

    static QString logDirectory();

    static void errorMessage(const QString& msg);

    QString remoteControlServer() const;

    std::shared_ptr<folly::Executor> graphExecutor() { return m_graphExecutor; }
    std::shared_ptr<folly::Executor> configExecutor() { return m_configExecutor; }

    bool verifyGraphExecutorCallingThread() const;

    void addThemeComponent(const QString & component);

    const QStringList & themeComponents() const;

    void setShowExit(bool show);

  private:
    void reloadServices();
    void reloadTheme();
    void reloadUi();
    void reloadAppSchedule();
    void showExpiredLicenseWarning(const ShowcaseLicense& license);

    void clear(bool removeError = true);

    bool checkStatus();
    bool checkRemoteControlConnection();
    bool checkDatabaseConnection();
    bool checkAssets();
    bool checkRunConfiguration();

    void loadPackagesFrom(const QStringList& paths);
    void parsePackagesFrom(const QString& path, std::vector<PackagePtr>& packages);

    Showcase();

    GraphPtr m_graph;
    UserInterfacePtr m_ui;
    ServiceProviderPtr m_services;
    RemoteControlPtr m_remoteControl;
    std::shared_ptr<ScheduleManager> m_scheduleManager;
    std::shared_ptr<AppSchedule> m_appSchedule;
    std::shared_ptr<WebBrowserCef::BrowserSessionManager> m_browserSessions;
    std::shared_ptr<Luminous::PDFManager> m_pdfManager;

    std::map<QString, PackagePtr> m_loadedPackages;
    QStringList m_themeComponents;

    std::shared_ptr<RunConfiguration> m_runConf;
    std::shared_ptr<ScheduleConfig> m_schedule;

    std::map<QString, size_t> m_loadedCSSFiles;

    std::mutex m_widgetInstancesMutex;
    std::map<Valuable::Node::Uuid, std::weak_ptr<WidgetInstance>> m_widgetInstances;

    std::mutex m_stateMutex;
    bool m_hasRemoteConnection;
    bool m_hasRunConf;

    bool m_showExit;

    ErrorPageWidgetPtr m_errorScreen;

    std::shared_ptr<Radiant::BGThread> m_graphThreadPool;
    std::shared_ptr<folly::Executor> m_graphExecutor;

    std::shared_ptr<Radiant::BGThread> m_configThreadPool;
    std::shared_ptr<folly::Executor> m_configExecutor;

    template <typename Factory> friend class FactoryRegistrant;
  };
  typedef std::shared_ptr<Showcase> ShowcasePtr;


  // -------------------------------------------------------------------


  template <typename T, typename Predicate = void>
  struct APIClass;

  template <typename T>
  struct APIClass<T, typename std::enable_if<std::is_base_of<GraphGenerator, T>::value>::type>
  { typedef GraphGenerator type; };

  template <typename T>
  struct APIClass<T, typename std::enable_if<std::is_base_of<PropertyGenerator, T>::value>::type>
  { typedef PropertyGenerator type; };

  template <typename T>
  struct APIClass<T, typename std::enable_if<std::is_base_of<UIComponent, T>::value>::type>
  { typedef UIComponent type; };

  template <typename T>
  struct APIClass<T, typename std::enable_if<std::is_base_of<ServiceComponent, T>::value>::type>
  { typedef ServiceComponent type; };

  // -------------------------------------------------------------------

  template <typename ComponentType>
  class FactoryRegistrant
  {
  public:
    typedef typename APIClass<ComponentType>::type Base;
    typedef typename ShowcaseFactory<Base>::CreateFunc CreateFunc;

    FactoryRegistrant(const QString& name, CreateFunc f);
    ~FactoryRegistrant();

  private:
    FactoryKey<Base> m_key;
    QString m_name;
  };

  // ------------------------------------------------------------------


  template <typename ComponentType>
  FactoryRegistrant<ComponentType>::FactoryRegistrant(
      const QString &name, CreateFunc f)
    : m_name(name)
  {
    ShowcaseFactoryPtr<Base> factory =
        std::make_shared<ShowcaseFactory<Base>>(typeid(ComponentType), f);

    auto weak = Showcase::weakInstance();
    auto showcase = weak.lock();
    if(!showcase)
      return;
    auto package = showcase->packageOfComponent(name);

    if(!package) {
      Showcase::errorMessage(QString("Couldn't find package for component %1.").arg(name.toUtf8().data()));
      assert(package);
    }

    ComponentDefinitionPtr component = package->component(name);
    assert(component);
    component->initComponent();

    const Schema& schema = component->schema();
    factory->setSchema(schema);

    m_key = showcase->registerFactory(name, factory);
  }

  template <typename ComponentType>
  FactoryRegistrant<ComponentType>::~FactoryRegistrant()
  {
    std::weak_ptr<Showcase> weak = Showcase::weakInstance();
    std::shared_ptr<Showcase> s = weak.lock();

    if(s)
      s->unregisterFactory(m_key);
  }

}

#define _MW_PLUGIN_CONCAT(x,y) x ## y
#define MW_PLUGIN_CONCAT(x,y) _MW_PLUGIN_CONCAT(x,y)

#define SHOWCASE_COMPONENT(name, type) \
namespace {\
Showcase::FactoryRegistrant<type> MW_PLUGIN_CONCAT(component, __LINE__) \
(name, std::make_shared<type> ); \
}