SettingsManager.h

/*
 *  Copyright (C) 2013-2018 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */

#pragma once

#include "ISettingCallback.h"
#include "ISettingControlCreator.h"
#include "ISettingCreator.h"
#include "ISettingsHandler.h"
#include "ISettingsValueSerializer.h"
#include "Setting.h"
#include "SettingConditions.h"
#include "SettingDefinitions.h"
#include "SettingDependency.h"
#include "threads/SharedSection.h"
#include "utils/logtypes.h"

#include <map>
#include <set>
#include <unordered_set>
#include <vector>

class CSettingCategory;
class CSettingGroup;
class CSettingSection;
class CSettingUpdate;

class TiXmlElement;
class TiXmlNode;

class CSettingsManager : public ISettingCreator,
                         public ISettingControlCreator,
                         private ISettingCallback,
                         private ISettingsHandler
{
public:
  CSettingsManager();
  ~CSettingsManager() override;

  static const uint32_t Version;
  static const uint32_t MinimumSupportedVersion;

  // implementation of ISettingCreator
  std::shared_ptr<CSetting> CreateSetting(const std::string &settingType, const std::string &settingId, CSettingsManager *settingsManager = nullptr) const override;

  // implementation of ISettingControlCreator
  std::shared_ptr<ISettingControl> CreateControl(const std::string &controlType) const override;

  uint32_t GetVersion() const { return Version; }
  uint32_t GetMinimumSupportedVersion() const { return MinimumSupportedVersion; }

  uint32_t ParseVersion(const TiXmlElement* root) const;

  bool Initialize(const TiXmlElement *root);
  bool Load(const TiXmlElement *root, bool &updated, bool triggerEvents = true, std::map<std::string, std::shared_ptr<CSetting>> *loadedSettings = nullptr);
  bool Save(const ISettingsValueSerializer* serializer, std::string& serializedValues) const;
  void Unload();
  void Clear();

  bool LoadSetting(const TiXmlNode *node, const std::string &settingId);

  bool LoadSetting(const TiXmlNode *node, const std::string &settingId, bool &updated);

  void SetInitialized();
  bool IsInitialized() const { return m_initialized; }
  void SetLoaded() { m_loaded = true; }
  bool IsLoaded() const { return m_loaded; }

  void AddSection(const std::shared_ptr<CSettingSection>& section);

  bool AddSetting(const std::shared_ptr<CSetting>& setting,
                  const std::shared_ptr<CSettingSection>& section,
                  const std::shared_ptr<CSettingCategory>& category,
                  const std::shared_ptr<CSettingGroup>& group);

  void RegisterCallback(ISettingCallback *callback, const std::set<std::string> &settingList);
  void UnregisterCallback(ISettingCallback *callback);

  void RegisterSettingType(const std::string &settingType, ISettingCreator *settingCreator);

  void RegisterSettingControl(const std::string &controlType, ISettingControlCreator *settingControlCreator);

  void RegisterSettingsHandler(ISettingsHandler *settingsHandler, bool bFront = false);
  void UnregisterSettingsHandler(ISettingsHandler *settingsHandler);

  void RegisterSettingOptionsFiller(const std::string &identifier, IntegerSettingOptionsFiller optionsFiller);
  void RegisterSettingOptionsFiller(const std::string &identifier, StringSettingOptionsFiller optionsFiller);
  void UnregisterSettingOptionsFiller(const std::string &identifier);
  void* GetSettingOptionsFiller(const std::shared_ptr<const CSetting>& setting);

  bool HasSettings() const;

  std::shared_ptr<CSetting> GetSetting(const std::string &id) const;
  std::vector<std::shared_ptr<CSettingSection>> GetSections() const;
  std::shared_ptr<CSettingSection> GetSection(std::string section) const;
  SettingDependencyMap GetDependencies(const std::string &id) const;
  SettingDependencyMap GetDependencies(const std::shared_ptr<const CSetting>& setting) const;

  bool GetBool(const std::string &id) const;
  int GetInt(const std::string &id) const;
  double GetNumber(const std::string &id) const;
  std::string GetString(const std::string &id) const;
  std::vector< std::shared_ptr<CSetting> > GetList(const std::string &id) const;

  bool SetBool(const std::string &id, bool value);
  bool ToggleBool(const std::string &id);
  bool SetInt(const std::string &id, int value);
  bool SetNumber(const std::string &id, double value);
  bool SetString(const std::string &id, const std::string &value);
  bool SetList(const std::string &id, const std::vector< std::shared_ptr<CSetting> > &value);

  bool SetDefault(const std::string &id);
  void SetDefaults();

  const CSettingConditionsManager& GetConditions() const { return m_conditions; }
  void AddCondition(const std::string &condition);
  void AddDynamicCondition(const std::string &identifier, SettingConditionCheck condition, void *data = nullptr);

  void RemoveDynamicCondition(const std::string &identifier);

private:
  // implementation of ISettingCallback
  bool OnSettingChanging(const std::shared_ptr<const CSetting>& setting) override;
  void OnSettingChanged(const std::shared_ptr<const CSetting>& setting) override;
  void OnSettingAction(const std::shared_ptr<const CSetting>& setting) override;
  bool OnSettingUpdate(const std::shared_ptr<CSetting>& setting,
                       const char* oldSettingId,
                       const TiXmlNode* oldSettingNode) override;
  void OnSettingPropertyChanged(const std::shared_ptr<const CSetting>& setting,
                                const char* propertyName) override;

  // implementation of ISettingsHandler
  bool OnSettingsLoading() override;
  void OnSettingsLoaded() override;
  void OnSettingsUnloaded() override;
  bool OnSettingsSaving() const override;
  void OnSettingsSaved() const override;
  void OnSettingsCleared() override;

  bool Serialize(TiXmlNode *parent) const;
  bool Deserialize(const TiXmlNode *node, bool &updated, std::map<std::string, std::shared_ptr<CSetting>> *loadedSettings = nullptr);

  bool LoadSetting(const TiXmlNode* node, const std::shared_ptr<CSetting>& setting, bool& updated);
  bool UpdateSetting(const TiXmlNode* node,
                     const std::shared_ptr<CSetting>& setting,
                     const CSettingUpdate& update);
  void UpdateSettingByDependency(const std::string &settingId, const CSettingDependency &dependency);
  void UpdateSettingByDependency(const std::string &settingId, SettingDependencyType dependencyType);

  void AddSetting(const std::shared_ptr<CSetting>& setting);

  void ResolveReferenceSettings(const std::shared_ptr<CSettingSection>& section);
  void CleanupIncompleteSettings();

  enum class SettingOptionsFillerType {
    Unknown = 0,
    Integer,
    String
  };

  void RegisterSettingOptionsFiller(const std::string &identifier, void *filler, SettingOptionsFillerType type);

  using CallbackSet = std::set<ISettingCallback *>;
  struct Setting {
    std::shared_ptr<CSetting> setting;
    SettingDependencyMap dependencies;
    std::set<std::string> children;
    CallbackSet callbacks;
    std::unordered_set<std::string> references;
  };

  using SettingMap = std::map<std::string, Setting>;

  void RefreshVisibilityAndEnableStatus(const std::shared_ptr<const CSetting>& setting);

  void ResolveSettingDependencies(const std::shared_ptr<CSetting>& setting);
  void ResolveSettingDependencies(const Setting& setting);

  SettingMap::const_iterator FindSetting(std::string settingId) const;
  SettingMap::iterator FindSetting(std::string settingId);
  std::pair<SettingMap::iterator, bool> InsertSetting(std::string settingId, const Setting& setting);

  bool m_initialized = false;
  bool m_loaded = false;

  SettingMap m_settings;
  using SettingSectionMap = std::map<std::string, std::shared_ptr<CSettingSection>>;
  SettingSectionMap m_sections;

  using SettingCreatorMap = std::map<std::string, ISettingCreator*>;
  SettingCreatorMap m_settingCreators;

  using SettingControlCreatorMap = std::map<std::string, ISettingControlCreator*>;
  SettingControlCreatorMap m_settingControlCreators;

  using SettingsHandlers = std::vector<ISettingsHandler*>;
  SettingsHandlers m_settingsHandlers;

  CSettingConditionsManager m_conditions;

  struct SettingOptionsFiller {
    void *filler;
    SettingOptionsFillerType type;
  };
  using SettingOptionsFillerMap = std::map<std::string, SettingOptionsFiller>;
  SettingOptionsFillerMap m_optionsFillers;

  mutable CSharedSection m_critical;
  mutable CSharedSection m_settingsCritical;

  Logger m_logger;
};