#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QDebug>
#include <QItemSelectionModel>
#include <QLabel>
#include <QMainWindow>
#include <QSortFilterProxyModel>
#include <QSystemTrayIcon>
#include <QTableWidget>
#include <QTextEdit>
#include <QTimer>
#include <QTimerEvent>
#include <QAction>
#include <QSystemTrayIcon>
#include <QAtomicInteger>

#include "RvcSettings.h"
#include "QRvcItemModel.hpp"
#include "QtMessageInfo.h"

#include "sysinfowidget.h"
#include "cpuwidget.h"
#include "performwidget.h"
#include "memorywidget.h"
#include "OperaThread.hpp"
#include "mlabel.h"
#include "floatwidget/widget.h"

#define APP_EXIT_CODE_QUIT 0
#define APP_EXIT_CODE_RESTART_CURR 1
#define APP_EXIT_CODE_RESTART_ACTIVE 2

QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE


class MainWindow;

class RichTimer : public QObject
{

    Q_OBJECT
public:
    explicit RichTimer(MainWindow *parent, QString entityName)
        :QObject((QObject*)parent)
        ,mWin(parent)
        ,mEntityName(entityName)
        ,mTimes(0)
    {
        mTimerID = startTimer(300);
    }
    virtual void timerEvent(QTimerEvent *event)
    {
        if(event->timerId() == mTimerID){
            HandleTimeout(mTimes == 7);
        }
    }
private:
    void HandleTimeout(bool toStop);
    int mTimerID;
    MainWindow* mWin;
    QString mEntityName;
    int mTimes;
};

class EntityStateRecoverTimer : public QObject
{

    Q_OBJECT
public:
    explicit EntityStateRecoverTimer(MainWindow *parent, QString entityName, EntityState restoreState)
        :QObject((QObject*)parent)
        ,mWin(parent)
        ,mEntityName(entityName)
        ,mState(restoreState)
        ,mTimes(0)
    {
        mTimerID = startTimer(10000);
    }
    virtual void timerEvent( QTimerEvent *event)
    {

        if(event->timerId() == mTimerID) {
            HandleTimeout();
        }
    }
private:
    void HandleTimeout();
    int mTimerID;
    MainWindow* mWin;
    QString mEntityName;
    EntityState mState;
    int mTimes;
};

class TimeDateTimer : public QObject
{
    Q_OBJECT
public:
    explicit TimeDateTimer(QObject *parent = 0)
        :QObject(parent)
        ,mWin(reinterpret_cast<MainWindow*>(parent))
        ,mDays(0),mHours(0),mMinutes(0),mSeconds(0){
        mTimer = new QTimer(this);
    }
    ~TimeDateTimer(){Stop();}
    void Start(int interval);
    void Stop();

private slots:
        void HandleTimeout();

private:
    QString GetCurrentRunTimeString()
    {
        QString result;
        if(mDays == 0)
            result = QString(QStringLiteral("elapsed: %1:%2:%3")).arg(mHours,2,10,QLatin1Char('0'))
                    .arg(mMinutes,2,10,QLatin1Char('0'))
                    .arg(mSeconds,2,10,QLatin1Char('0'));
        else
            result = QString(QStringLiteral("elapsed: %1 day - %2:%3:%4")).arg(mDays,2,10,QLatin1Char('0'))
                    .arg(mHours,2,10,QLatin1Char('0'))
                    .arg(mMinutes,2,10,QLatin1Char('0'))
                    .arg(mSeconds,2,10,QLatin1Char('0'));
        return result;
    }

    MainWindow* mWin;
    int mDays;
    int mHours;
    int mMinutes;
    int mSeconds;
    QTimer *mTimer;
};

enum ExecuteType {
    CreatesSubProcess = 0,
    BootEntity,
    RunShellScript
};



class RvcAdditionAction : public QAction
{
public:
    explicit RvcAdditionAction(QObject *parent = nullptr)
        :QAction(parent) {}
    explicit RvcAdditionAction(const QString &text, QObject *parent = nullptr)
        :QAction(text, parent) {}
    explicit RvcAdditionAction(const QIcon &icon, const QString &text, QObject *parent = nullptr)
        :QAction(icon, text, parent) {}

    struct AdditionMenuInfo {
        ExecuteType type;
        QString cmdLine;
        QString entityName;
    } userData;
};

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    MainWindow(QString systemInfo, int totalEntityCount, QWidget *parent = nullptr);
    ~MainWindow();

    bool CanDisturb() const;

protected:
    void closeEvent(QCloseEvent *event) override;

private:
    void Init(QString title);
    void Test_EntityList();
    void Test_EventLog();
    void InitMenuAction();
    void InitStatusBar();
    void InitEntitiesView();
    void AddEntityEntry(const EntityInfo& entityInst);
    void InitSystemTrayIcon();

    int TriggerEntityState(QString entityName, EntityState state, int pid = 0, bool flicker = true);
    int TriggerEntityState(QTableWidgetItem* item, EntityState state, int pid = 0, bool flicker = true);
    void TriggerEntityState(int row, EntityState state, int pid, bool flicker = true);
    int FindEntityRowIndex(QString entityName);

    void ShowStatusMessage(QString message, int messageType);

    int DealWithEntity(const EntityInfo& entity, DealType dealType, QString extendParam = "", bool multiThread = true);
    void UpdateEntityOperateBtnState(EntityState currState);
    void ResetAllEntityOperateBtnState(bool enable=true);
    void StartEntityFromCustom(const QString& entityName, const QString& cmdLine);
    bool LoadPlguins();
    void OnSilentStateChange(bool beSilent);

    void InitFloatWidget();

public slots:
    void ReceiveMessage(const QtMessageInfo* message);
    void ReceiveMessageVariant(QVariant info);
    void ReceiveEntityVariant(QVariant info);
    void ReceiveOperatResult(int action, int result, const QString& message);
    void ReceiveCustomOperatResult(int action, int result, const QString& message);

    void EntityItemContextMenu(QPoint pos);
private slots:

    void LoadCustomPlguins();

    void DisplayEntities();
    void EntitySelectionChanged();

    void StartEntity();
    void PauseEntity();
    void ContinueEntity();
    void TerminateEntity();
    void KillEntity();
    void TestEntity();

    void SortEntityItem(int n);
    void RemindEntityStateChange(int row, EntityState previousState, EntityState currState);

    void OnTrayIconActivated(QSystemTrayIcon::ActivationReason activeRson);

    void ConfigApp();
    void QuitApp();
    void RestartApp();
    void RestartSystem();
    void ShutdownSystem();
    void RestartAppThroughActive();
    void RestartAppThroughSpShell();
    void InitializeTerminal();
    void VersionView();
    void LogView();
    void ErrorCodeView();
    void RemoveEntityRuninfoConfigFile();

    void TriggerAdditionMenu(QAction* action);
    void ProcessStarted();
    void GetSubProcessMsg();

    void messageClicked();

    void ExportEntitySnapshot();

    void RecordEntitySnapshot();

private:

    EntityInfo GetCurrentSelectedEntity();
    EntityInfo GetEntityInfoByRowIndex(int row);
    QTableWidgetItem* FindEnityWidgetItem(QString entityName);
    void UpdateItemBackgroundColor(int row, EntityState state);

    enum NoteSrcType {
      BootStage,
      EntityFire
    };
    void Note(QString info, NoteSrcType srcType, QString srcEntity, bool bForce = false);

    QAction* CreateMenuAction(QString text, QKeySequence keyShot, QString toolTipText, void (MainWindow::*)());
    bool InsertConsole(const QtMessageInfo& message);
    /*弹窗显示信息*/
    void NotifyLogMessage(MessageType type, const QString& title, const QString& message);
    void UpdateEntityStatistics();
    void ExportEntityInfo(bool fromBtnClick);

    QString GetPerfStorePath();

    QStringList ExecuteShellScripts(QString shellCmd);
    
private:

    Ui::MainWindow *ui;
    RvcItemModel* mEntityModel;
    QItemSelectionModel *mEntitySelectedModel;
    QSortFilterProxyModel* mEntityFilterModel;
    QLabel *mToolsTip;
    MLabel* mStatusLabel;
    QTimer *mEntityStateChangeReminder;
    QMenu *mEntityPopMenu;
    friend RichTimer;
    friend EntityStateRecoverTimer;

    void RemindEntityStateChangeWith(QString entityName, bool bEnd);
    friend TimeDateTimer;
    void TimeUpdate(const QString& timeStr);

    CpuWidget mCpuWidget;
    MemoryWidget mMemoryWidget;
    PerformWidget* mPerformWidge;

    QVector< EntityBootInfo> mBootEntitiesInfo;

    QSystemTrayIcon *mSicon;
    bool mSilent;

    QAtomicInteger<quint32> mIdleEntityCount;
    QAtomicInteger<quint32> mTotalEntityCount;

    Widget* mFloatWidget;

};
#endif // MAINWINDOW_H