#include "MainWindow.h"

#include <qtabwidget.h>
#include <QSizePolicy>
#include <QHBoxLayout>
#include <QScrollBar>
#include <QDateTime>
#include <QGestureEvent>
#include <QDockWidget>
#include <fstream>
#include <sstream>
#include <QKeyEvent>

#include "ui_MainWindow.h"
#include "event/EventCenter.h"
#include "forms/tabformwidget.h"
#include "forms/select/SelectFormWidget.h"
#include "forms/scan/ScanFormWidget.h"
#include "forms/settings/AdminSettingForm.h"
#include "forms/TopBarWidget.h"
#include "dialogs/guimessagedialog.h"
#include "device/DeviceManager.h"
#include "errorhandle/GUIErrorHandle.h"
#include "LoginDialog.h"
#include "models/User.h"
#include "appvals/AppGlobalValues.h"
#include "components/UTextEdit.h"

MainWindow::MainWindow(QWidget* aParent)
    : QMainWindow(aParent)
    , mUI(new Ui::MainWindow)
    , mDebugConsoleWidget(nullptr)
    , mMessageDialog(nullptr)
    , mDebugMessageConsole(nullptr)
    , mTabWidget(new QTabWidget(this))
    , mAdminTabIndex(-1)
    , mLoginDialog(new LoginDialog(this))
    , mThread(nullptr)
    , mIsDebugMode(false)
{
    mUI->setupUi(this);
    this->loadStyleSheet("Dark2");
    this->setWindowFlags(Qt::Window);

    initializeTabWidget();
    initializeLayout();

    connect(EventCenter::Default(), &EventCenter::PatientSelected, [=](QObject* sender, QObject* data) {
        mTabWidget->setCurrentIndex(1);
        });

    connect(EventCenter::Default(), &EventCenter::DeviceErrorRaise, [=](QObject* parent, QObject* msg) {
        if (!this->isVisible()) return;
        //默认旧模式
        if (!mMessageDialog)
        {
            mMessageDialog = new GUIMessageDialog(this);
        }
        if (msg)
        {
            QString* str = (QString*)msg;
            mMessageDialog->showMessage(*str);
        }
        else
        {
            mMessageDialog->showMessage("Something went error!");
        }
        mMessageDialog->stopLoading();
        mMessageDialog->showExitButton();
        if (mMessageDialog->isHidden())
        {
            mMessageDialog->setWindowModality(Qt::NonModal);
            mMessageDialog->exec();
        }
    });
    connect(EventCenter::Default(), &EventCenter::InvokeOperationStart, [=](QObject*, QObject* msg) {
        if (mMessageDialog)
        {
            mMessageDialog->hide();
            delete mMessageDialog;
        }
        mMessageDialog = new GUIMessageDialog(this);
        if (msg)
        {
            QString* str = (QString*)msg;
            mMessageDialog->showMessage(*str);
        }
        else
        {
            mMessageDialog->hideMessage();
        }
        mMessageDialog->hideExitButton();
        mMessageDialog->startLoading();
        AppGlobalValues::setInProcessing(true);
        //		msgDialog->showFullScreen();
        if (mMessageDialog->isHidden())
        {
            mMessageDialog->show();
        }
        });
    connect(EventCenter::Default(), &EventCenter::InvokeOperationProgress, [=](QObject*, QObject* msg) {
        if (!mMessageDialog) mMessageDialog = new GUIMessageDialog(this);
        if (msg)
        {
            QVariant* var = (QVariant*)msg;
            if (mMessageDialog->Pending())
            {
                mMessageDialog->stopPending();
            }
            mMessageDialog->showMessage(var->toString());
        }
        else
        {
            mMessageDialog->hideMessage();
        }
        if (mMessageDialog->isHidden())
        {
            mMessageDialog->show();
        }
        });
    connect(EventCenter::Default(), &EventCenter::InvokeOperationPending, [=](QObject*, QObject* msg) {
        if (!mMessageDialog) return;
        if (!mMessageDialog->Pending())
        {
            mMessageDialog->startPending();
            QVariant* var = (QVariant*)msg;
            mMessageDialog->showMessage(var->toString());
        }
        });
    connect(EventCenter::Default(), &EventCenter::InvokeOperationEnd, [=](QObject*, QObject* v) {
        if (!mMessageDialog)
        {
            return;
        }
        if (!mMessageDialog->isHidden())
        {
            if (v && ((QVariant*)v)->toBool())
            {
                mMessageDialog->stopLoading();
                mMessageDialog->showMessage("Scan completed!");
                mMessageDialog->showExitButton();
                mMessageDialog->setWindowModality(Qt::WindowModal);
                mMessageDialog->exec();
            }
            else
            {
                mMessageDialog->accept();
            }
            delete mMessageDialog;
            mMessageDialog = nullptr;
            AppGlobalValues::setInProcessing(false);
        }
        });
    connect(EventCenter::Default(), &EventCenter::RequestLogin, [=](QObject*, QObject* msg) {
        this->requestLogin();
        });
    connect(EventCenter::Default(), &EventCenter::LoginRoleChanged, [=](QObject*, QObject*) {
        if (User::Current()->isAdmin())
        {
            if (mAdminTabIndex == -1)
            {
                AdminSettingForm* form = new AdminSettingForm(this);
                mAdminTabIndex = mTabWidget->addTab(form, tr("Settings"));
            }
        }
        else
        {
            if (mAdminTabIndex != -1)
            {
                mTabWidget->removeTab(mAdminTabIndex);
                mAdminTabIndex = -1;
            }
        }
        qApp->processEvents();
        });
    connect(DeviceManager::Default(), &DeviceManager::raiseGlobalError, this, &MainWindow::triggerError);
    GUIErrorHandle::Default()->init();
    mThread = QThread::create([]() {
        QThread::sleep(10);
        int f = 0x00100001;
        for (int i = 0; i < 8; ++i)
        {
            QThread::sleep(10);
            f = f << (i * 4);
            printf("invoke %d\r\n", f);
            char* v = (char*)&f;
            QString msg;
            msg.append("w ");
            msg.append(v[0]);
            msg.append(v[1]);
            msg.append(v[2]);
            msg.append(v[3]);
            EventCenter::Default()->triggerEvent(GUIErrorRaise, nullptr, (QObject*)&msg);
        }
        });
    mThread->start();
    centerWidgetHide();
    connect(EventCenter::Default(), &EventCenter::ReloadLanguage, [=]() {
        mTabWidget->setTabText(0, tr("Select"));
        mTabWidget->setTabText(1, tr("Scan"));
        mTabWidget->setTabText(2, tr("Verify"));
        mTabWidget->setTabText(3, tr("Settings"));
        });
}

void MainWindow::initializeTabWidget()
{
    mTabWidget->setTabPosition(QTabWidget::South);
    mTabWidget->setContentsMargins(0, 0, 0, 0);

    SelectFormWidget* selectForm = new SelectFormWidget(this);
    mTabWidget->addTab(selectForm, tr("Select"));
    ScanFormWidget* scanForm = new ScanFormWidget(this);
    mTabWidget->addTab(scanForm, tr("Scan"));
    TabFormWidget* verifyForm = new TabFormWidget(this);
    mTabWidget->addTab(verifyForm, tr("Verify"));
    mTabWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
}

void MainWindow::initializeLayout()
{
    QVBoxLayout* layout = new QVBoxLayout(this);
    layout->setMargin(0);
    layout->setSpacing(0);
    QWidget* topBarWidget = new TopBarWidget(this);
    topBarWidget->setObjectName("topbarWidget");
    layout->addWidget(topBarWidget);
    layout->addWidget(mTabWidget);

    mUI->mCentralWidget->setLayout(layout);
}

void MainWindow::QMessageOutput(QtMsgType aType, const QMessageLogContext& aContext, const QString& msg)
{

    std::cout << msg.toStdString().c_str() << std::endl;

    //QByteArray localMsg = msg.toLocal8Bit();
    //switch (type) {
    //case QtDebugMsg:
    //	fprintf(stderr, "Debug: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line, context.function);
    //	break;
    //case QtInfoMsg:
    //	fprintf(stderr, "Info: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line, context.function);
    //	break;
    //case QtWarningMsg:
    //	fprintf(stderr, "Warning: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line, context.function);
    //	break;
    //case QtCriticalMsg:
    //	fprintf(stderr, "Critical: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line, context.function);
    //	break;
    //case QtFatalMsg:
    //	fprintf(stderr, "Fatal: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line, context.function);
    //	abort();
    //}
}

MainWindow::~MainWindow()
{
    mThread->terminate();
    mThread->deleteLater();
    delete mUI;
}
void MainWindow::changeEvent(QEvent* aEvent)
{
    if (aEvent->type() == QEvent::LanguageChange)
    {
        mUI->retranslateUi(this);
    }

    QWidget::changeEvent(aEvent);
}


void MainWindow::loadStyleSheet(const QString& aSheetName)
{
    QFile file(":/stylesheet/" + aSheetName + ".css");
    file.open(QFile::ReadOnly);
    if (file.isOpen())
    {
        QString styleSheet = this->styleSheet();
        styleSheet += QLatin1String(file.readAll());
        this->setStyleSheet(styleSheet);
    }
}

void MainWindow::centerWidgetHide()
{
    mUI->mCentralWidget->setVisible(false);
}

void MainWindow::centerWidgetShow()
{
    mUI->mCentralWidget->setVisible(true);
}


QTextEdit* MainWindow::getEdit()
{
    return mDebugMessageConsole;
}

void MainWindow::requestLogin()
{
    mLoginDialog->clearInputData();
    mLoginDialog->setWindowModality(Qt::WindowModal);
    mLoginDialog->showFullScreen();
    centerWidgetHide();
    while (QDialog::Accepted != mLoginDialog->result())
    {
        mLoginDialog->exec();
    }
    mLoginDialog->setResult(QDialog::Rejected);
    centerWidgetShow();
}

void MainWindow::debugConsoleOn()
{
    mIsDebugMode = true;
    mDebugConsoleWidget = new QDockWidget(this);
    mDebugConsoleWidget->setObjectName(QString::fromUtf8("dockWidget"));
    mDebugConsoleWidget->setAllowedAreas(Qt::RightDockWidgetArea);
    this->addDockWidget(static_cast<Qt::DockWidgetArea>(2), mDebugConsoleWidget);

    mDebugMessageConsole = new UTextEdit(this);
    mDebugMessageConsole->setFocusPolicy(Qt::NoFocus);
    mDebugConsoleWidget->setWidget(mDebugMessageConsole);

    const QString edit_style =
        "QScrollBar:vertical{border: 0px solid grey; background:#2d2d2d; width: 15px; margin: 0px 0 0px 0; }"
        "QScrollBar::handle:vertical{background:#5a5a5a;min-height: 25px;}"
        "QScrollBar::add-page:vertical, QScrollBar::sub-page:vertical{background:#2d2d2d;}";
    mDebugMessageConsole->verticalScrollBar()->setStyleSheet(edit_style);
    //clear buffer before redirect;
}

void MainWindow::triggerError(const QString& aMessage)
{
    QString message(aMessage);
    EventCenter::Default()->triggerEvent(GUIErrorRaise, nullptr, (QObject*)&message);
}

void MainWindow::grabGestures(const QList<Qt::GestureType>& aGestures)
{
    //! [enable gestures]
    foreach(Qt::GestureType gesture, aGestures)
    {
        grabGesture(gesture);
    }
    //! [enable gestures]
}

//! [event handler]
bool MainWindow::event(QEvent* aEvent)
{
    if (aEvent->type() == QEvent::Gesture)
    {
        return gestureEvent(static_cast<QGestureEvent*>(aEvent));
    }
    return QWidget::event(aEvent);
}

bool MainWindow::gestureEvent(QGestureEvent* aGestureEvent)
{
    if (QGesture* swipe = aGestureEvent->gesture(Qt::SwipeGesture))
    {
        swipeTriggered(static_cast<QSwipeGesture*>(swipe));
    }
    if (QGesture* pan = aGestureEvent->gesture(Qt::PanGesture))
    {
        panTriggered(static_cast<QPanGesture*>(pan));
    }
    return true;
}

void MainWindow::panTriggered(QPanGesture* aPanGesture)
{
    if (aPanGesture->state() == Qt::GestureFinished)
    {
        QPointF delta = aPanGesture->offset();
        int index = mTabWidget->currentIndex();
        if (delta.x() > 50)
        {

            index--;
            if (index >= 0)
            {
                mTabWidget->setCurrentIndex(index);
            }
        }
        if (delta.x() < -50)
        {
            index++;
            if (index < mTabWidget->count())
            {
                mTabWidget->setCurrentIndex(index);
            }
        }
    }
}

void MainWindow::swipeTriggered(QSwipeGesture* aSwipeGesture)
{
    if (aSwipeGesture->state() == Qt::GestureFinished)
    {
        //if (gesture->horizontalDirection() == QSwipeGesture::Right) {
        //	int index = tab->currentIndex();
        //	index--;
        //	if (index >= 0) {
        //		tab->setCurrentIndex(index);
        //	}

        //}
        //if (gesture->horizontalDirection() == QSwipeGesture::Left) {
        //	int index = tab->currentIndex();
        //	index++;
        //	if (index < tab->count()) {
        //		tab->setCurrentIndex(index);
        //	}
        //}
        if (aSwipeGesture->verticalDirection() == QSwipeGesture::Down)
        {
            if (mIsDebugMode)
            {
                mDebugConsoleWidget->show();
            }
        }
        if (aSwipeGesture->verticalDirection() == QSwipeGesture::Up)
        {
            if (mIsDebugMode)
            {
                mDebugConsoleWidget->hide();
            }
        }
        //update();
    }
}

void MainWindow::keyPressEvent(QKeyEvent *event) {
    if (event->modifiers()==Qt::ControlModifier &&event->key()==Qt::Key_R){
        QFile file("D:\\workdir\\GUI\\src\\stylesheet\\Dark2.css");
        file.open(QFile::ReadOnly);
        if (file.isOpen())
        {
            QString styleSheet = this->styleSheet();
            styleSheet += QLatin1String(file.readAll());
            this->setStyleSheet(styleSheet);
        }
        this->update();
    }

    QWidget::keyPressEvent(event);
}