GUI/src/forms/scan/ScanFormWidget.cpp

#include "ScanFormWidget.h"
#include "ui_TabFormWidget.h"

#include <QVBoxLayout>
#include <QToolButton>
#include <QButtonGroup>
#include <QPainter>
#include <QLabel>
#include <QTimer>
#include <QKeyEvent>
#include <qdebug.h>

#include "forms/scan/PatientInformationForm.h"
#include "event/EventCenter.h"
#include "dialogs/DialogManager.h"
#include "log/UserOperationLog.h"
#include "json/jsonobject.h"
#include "device/DeviceManager.h"
#include "dicom/WorkListManager.h"

#ifdef WIN32
#else
#include <cmath>
#endif

namespace{
    const size_t PREVIEW_ROW = 140;
    const size_t PREVIEW_COL = 140;
    const float PIXEL_SPACING = 1.5f;
    const float HALF_ROI_WIDTH = 100.0f;
    const unsigned int DRAINAGE_TIME = 180000; //3 minitues
}

ScanFormWidget::ScanFormWidget(QWidget* parent)
    : TabFormWidget(parent)
    , mPatInf(new PatientInformationForm(this))
    , mAccountButton(new QToolButton(this))
    , mShutdownButton(new QToolButton(this))
    , mWorklistButton(new QToolButton(this))
    , mStartScanButton(new QToolButton(this))
    , mDrainageButton(new QToolButton(this))
    , mXYLabel(new QLabel(this))
    , mZLabel(new QLabel(this))
    , mScanProcessLabel(new QLabel(this))
    , mDrainageTimer(new QTimer(this))
{

    auto commandlayout = new QHBoxLayout(ui->commandWidget);
    initCommandWidget(commandlayout);


    //initScanControlBar(commandlayout);
    initScanContent();
    initEvents();
    mDrainageTimer->setSingleShot(true);
    connect(mDrainageTimer, &QTimer::timeout, this, [this]()
    {
        mDrainageButton->click();
    });
}

void ScanFormWidget::initCommandWidget(QHBoxLayout *layout)
{
    bool anonymousMode = JsonObject::Instance()->getAnonymousMode();
    mAccountButton->setObjectName("btnAccount");
    mAccountButton->setText(tr("Account"));
    layout->addWidget(mAccountButton);

    mShutdownButton->setObjectName("btnShutDown");
    mShutdownButton->setText(tr("ShutDown"));
    layout->addWidget(mShutdownButton);

    mWorklistButton->setObjectName("btnWorklist");
    mWorklistButton->setText(tr("Worklist"));
    mWorklistButton->setEnabled(!anonymousMode);
    layout->addWidget(mWorklistButton);

    mStartScanButton->setObjectName("btnScan");
    mStartScanButton->setText(tr("Start Scan"));
    layout->addWidget(mStartScanButton);

    layout->addSpacerItem(new QSpacerItem(20, 20, QSizePolicy::Expanding));
    addVerticalLine(layout);

    mDrainageButton->setObjectName("btnDrainage");
    mDrainageButton->setCheckable(true);
    mDrainageButton->setText(tr("Drainage"));
    layout->addWidget(mDrainageButton);

    connect(mDrainageButton, &QToolButton::clicked, [=](bool aSatus)
    {
        //Drainage
        if(aSatus && DialogManager::Default()->requestAlertMessage(tr("Make sure to open the drain valve ?"), DialogButtonMode::OkAndCancel, tr("Confirm Drainage")) == QDialog::Rejected)
        {
            mDrainageButton->setChecked(!aSatus);
            return;
        }
        mDrainageButton->setEnabled(false);
        if(aSatus == true)
        {
            mDrainageTimer->start(DRAINAGE_TIME);
            QString code = "1";
            mDrainageButton->setText(tr("Drainaging"));
            EventCenter::Default()->triggerEvent(RequestDrainage, nullptr, (QObject*)(&code));
            LOG_USER_OPERATION("Perform Drainage");
        }
        else
        {
            mDrainageTimer->stop();
            QString code = "0";
            mDrainageButton->setText(tr("Drainage"));
            EventCenter::Default()->triggerEvent(RequestDrainage, nullptr, (QObject*)(&code));
            LOG_USER_OPERATION("Stop Drainage");
        }
    });

    connect(DeviceManager::Default(), &DeviceManager::startPumpControlResult, [this](bool aIsSucessful)
    {
        mDrainageButton->setEnabled(true);
        if(!aIsSucessful)
        {
            mDrainageTimer->stop();
            bool isChecked = mDrainageButton->isChecked();
            mDrainageButton->setChecked(!isChecked);
            if(isChecked)
            {
                mDrainageButton->setText(tr("Drainage"));
            }
            else
            {
                mDrainageButton->setText(tr("Drainaging"));
            }
        }
    });

    connect(mAccountButton, &QToolButton::clicked, DialogManager::Default(),&DialogManager::requestEditSelfAccount);

    connect(mShutdownButton, &QToolButton::clicked, []()
    {
        if(DialogManager::Default()->requestAlertMessage(QString(tr("Shut down now ?")), DialogButtonMode::OkAndCancel,tr("Shut Down")) == QDialog::Accepted)
        {
            LOG_USER_OPERATION("Shut Down")
            EventCenter::Default()->triggerEvent(GUIEvents::RequestShutdown, nullptr, nullptr);
        }
    });

    connect(mWorklistButton, &QToolButton::clicked, [&]()
    {
        DialogManager::Default()->requestGetWorkList();
    });

    connect(EventCenter::Default(), &EventCenter::AnonymousModeChanged, this, &ScanFormWidget::updateDataByAnonymousMode);


//    auto group = new QButtonGroup(ui->commandWidget);
//    mBtnLeft->setCheckable(true);
//    mBtnLeft->setChecked(true);
//    mBtnRight->setCheckable(true);
//    group->addButton(mBtnRight, 1);
//    group->addButton(mBtnLeft, 0);
//    connect(group, SIGNAL(buttonClicked(int)), this, SLOT(protocolChanged(int)));
}

void ScanFormWidget::initScanContent()
{

    QHBoxLayout* contentLayout = new QHBoxLayout(ui->contentWidget);
    contentLayout->addWidget(mPatInf);

    QWidget* scanProcessWidget = new QWidget(this);
    scanProcessWidget->setObjectName("ScanProcessWidget");
    contentLayout->addWidget(scanProcessWidget);

    QVBoxLayout* scanProcessLayout = new QVBoxLayout(scanProcessWidget);
    mScanProcessLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
    mScanProcessLabel->setAlignment(Qt::AlignCenter);
    mScanProcessLabel->setObjectName("ScanProcessInformation");
    mScanProcessLabel->setText(tr("Please confirm checking patient information to start the process"));
    scanProcessLayout->addWidget(mScanProcessLabel);
    QWidget* displayWidget = new QWidget(this);
    scanProcessLayout->addWidget(displayWidget);



    QHBoxLayout* displayLayout = new QHBoxLayout(displayWidget);
    QWidget* xyWidget = new QWidget(this);
    xyWidget->setObjectName("broadcastWidget");
    QHBoxLayout* xyLayout = new QHBoxLayout(xyWidget);
    xyLayout->addWidget(mXYLabel);
    displayLayout->addWidget(xyWidget);

    QWidget* zWidget = new QWidget(this);
    zWidget->setObjectName("broadcastWidget");
    QHBoxLayout* zLayout = new QHBoxLayout(zWidget);
    zLayout->addWidget(mZLabel);
    displayLayout->addWidget(zWidget);


}

void ScanFormWidget::initScanControlBar(QHBoxLayout *layout)
{
//    connect(mBtnEScan, &QToolButton::clicked, [=]() {
//        int result = DialogManager::Default()->requestAlertMessage(tr("Please make sure the holder is only contain water!"),DialogButtonMode::OkAndCancel,tr("Confirm Scan"));
//        if (result != QDialog::Accepted)return;
//        QString patientInf(mPatInf->getCurrentPatientJsonString(true));
//        LOG_USER_OPERATION("Start Empty Scan")
//        EventCenter::Default()->triggerEvent(RequestEmptyScan, nullptr, (QObject*)(&patientInf));
//    });
//    connect(mBtnPreview, &QToolButton::clicked, [=]() {
//        LOG_USER_OPERATION(QString("Start Preview, ID: %1").arg(mPatInf->getPatientID()))
//        EventCenter::Default()->triggerEvent(RequestPreviewScan, nullptr, nullptr);
        
//    });
    connect(DeviceManager::Default(), &DeviceManager::startPreviewScanResult, [this](bool aIsSucessful)
    {
        if(!aIsSucessful)
        {
            setPreviewing(false);
        }
    });


//    connect(mBtnScan, &QToolButton::clicked, [=]() {
//        if(JsonObject::Instance()->getScanConfirm())
//        {
//            int ret = DialogManager::Default()->requestPatientConfirm(mPatInf->getPatientInformation(),mPatInf->getProtocol());
//            if (ret != QDialog::Accepted) return;
//        }
//        QString patientInf(mPatInf->getCurrentPatientJsonString(false));
//        LOG_USER_OPERATION(QString("Start Scan, ID: %1").arg(mPatInf->getPatientID()))
//        if (!DeviceManager::Default()->hasValidEmptyScan()){
//            QString msg(tr("No refresh data exists, please do Refresh operation first."));
//            EventCenter::Default()->triggerEvent(DeviceErrorRaise, nullptr, (QObject*)(&msg));
//            return;
//        }
//        EventCenter::Default()->triggerEvent(RequestPatientScan, nullptr, (QObject*)(&patientInf));
//    });
//    connect(mBtnStop, &QToolButton::clicked, [=]() {
//        LOG_USER_OPERATION("Stop Preview")
//        EventCenter::Default()->triggerEvent(RequestPreviewStop, nullptr, nullptr);
//    });

}

void ScanFormWidget::protocolChanged(int type)
{
    LOG_USER_OPERATION(QString("Select Laterality %1").arg(type == 0 ? "Left" : "Right"));
}

void ScanFormWidget::setPreviewing(bool val)
{
//    mBtnPreview->setCheckable(val);
//    mBtnPreview->setChecked(val);
//    mBtnPreview->setEnabled(!val);
//    mBtnEScan->setEnabled(!val);
//    mBtnScan->setEnabled(!val);
    mDrainageButton->setEnabled(!val);

}

void ScanFormWidget::renderLoading()
{
    setPreviewing(true);

    uchar c_data[PREVIEW_ROW][PREVIEW_COL];
    for (auto data_ptr : c_data) {
        memset(data_ptr, 0, PREVIEW_COL);
    }
    QImage img(c_data[0], PREVIEW_COL, PREVIEW_ROW, QImage::Format_Grayscale8);
    QPixmap pic = QPixmap::fromImage(img).scaledToHeight(800, Qt::SmoothTransformation);
    QPainter painter(&pic);
    QPen pen;
    pen.setStyle(Qt::DashLine);
    pen.setWidth(3);
    QFont font("Futura");
    font.setPixelSize(26);
    font.setBold(true);
    painter.setFont(font);
    pen.setColor(QColor(255, 255, 0));
    painter.setPen(pen);
    painter.drawText(400 - 13 * 5, 400 + 13, "Loading...");
}

void ScanFormWidget::renderPreviewData(const QObject* /*sender*/,const QObject *data)
{
    if (!data)return;
    auto array = (QByteArray*)data;
    auto raw_dataptr = (uchar*)array->data();
    uchar c_data[PREVIEW_ROW][PREVIEW_COL];
    for (auto data_ptr : c_data) {
        memcpy(data_ptr, raw_dataptr, PREVIEW_COL);
        raw_dataptr += PREVIEW_COL;
    }
    QImage img(c_data[0], PREVIEW_COL, PREVIEW_ROW, QImage::Format_Grayscale8);
    QPixmap pic = QPixmap::fromImage(img).scaledToHeight(800, Qt::SmoothTransformation);
    QPainter painter(&pic);
    QPen pen;
    pen.setColor(QColor(255, 255, 0, 100));
    pen.setStyle(Qt::DashLine);
    pen.setWidth(3);
    QFont font("Futura");
    font.setPixelSize(26);
    font.setBold(true);
    painter.setFont(font);
    painter.setPen(pen);
    static int borderSpacing = (int)roundf(((PIXEL_SPACING * (PREVIEW_ROW * 0.5f) - HALF_ROI_WIDTH) * (800.0f / (1.5f * 140.0f))));
    painter.drawLine(borderSpacing, borderSpacing, borderSpacing, 800 - borderSpacing);
    painter.drawLine(borderSpacing + 1, borderSpacing, 800 - borderSpacing, borderSpacing);
    painter.drawLine(borderSpacing + 1, 800 - borderSpacing, 800 - borderSpacing, 800 - borderSpacing);
    painter.drawLine(800 - borderSpacing, borderSpacing + 1, 800 - borderSpacing, 800 - borderSpacing - 1);
    pen.setColor(QColor(255, 255, 0));
    painter.setPen(pen);
    painter.drawText(335,40,QString("Previewing, current frame:%1").arg(++mCurrentFrame));
    painter.drawText(borderSpacing + 13, 400 + 13, "L");
    painter.drawText(800 - borderSpacing - 30, 400 + 13, "R");
    painter.drawText(400 - 13, borderSpacing + 30, "H");
    painter.drawText(400 - 13, 800 - borderSpacing - 13, "F");
    painter.drawText(borderSpacing + 6, borderSpacing + 30, "ROI");
}

void ScanFormWidget::initEvents()
{
    //Events---------------------------------------------------------------
    connect(EventCenter::Default(), &EventCenter::PatientSelected, [=](QObject* sender, QObject* data) {
        if (data)
        {
              PatientInformation* patientInfo = (PatientInformation*)data;
              DialogResult result = DialogManager::Default()->reuqestConfirmStartScan(patientInfo);
              if(result.ResultCode == QDialog::Accepted)
              {

                  mPatInf->setPatientInformation(patientInfo->Copy());
              }

//            mBtnScan->setEnabled(true);
//            mBtnEScan->setEnabled(true);
//            mBtnPreview->setEnabled(true);
//            mBtnStop->setEnabled(true);
        }
        else{
//            mBtnScan->setEnabled(false);
//            mBtnEScan->setEnabled(false);
//            mBtnPreview->setEnabled(false);
//            mBtnStop->setEnabled(false);
        }
    });
    connect(EventCenter::Default(), &EventCenter::ResponseStopPreview, [=](QObject* sender, QObject* data) {
        setPreviewing(false);
    });
    connect(EventCenter::Default(), &EventCenter::ResponsePreview, this,&ScanFormWidget::renderLoading);
    connect(EventCenter::Default(), &EventCenter::ResponsePreviewData, this,&ScanFormWidget::renderPreviewData);
    connect(EventCenter::Default(), &EventCenter::ReloadLanguage, this, &ScanFormWidget::reloadLanguage);
    connect(EventCenter::Default(), &EventCenter::DeviceErrorRaise, [=](QObject* parent, QObject* msg){
        printf("signal:%d\r\n",senderSignalIndex());
    });
}

void ScanFormWidget::reloadLanguage()
{
    mAccountButton->setText(tr("Account"));
    mShutdownButton->setText(tr("ShutDown"));
    mWorklistButton->setText(tr("Worklist"));
    mStartScanButton->setText(tr("Start Scan"));
    mDrainageButton->isChecked() ? mDrainageButton->setText(tr("Drainaging")) : mDrainageButton->setText(tr("Drainage"));
}

void ScanFormWidget::updateDataByAnonymousMode()
{
    bool anonymousMode = JsonObject::Instance()->getAnonymousMode();
    mWorklistButton->setEnabled(!anonymousMode);
}

void ScanFormWidget::keyPressEvent(QKeyEvent* aEvent)
{
    switch (aEvent->key())
    {
        case Qt::Key_0:
        case Qt::Key_1:
        case Qt::Key_2:
        case Qt::Key_3:
        case Qt::Key_4:
        case Qt::Key_5:
        case Qt::Key_6:
        case Qt::Key_7:
        case Qt::Key_8:
        case Qt::Key_9:
        case Qt::Key_A:
        case Qt::Key_B:
        case Qt::Key_C:
        case Qt::Key_D:
        case Qt::Key_E:
        case Qt::Key_F:
        case Qt::Key_G:
        case Qt::Key_H:
        case Qt::Key_I:
        case Qt::Key_J:
        case Qt::Key_K:
        case Qt::Key_L:
        case Qt::Key_M:
        case Qt::Key_N:
        case Qt::Key_O:
        case Qt::Key_P:
        case Qt::Key_Q:
        case Qt::Key_R:
        case Qt::Key_S:
        case Qt::Key_T:
        case Qt::Key_U:
        case Qt::Key_V:
        case Qt::Key_W:
        case Qt::Key_X:
        case Qt::Key_Y:
        case Qt::Key_Z:
        {
            WorkListManager::getInstance()->setSearchString(aEvent->text());
            break;
        }
        case Qt::Key_Enter:
        case Qt::Key_Return:
        {
            QString text = WorkListManager::getInstance()->getSearchString();
            EventCenter::Default()->triggerEvent(InputWorkListSearchValue, nullptr, (QObject*)&text);
            break;
        }
        default:
        break;
    }
    QWidget::keyPressEvent(aEvent);
}