/*
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 MAINWINDOW_H
#define MAINWINDOW_H

#include "browserdialog.h"
#include "bsafolder.h"
#include "delayedfilewriter.h"
#include "errorcodes.h"
#include "imoinfo.h"
#include "iuserinterface.h"
#include "modinfo.h"
#include "modlistsortproxy.h"
#include "savegameinfo.h"
#include "tutorialcontrol.h"

// Note the commented headers here can be replaced with forward references,
// when I get round to cleaning up main.cpp
struct Executable;
class CategoryFactory;
class LockedDialogBase;
class OrganizerCore;
#include "plugincontainer.h" //class PluginContainer;
class PluginListSortProxy;
namespace BSA {
class Archive;
}
#include "iplugingame.h" //namespace MOBase { class IPluginGame; }
namespace MOBase {
class IPluginModPage;
}
namespace MOBase {
class IPluginTool;
}
namespace MOBase {
class ISaveGame;
}

namespace MOShared {
class DirectoryEntry;
}

#include <QByteArray>
#include <QDir>
#include <QFileInfo>
#include <QFileSystemWatcher>
#include <QHeaderView>
#include <QList>
#include <QMainWindow>
#include <QObject>
#include <QPersistentModelIndex>
#include <QProcess>
#include <QString>
#include <QStringList>
#include <QTime>
#include <QTimer>
#include <QVariant>
#include <Qt>

class QAction;
class QAbstractItemModel;
class QDateTime;
class QEvent;
class QFile;
class QListWidgetItem;
class QMenu;
class QModelIndex;
class QPoint;
class QProgressBar;
class QProgressDialog;
class QTranslator;
class QTreeWidgetItem;
class QUrl;
class QSettings;
class QWidget;

#ifndef Q_MOC_RUN
#include <boost/signals2.hpp>
#endif

// Sigh - just for HANDLE
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>

#include <functional>
#include <set>
#include <string>
#include <vector>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow, public IUserInterface {
    Q_OBJECT

    friend class OrganizerProxy;

public:
    explicit MainWindow(QSettings& initSettings, OrganizerCore& organizerCore, PluginContainer& pluginContainer,
                        QWidget* parent = 0);
    ~MainWindow();

    void storeSettings(QSettings& settings) override;
    void readSettings();

    virtual ILockedWaitingForProcess* lock() override;
    virtual void unlock() override;

    bool addProfile();
    void updateBSAList(const QStringList& defaultArchives, const QStringList& activeArchives);
    void refreshDataTree();
    void refreshDataTreeKeepExpandedNodes();
    void refreshSaveList();

    void setModListSorting(int index);
    void setESPListSorting(int index);

    void saveArchiveList();

    void registerPluginTool(MOBase::IPluginTool* tool);
    void registerModPage(MOBase::IPluginModPage* modPage);

    void addPrimaryCategoryCandidates(QMenu* primaryCategoryMenu, ModInfo::Ptr info);

    void createStdoutPipe(HANDLE* stdOutRead, HANDLE* stdOutWrite);
    std::string readFromPipe(HANDLE stdOutRead);
    void processLOOTOut(const std::string& lootOut, std::string& errorMessages, QProgressDialog& dialog);

    void updateModInDirectoryStructure(unsigned int index, ModInfo::Ptr modInfo);

    QString getOriginDisplayName(int originID);

    void installTranslator(const QString& name);

    virtual void disconnectPlugins();

    void displayModInformation(ModInfo::Ptr modInfo, unsigned int index, int tab);

    virtual bool closeWindow();
    virtual void setWindowEnabled(bool enabled);

    virtual MOBase::DelayedFileWriterBase& archivesWriter() override { return m_ArchiveListWriter; }

public slots:

    void displayColumnSelection(const QPoint& pos);

    void modorder_changed();
    void refresher_progress(int percent);
    void directory_refreshed();

    void toolPluginInvoke();
    void modPagePluginInvoke();

signals:

    /**
     * @brief emitted after the information dialog has been closed
     */
    void modInfoDisplayed();

    /**
     * @brief emitted when the selected style changes
     */
    void styleChanged(const QString& styleFile);

    void modListDataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight);

protected:
    virtual void showEvent(QShowEvent* event);
    virtual void closeEvent(QCloseEvent* event);
    virtual bool eventFilter(QObject* obj, QEvent* event);
    virtual void resizeEvent(QResizeEvent* event);
    virtual void dragEnterEvent(QDragEnterEvent* event);
    virtual void dropEvent(QDropEvent* event);

private slots:
    void on_actionChange_Game_triggered();

private slots:
    void on_clickBlankButton_clicked();

private:
    void cleanup();

    void actionToToolButton(QAction*& sourceAction);

    void updateToolBar();
    void activateSelectedProfile();

    void setExecutableIndex(int index);

    void startSteam();

    void updateTo(QTreeWidgetItem* subTree, const std::wstring& directorySoFar,
                  const MOShared::DirectoryEntry& directoryEntry, bool conflictsOnly);
    bool refreshProfiles(bool selectProfile = true);
    void refreshExecutablesList();
    void installMod(QString fileName = "");

    QList<MOBase::IOrganizer::FileInfo>
    findFileInfos(const QString& path, const std::function<bool(const MOBase::IOrganizer::FileInfo&)>& filter) const;

    bool modifyExecutablesDialog();
    void displayModInformation(int row, int tab = 0);
    void testExtractBSA(int modIndex);

    void writeDataToFile(QFile& file, const QString& directory, const MOShared::DirectoryEntry& directoryEntry);

    void refreshFilters();

    /**
     * Sets category selections from menu; for multiple mods, this will only apply
     * the changes made in the menu (which is the delta between the current menu selection and the reference mod)
     * @param menu the menu after editing by the user
     * @param modRow index of the mod to edit
     * @param referenceRow row of the reference mod
     */
    void addRemoveCategoriesFromMenu(QMenu* menu, int modRow, int referenceRow);

    /**
     * Sets category selections from menu; for multiple mods, this will completely
     * replace the current set of categories on each selected with those selected in the menu
     * @param menu the menu after editing by the user
     * @param modRow index of the mod to edit
     */
    void replaceCategoriesFromMenu(QMenu* menu, int modRow);

    bool populateMenuCategories(QMenu* menu, int targetID);

    void updateDownloadListDelegate();

    // remove invalid category-references from mods
    void fixCategories();

    void createHelpWidget();

    bool extractProgress(QProgressDialog& extractProgress, int percentage, std::string fileName);

    size_t checkForProblems();

    int getBinaryExecuteInfo(const QFileInfo& targetInfo, QFileInfo& binaryInfo, QString& arguments);
    QTreeWidgetItem* addFilterItem(QTreeWidgetItem* root, const QString& name, int categoryID,
                                   ModListSortProxy::FilterType type);
    void addContentFilters();
    void addCategoryFilters(QTreeWidgetItem* root, const std::set<int>& categoriesUsed, int targetID);

    void setCategoryListVisible(bool visible);

    void displaySaveGameInfo(QListWidgetItem* newItem);

    HANDLE nextChildProcess();

    bool errorReported(QString& logFile);

    void updateESPLock(bool locked);

    static void setupNetworkProxy(bool activate);
    void activateProxy(bool activate);
    void setBrowserGeometry(const QByteArray& geometry);

    bool createBackup(const QString& filePath, const QDateTime& time);
    QString queryRestore(const QString& filePath);

    QMenu* modListContextMenu();

    std::set<QString> enabledArchives();

    void scheduleUpdateButton();

    QDir currentSavesDir() const;

    void startMonitorSaves();
    void stopMonitorSaves();

    void dropLocalFile(const QUrl& url, const QString& outputDir, bool move);

    bool registerWidgetState(const QString& name, QHeaderView* view, const char* oldSettingName = nullptr);

private:
    static const char* PATTERN_BACKUP_GLOB;
    static const char* PATTERN_BACKUP_REGEX;
    static const char* PATTERN_BACKUP_DATE;

private:
    Ui::MainWindow* ui;

    bool m_WasVisible;

    MOBase::TutorialControl m_Tutorial;

    int m_OldProfileIndex;

    std::vector<QString> m_ModNameList; // the mod-list to go with the directory structure
    QProgressBar* m_RefreshProgress;
    bool m_Refreshing;

    QStringList m_DefaultArchives;

    QAbstractItemModel* m_ModListGroupingProxy;
    ModListSortProxy* m_ModListSortProxy;

    PluginListSortProxy* m_PluginListSortProxy;

    int m_OldExecutableIndex;

    int m_ContextRow;
    QPersistentModelIndex m_ContextIdx;
    QTreeWidgetItem* m_ContextItem;
    QAction* m_ContextAction;

    CategoryFactory& m_CategoryFactory;

    int m_ModsToUpdate;

    bool m_LoginAttempted;

    QTimer m_CheckBSATimer;
    QTimer m_SaveMetaTimer;
    QTimer m_UpdateProblemsTimer;

    QTime m_StartTime;
    // SaveGameInfoWidget *m_CurrentSaveView;
    MOBase::ISaveGameInfoWidget* m_CurrentSaveView;

    OrganizerCore& m_OrganizerCore;
    PluginContainer& m_PluginContainer;

    QString m_CurrentLanguage;
    std::vector<QTranslator*> m_Translators;

    BrowserDialog m_IntegratedBrowser;

    QFileSystemWatcher m_SavesWatcher;

    std::vector<QTreeWidgetItem*> m_RemoveWidget;

    QByteArray m_ArchiveListHash;

    bool m_DidUpdateMasterList;

    LockedDialogBase* m_LockDialog{nullptr};
    uint64_t m_LockCount{0};

    bool m_closing{false};

    std::vector<std::pair<QString, QHeaderView*>> m_PersistedGeometry;

    MOBase::DelayedFileWriter m_ArchiveListWriter;

    enum class ShortcutType { Toolbar, Desktop, StartMenu };

    void addWindowsLink(ShortcutType const);

    Executable const& getSelectedExecutable() const;
    Executable& getSelectedExecutable();

private slots:

    void updateWindowTitle(const QString& accountName, bool premium);

    void showMessage(const QString& message);
    void showError(const QString& message);

    // main window actions
    void helpTriggered();
    void issueTriggered();
    void wikiTriggered();
    void tutorialTriggered();
    void extractBSATriggered();

    // modlist context menu
    void installMod_clicked();
    void createEmptyMod_clicked();
    void restoreBackup_clicked();
    void renameMod_clicked();
    void removeMod_clicked();
    void reinstallMod_clicked();
    void endorse_clicked();
    void dontendorse_clicked();
    void unendorse_clicked();
    void ignoreMissingData_clicked();
    void visitOnNexus_clicked();
    void visitWebPage_clicked();
    void openExplorer_clicked();
    void information_clicked();
    // savegame context menu
    void deleteSavegame_clicked();
    void fixMods_clicked(SaveGameInfo::MissingAssets const& missingAssets);
    // data-tree context menu
    void writeDataToFile();
    void openDataFile();
    void addAsExecutable();
    void previewDataFile();
    void hideFile();
    void unhideFile();

    void linkToolbar();
    void linkDesktop();
    void linkMenu();

    void languageChange(const QString& newLanguage);
    void saveSelectionChanged(QListWidgetItem* newItem);

    void windowTutorialFinished(const QString& windowName);

    BSA::EErrorCode extractBSA(BSA::Archive& archive, BSA::Folder::Ptr folder, const QString& destination,
                               QProgressDialog& extractProgress);

    void createModFromOverwrite();
    void clearOverwrite();

    void procError(QProcess::ProcessError error);
    void procFinished(int exitCode, QProcess::ExitStatus exitStatus);

    // nexus related
    void checkModsForUpdates();
    void nexusLinkActivated(const QString& link);

    void loginFailed(const QString& message);

    void linkClicked(const QString& url);

    void updateAvailable();

    void motdReceived(const QString& motd);
    void notEndorsedYet();

    void originModified(int originID);

    void addRemoveCategories_MenuHandler();
    void replaceCategories_MenuHandler();

    void addPrimaryCategoryCandidates();

    void modDetailsUpdated(bool success);

    void modInstalled(const QString& modName);

    void nxmUpdatesAvailable(const std::vector<int>& modIDs, QVariant userData, QVariant resultData, int requestID);
    void nxmEndorsementToggled(int, QVariant, QVariant resultData, int);
    void nxmDownloadURLs(int modID, int fileID, QVariant userData, QVariant resultData, int requestID);
    void nxmRequestFailed(int modID, int fileID, QVariant userData, int requestID, const QString& errorString);

    void editCategories();
    void deselectFilters();

    void displayModInformation(const QString& modName, int tab);
    void modOpenNext();
    void modOpenPrev();

    void modRenamed(const QString& oldName, const QString& newName);
    void modRemoved(const QString& fileName);

    void hideSaveGameInfo();

    void hookUpWindowTutorials();

    void resumeDownload(int downloadIndex);
    void endorseMod(ModInfo::Ptr mod);
    void cancelModListEditor();

    void lockESPIndex();
    void unlockESPIndex();

    void enableVisibleMods();
    void disableVisibleMods();
    void exportModListCSV();
    void openInstanceFolder();
    void openDownloadsFolder();
    void openProfileFolder();
    void openGameFolder();
    void openMyGamesFolder();
    void startExeAction();

    void checkBSAList();

    void updateProblemsButton();

    void saveModMetas();

    void updateStyle(const QString& style);

    void modlistChanged(const QModelIndex& index, int role);
    void fileMoved(const QString& filePath, const QString& oldOriginName, const QString& newOriginName);

    void modFilterActive(bool active);
    void espFilterChanged(const QString& filter);
    void downloadFilterChanged(const QString& filter);

    void expandModList(const QModelIndex& index);

    /**
     * @brief resize columns in mod list and plugin list to content
     */
    void resizeLists(bool modListCustom, bool pluginListCustom);

    /**
     * @brief allow columns in mod list and plugin list to be resized
     */
    void allowListResize();

    void toolBar_customContextMenuRequested(const QPoint& point);
    void removeFromToolbar();
    void overwriteClosed(int);

    void changeVersioningScheme();
    void ignoreUpdate();
    void unignoreUpdate();

    void refreshSavesIfOpen();
    void expandDataTreeItem(QTreeWidgetItem* item);
    void about();
    void delayedRemove();

    void modlistSelectionChanged(const QModelIndex& current, const QModelIndex& previous);
    void modListSortIndicatorChanged(int column, Qt::SortOrder order);

    void modlistSelectionsChanged(const QItemSelection& current);
    void esplistSelectionsChanged(const QItemSelection& current);

private slots: // ui slots
    // actions
    void on_actionAdd_Profile_triggered();
    void on_actionInstallMod_triggered();
    void on_actionModify_Executables_triggered();
    void on_actionNexus_triggered();
    void on_actionProblems_triggered();
    void on_actionSettings_triggered();
    void on_actionUpdate_triggered();
    void on_actionEndorseMO_triggered();

    void on_clearFiltersButton_clicked();
    void on_btnRefreshData_clicked();
    void on_categoriesList_customContextMenuRequested(const QPoint& pos);
    void on_conflictsCheckBox_toggled(bool checked);
    void on_dataTree_customContextMenuRequested(const QPoint& pos);
    void on_executablesListBox_currentIndexChanged(int index);
    void on_modList_customContextMenuRequested(const QPoint& pos);
    void on_modList_doubleClicked(const QModelIndex& index);
    void on_profileBox_currentIndexChanged(int index);
    void on_savegameList_customContextMenuRequested(const QPoint& pos);
    void on_startButton_clicked();
    void on_tabWidget_currentChanged(int index);

    void on_espList_customContextMenuRequested(const QPoint& pos);
    void on_displayCategoriesBtn_toggled(bool checked);
    void on_groupCombo_currentIndexChanged(int index);
    void on_categoriesList_itemSelectionChanged();
    void on_linkButton_pressed();
    void on_showHiddenBox_toggled(bool checked);
    void on_bsaList_itemChanged(QTreeWidgetItem* item, int column);
    void on_bossButton_clicked();

    void on_saveButton_clicked();
    void on_restoreButton_clicked();
    void on_restoreModsButton_clicked();
    void on_saveModsButton_clicked();
    void on_actionCopy_Log_to_Clipboard_triggered();
    void on_categoriesAndBtn_toggled(bool checked);
    void on_categoriesOrBtn_toggled(bool checked);
    void on_managedArchiveLabel_linkHovered(const QString& link);
};

#endif // MAINWINDOW_H