/*
Copyright (C) 2012 Sebastian Herbord. All rights reserved.

This file is part of Mod Organizer.

Mod Organizer is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Mod Organizer is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef WORKAROUNDS_H
#define WORKAROUNDS_H

#include "loadmechanism.h"

#include <QList>
#include <QMap>
#include <QObject>
#include <QSet>
#include <QSettings>
#include <QString>
#include <QVariant>

#include <QtGlobal> //for uint

#include <map>
#include <vector>

class QCheckBox;
class QComboBox;
class QLineEdit;
class QSpinBox;
class QListWidget;
class QWidget;
class QLabel;

struct ServerInfo;

namespace MOBase {
  class IPlugin;
  class IPluginGame;
}

class SettingsDialog;

/**
 * manages the settings for Mod Organizer. The settings are not cached
 * inside the class but read/written directly from/to disc
 **/
class Settings : public QObject
{

  Q_OBJECT

public:

  /**
   * @brief constructor
   **/
  Settings(const QSettings &settingsSource);

  virtual ~Settings();

  static Settings &instance();

  /**
   * unregister all plugins from settings
   */
  void clearPlugins();

  /**
   * @brief register plugin to be configurable
   * @param plugin the plugin to register
   * @return true if the plugin may be registered, false if it is blacklisted
   */
  void registerPlugin(MOBase::IPlugin *plugin);

  /**
   * displays a SettingsDialog that allows the user to change settings. If the
   * user accepts the changes, the settings are immediately written
   **/
  void query(QWidget *parent);

  /**
   * set up the settings for the specified plugins
   **/
  void addPluginSettings(const std::vector<MOBase::IPlugin*> &plugins);

  /**
   * @return true if the user wants unchecked plugins (esp, esm) should be hidden from
   *         the virtual dat adirectory
   **/
  bool hideUncheckedPlugins() const;

  /**
   * @return true if files of the core game are forced-enabled so the user can't accidentally disable them
   */
  bool forceEnableCoreFiles() const;

  /**
   * @brief register download speed
   * @param url complete download url
   * @param bytesPerSecond download size in bytes per second
   */
  void setDownloadSpeed(const QString &serverName, int bytesPerSecond);

  /**
   * the steam appid is assigned by the steam platform to each product sold there.
   * The appid may differ between different versions of a game so it may be impossible
   * for Mod Organizer to automatically recognize it, though usually it does
   * @return the steam appid for the game
   **/
  QString getSteamAppID() const;

  /**
   * retrieves the base directory under which the other directories usually
   * reside
   */
  QString getBaseDirectory() const;

  /**
   * retrieve the directory where downloads are stored (with native separators)
   **/
  QString getDownloadDirectory(bool resolve = true) const;

  /**
   * retrieve a sorted list of preferred servers
   */
  std::map<QString, int> getPreferredServers();

  /**
   * retrieve the directory where mods are stored (with native separators)
   **/
  QString getModDirectory(bool resolve = true) const;

  /**
   * returns the version of nmm to impersonate when connecting to nexus
   **/
  QString getNMMVersion() const;

  /**
   * retrieve the directory where the web cache is stored (with native separators)
   **/
  QString getCacheDirectory(bool resolve = true) const;

  /**
   * retrieve the directory where profiles stored (with native separators)
   **/
  QString getProfileDirectory(bool resolve = true) const;

  /**
   * retrieve the directory were new files are stored that can't be assigned
   * to a mod (with native separators)
   */
  QString getOverwriteDirectory(bool resolve = true) const;

  /**
   * @return true if the user has set up automatic login to nexus
   **/
  bool automaticLoginEnabled() const;

  /**
   * @brief retrieve the login information for nexus
   *
   * @param username (out) receives the user name for nexus
   * @param password (out) received the password for nexus
   * @return true if automatic login is active, false otherwise
   **/
  bool getNexusLogin(QString &username, QString &password) const;

  /**
   * @brief retrieve the login information for steam
   *
   * @param username (out) receives the user name for nexus
   * @param password (out) received the password for nexus
   * @return true if a username has been specified, false otherwise
   **/
  bool getSteamLogin(QString &username, QString &password) const;

  /**
   * @return true if the user disabled internet features
   */
  bool offlineMode() const;

  /**
   * @return true if the user chose compact downloads
   */
  bool compactDownloads() const;

  /**
   * @return true if the user chose meta downloads
   */
  bool metaDownloads() const;

  /**
   * @return the configured log level
   */
  int logLevel() const;

  /**
  * @return the configured crash dumps type
  */
  int crashDumpsType() const;

  /**
  * @return the configured crash dumps max
  */
  int crashDumpsMax() const;

  /**
   * @brief set the nexus login information
   *
   * @param username username
   * @param password password
   */
  void setNexusLogin(QString username, QString password);

  /**
   * @brief set the steam login information
   *
   * @param username username
   * @param password password
   */
  void setSteamLogin(QString username, QString password);

  /**
   * @return the load mechanism to be used
   **/
  LoadMechanism::EMechanism getLoadMechanism() const;

  /**
   * @brief activate the load mechanism selected by the user
   **/
  void setupLoadMechanism();

  /**
   * @return true if the user configured the use of a network proxy
   */
  bool useProxy() const;

  /**
   * @return true if the user wants to see non-official plugins installed outside MO in his mod list
   */
  bool displayForeign() const;

  /**
   * @brief sets the new motd hash
   **/
  void setMotDHash(uint hash);

  /**
   * @return hash of the last displayed message of the day
   **/
  uint getMotDHash() const;

  /**
   * @brief allows direct access to the wrapped QSettings object
   * @return the wrapped QSettings object
   */
  QSettings &directInterface() { return m_Settings; }

  /**
   * @brief retrieve a setting for one of the installed plugins
   * @param pluginName name of the plugin
   * @param key name of the setting to retrieve
   * @return the requested value as a QVariant
   * @note an invalid QVariant is returned if the the plugin/setting is not declared
   */
  QVariant pluginSetting(const QString &pluginName, const QString &key) const;

  /**
   * @brief set a setting for one of the installed mods
   * @param pluginName name of the plugin
   * @param key name of the setting to change
   * @param value the new value to set
   * @throw an exception is thrown if pluginName is invalid
   */
  void setPluginSetting(const QString &pluginName, const QString &key, const QVariant &value);

  /**
   * @brief retrieve a persistent value for a plugin
   * @param pluginName name of the plugin to store data for
   * @param key id of the value to retrieve
   * @param def default value to return if the value is not set
   * @return the requested value
   */
  QVariant pluginPersistent(const QString &pluginName, const QString &key, const QVariant &def) const;

  /**
   * @brief set a persistent value for a plugin
   * @param pluginName name of the plugin to store data for
   * @param key id of the value to retrieve
   * @param value value to set
   * @throw an exception is thrown if pluginName is invalid
   */
  void setPluginPersistent(const QString &pluginName, const QString &key, const QVariant &value, bool sync);

  /**
   * @return short code of the configured language (corresponding to the translation files)
   */
  QString language();

  /**
   * @brief updates the list of known servers
   * @param list of servers from a recent query
   */
  void updateServers(const QList<ServerInfo> &servers);

  /**
   * @brief add a plugin that is to be blacklisted
   * @param fileName name of the plugin to blacklist
   */
  void addBlacklistPlugin(const QString &fileName);

  /**
   * @brief test if a plugin is blacklisted and shouldn't be loaded
   * @param fileName name of the plugin
   * @return true if the file is blacklisted
   */
  bool pluginBlacklisted(const QString &fileName) const;

  /**
   * @return all loaded MO plugins
   */
  std::vector<MOBase::IPlugin*> plugins() const { return m_Plugins; }

  bool usePrereleases() const;

  /**
   * @brief register MO as the handler for nxm links
   * @param force set to true to enforce the registration dialog to show up,
   *              even if the user said earlier not to
   */
  void registerAsNXMHandler(bool force);

public slots:

  void managedGameChanged(MOBase::IPluginGame const *gamePlugin);

private:

  static QString obfuscate(const QString &password);
  static QString deObfuscate(const QString &password);

  void addLanguages(QComboBox *languageBox);
  void addStyles(QComboBox *styleBox);
  void readPluginBlacklist();
  void writePluginBlacklist();
  QString getConfigurablePath(const QString &key, const QString &def, bool resolve) const;

  class SettingsTab
  {
  public:
    SettingsTab(Settings *m_parent, SettingsDialog &m_dialog);
    virtual ~SettingsTab();

    virtual void update() = 0;

  protected:
    Settings *m_parent;
    QSettings &m_Settings;
    SettingsDialog &m_dialog;

  };

  /** Display/store the configuration in the 'general' tab of the settings dialogue */
  class GeneralTab : public SettingsTab
  {
  public:
    GeneralTab(Settings *m_parent, SettingsDialog &m_dialog);

    void update();

  private:
    QComboBox *m_languageBox;
    QComboBox *m_styleBox;
    QCheckBox *m_compactBox;
    QCheckBox *m_showMetaBox;
    QCheckBox *m_usePrereleaseBox;
  };

  class PathsTab : public SettingsTab
  {
  public:
    PathsTab(Settings *parent, SettingsDialog &dialog);

    void update();

  private:
    QLineEdit *m_baseDirEdit;
    QLineEdit *m_downloadDirEdit;
    QLineEdit *m_modDirEdit;
    QLineEdit *m_cacheDirEdit;
    QLineEdit *m_profilesDirEdit;
    QLineEdit *m_overwriteDirEdit;
  };

  class DiagnosticsTab : public SettingsTab
  {
  public:
    DiagnosticsTab(Settings *parent, SettingsDialog &dialog);

    void update();

  private:
    QComboBox *m_logLevelBox;
    QComboBox *m_dumpsTypeBox;
    QSpinBox *m_dumpsMaxEdit;
    QLabel *m_diagnosticsExplainedLabel;
  };

  /** Display/store the configuration in the 'nexus' tab of the settings dialogue */
  class NexusTab : public SettingsTab
  {
  public:
    NexusTab(Settings *m_parent, SettingsDialog &m_dialog);

    void update();

  private:
    QCheckBox *m_loginCheckBox;
    QLineEdit *m_usernameEdit;
    QLineEdit *m_passwordEdit;
    QCheckBox *m_offlineBox;
    QCheckBox *m_proxyBox;
    QListWidget *m_knownServersList;
    QListWidget *m_preferredServersList;
  };

  /** Display/store the configuration in the 'steam' tab of the settings dialogue */
  class SteamTab : public SettingsTab
  {
  public:
    SteamTab(Settings *m_parent, SettingsDialog &m_dialog);

    void update();

  private:
    QLineEdit *m_steamUserEdit;
    QLineEdit *m_steamPassEdit;
  };

  /** Display/store the configuration in the 'plugins' tab of the settings dialogue */
  class PluginsTab : public SettingsTab
  {
  public:
    PluginsTab(Settings *m_parent, SettingsDialog &m_dialog);

    void update();

  private:
    QListWidget *m_pluginsList;
    QListWidget *m_pluginBlacklistList;
  };

  /** Display/store the configuration in the 'workarounds' tab of the settings dialogue */
  class WorkaroundsTab : public SettingsTab
  {
  public:
    WorkaroundsTab(Settings *m_parent, SettingsDialog &m_dialog);

    void update();

  private:
    QLineEdit *m_appIDEdit;
    QComboBox *m_mechanismBox;
    QLineEdit *m_nmmVersionEdit;
    QCheckBox *m_hideUncheckedBox;
    QCheckBox *m_forceEnableBox;
    QCheckBox *m_displayForeignBox;
  };

private slots:

  void resetDialogs();

signals:

  void languageChanged(const QString &newLanguage);
  void styleChanged(const QString &newStyle);

private:

  static Settings *s_Instance;

  MOBase::IPluginGame const *m_GamePlugin;

  QSettings m_Settings;

  LoadMechanism m_LoadMechanism;

  std::vector<MOBase::IPlugin*> m_Plugins;

  QMap<QString, QMap<QString, QVariant>> m_PluginSettings;
  QMap<QString, QMap<QString, QVariant>> m_PluginDescriptions;

  QSet<QString> m_PluginBlacklist;

};

#endif // WORKAROUNDS_H