#include "dialog_inputserialnum.h"
#include "ui_dialog_inputserialnum.h"
#include "mainwindow.h"
#include "base/HGBase.h"

Dialog_InputSerialNum::Dialog_InputSerialNum(class MainWindow *mainWnd, const QString &devName,
                                             SANE_Handle handle, const QString &serialNum, const QString &devType) :
    QDialog(mainWnd),
    ui(new Ui::Dialog_InputSerialNum),
    m_mainWnd(mainWnd),
    m_handle(handle),
    m_valid(true),
    m_serialNum(serialNum),
    m_devType(devType),
    m_devName(devName),
    m_hg(nullptr)
{
    ui->setupUi(this);

    setWindowFlags(Qt::Dialog | Qt::WindowCloseButtonHint);

    QFont ft;
    ft.setPointSize(15);
    this->setFont(ft);

    ui->lineEdit_sn->setValidator(new QRegExpValidator(QRegExp("[a-zA-Z0-9]+$")));
    ui->lineEdit_sn->setMaxLength(14);

    if (handle != nullptr)
    {
        ui->cbox_devType->setEnabled(false);
        ui->cbox_devType->setCurrentText(devType);
        ui->lineEdit_sn->setText(serialNum);
        ui->lineEdit_sn->selectAll();
    }
    else
    {
        ui->cbox_devType->setCurrentIndex(0);
        ui->lineEdit_sn->setText("");
        ui->pbtn_setSn->setEnabled(false);
    }

    if (m_handle != nullptr)
        m_hg = new hgscanner(nullptr, nullptr, this, m_handle);

    connect(this, SIGNAL(testResult()), this, SLOT(on_testResult()));
}

Dialog_InputSerialNum::~Dialog_InputSerialNum()
{
    delete m_hg;
    m_hg = nullptr;

    delete ui;
}

QString Dialog_InputSerialNum::GetSn()
{
    return ui->lineEdit_sn->text();
}

QString Dialog_InputSerialNum::GetDevType()
{
    return ui->cbox_devType->currentText();
}

void Dialog_InputSerialNum::Invalid(const QString &devName)
{
    if (devName == m_devName)
    {
        sane_close(m_handle);
        m_handle = nullptr;
        m_valid = false;
        reject();
    }
}

void Dialog_InputSerialNum::setSpeedAndSleep(bool updateSleep)
{
    if (m_hg == nullptr)
    {
        return;
    }

    HGChar cfgPath[512] = {0};
    HGBase_GetConfigPath(cfgPath, 512);
    HGBase_CreateDir(cfgPath);
    strcat(cfgPath, m_devType.toStdString().c_str());
    strcat(cfgPath, ".json");

    //HGPdtToolDb_DownloadFile(m_pdtToolDbuserMgr, m_devType.toStdString().c_str(), cfgPath);

    AnalysisJson analysisJson(QString::fromStdString(cfgPath));
    AnalysisJson::json_global jsonGlobal = analysisJson.GetGlobal();
    LPWRITECFG lp = new WRITECFG;

    if (updateSleep)
    {
        int sleepTime = jsonGlobal.sleep_time;
        lp->cat = WRITE_CAT_SLEEP;
        lp->val = (void*)&sleepTime;
        m_mainWnd->addTestingRef();
        func_test_go(WRITE_CFG_NAME, (const wchar_t*)lp, m_hg);

        delete lp;
        return;
    }

    VIDPID vidpid;
    vidpid.VID = jsonGlobal.vid_to;
    vidpid.PID = jsonGlobal.pid_to;
    int vidpidValue = vidpid.Value;
    lp->cat = WRITE_CAT_VID_PID;
    lp->val = (void*)&vidpidValue;
    m_mainWnd->addTestingRef();
    func_test_go(WRITE_CFG_NAME, (const wchar_t*)lp, m_hg);

    int speedMode = jsonGlobal.speed_mode ;
    lp->cat = WRITE_CAT_SPEED;
    lp->val = (void*)&speedMode;
    m_mainWnd->addTestingRef();
    func_test_go(WRITE_CFG_NAME, (const wchar_t*)lp, m_hg);

    QString device_model = jsonGlobal.device_model;
    if (!device_model.isEmpty())
    {
        std::wstring devModel = device_model.toStdWString();
        lp->cat = WRITE_CAT_DEVS_MODEL;
        lp->val = (void*)devModel.c_str();
        m_mainWnd->addTestingRef();
        func_test_go(WRITE_CFG_NAME, (const wchar_t*)lp, m_hg);
    }

    delete lp;
}

void Dialog_InputSerialNum::on_testResult()
{
    m_mainWnd->releaseTesting();
}

void Dialog_InputSerialNum::on_pbtn_ok_clicked()
{
    if (!m_valid)
    {
        QMessageBox::information(this, tr("tips"), tr("device is lost"));
        reject();
        return;
    }

    if (ui->lineEdit_sn->text().isEmpty())
    {
        QMessageBox::information(this, tr("tips"), tr("Serial num is empty"));
        return;
    }

    QString str = ui->lineEdit_sn->text();
    for (int i = 0; i < str.size(); ++i)
    {
        if ((str.at(i) < '0' && str.at(i) > '9') || (str.at(i) < 'A' && str.at(i) > 'Z'))
        {
            QMessageBox::information(this, tr("tips"), tr("sn is illegal"));
            return;
        }
    }

    if (m_mainWnd->FindInterface(ui->lineEdit_sn->text()) != nullptr)
    {
        QMessageBox::information(this, tr("tips"), tr("The device is testing"));
        return;
    }

    setSpeedAndSleep(true);
    accept();
}

void Dialog_InputSerialNum::on_pbtn_cancel_clicked()
{
    reject();
}

void Dialog_InputSerialNum::on_pbtn_setSn_clicked()
{
    QString sn = ui->lineEdit_sn->text();
    std::string serialNum = sn.toStdString();
    if(SANE_STATUS_GOOD != sane_io_control(m_handle, IO_CTRL_CODE_SET_SERIAL, &serialNum[0], nullptr))
    {
        QMessageBox::information(this, tr("tips"), tr("set sn failed"));
    }
    else
    {
        ui->lineEdit_sn->setText(m_mainWnd->getDevSn(m_handle));
        QMessageBox::information(this, tr("tips"), tr("set sn succeed"));
    }

    setSpeedAndSleep(false);
}