#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "console.h"

#include <QMessageBox>
#include <QTime>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent),
      m_ui(new Ui::MainWindow),
      m_console(new Console),
      m_serial(new QSerialPort),
      m_time(new QTime),
      m_timer(new QTimer),
      m_readyReadTimeout(new QTimer),

      m_serialTimeout(new QTimer)
{
    m_ui->setupUi(this);
    m_console->setEnabled(false);

    if (QIcon("reload_60.png").isNull())
    {
        qDebug() << "Icon is null";
    }

    m_ui->reloadButton->setIcon(QIcon("reload_60.png"));
    m_ui->reloadButton->setIconSize(QSize(30, 30));

    m_ui->consoleLayout->addWidget(m_console);

    connect(m_ui->rescanButton, &QPushButton::clicked, this, &MainWindow::fillPortsInfo);
    connect(m_ui->openCloseButton, &QPushButton::clicked, this, &MainWindow::openCloseSerialPort);
    connect(m_ui->countdownButton, &QPushButton::clicked, this, &MainWindow::setupCountdown);
    connect(m_timer, &QTimer::timeout, this, &MainWindow::updateCountdown);

    connect(m_ui->getNameButton, &QPushButton::clicked, this, &MainWindow::sendName);
    connect(m_serialTimeout, &QTimer::timeout, this, &MainWindow::receiveName);
    connect(m_ui->getFileButton, &QPushButton::clicked, this, &MainWindow::sendFile);
    connect(m_ui->getFileReadyReadButton, &QPushButton::clicked, this, &MainWindow::sendFileReadyRead);

    connect(&m_readyReadTimeout, &QTimer::timeout, this, &MainWindow::readyReadTimeout);


    fillPortsInfo();
    fillPortsParameters();
}

MainWindow::~MainWindow()
{
    delete m_ui;
}

void MainWindow::openCloseSerialPort()
{
    QString name = m_ui->serialPortListBox->currentText();
    qint32 baudRate = m_ui->baudRateBox->itemData(m_ui->baudRateBox->currentIndex()).toInt();

    if (m_serial->isOpen())
    {
        m_serial->close();
        m_console->setEnabled(false);
        m_ui->openCloseButton->setText("Open");
        m_ui->statusBar->showMessage(tr("Disconnected"));
    }
    else
    {
        qDebug() << name;
        qDebug() << baudRate;

        m_serial->setPortName(name);
        m_serial->setBaudRate(baudRate);
        m_serial->setDataBits(QSerialPort::Data8);
        m_serial->setParity(QSerialPort::NoParity);
        m_serial->setStopBits(QSerialPort::OneStop);
        m_serial->setFlowControl(QSerialPort::NoFlowControl);

        if (m_serial->open(QIODevice::ReadWrite))
        {
            m_console->setEnabled(true);


    //        m_console->setLocalEchoEnabled(p.localEchoEnabled);

            m_ui->openCloseButton->setText("Close");

            m_ui->statusBar->showMessage(tr("Connected to %1 : %2, %3, %4, %5, %6")
                    .arg(name).arg(baudRate).arg(QSerialPort::Data8)
                    .arg(QSerialPort::NoParity).arg(QSerialPort::OneStop).arg("N"));
        }
        else
        {
            QMessageBox::critical(this, tr("Error"), m_serial->errorString());

            m_ui->statusBar->showMessage(tr("Open error"));
        }
    }
}

void MainWindow::fillPortsParameters()
{
    m_ui->baudRateBox->addItem(QStringLiteral("921600"), 921600);
    m_ui->baudRateBox->addItem(QStringLiteral("9600"), QSerialPort::Baud9600);
    m_ui->baudRateBox->addItem(QStringLiteral("19200"), QSerialPort::Baud19200);
    m_ui->baudRateBox->addItem(QStringLiteral("38400"), QSerialPort::Baud38400);
    m_ui->baudRateBox->addItem(QStringLiteral("115200"), QSerialPort::Baud115200);
}

void MainWindow::fillPortsInfo()
{
    m_ui->serialPortListBox->clear();

    for(const QSerialPortInfo &info : QSerialPortInfo::availablePorts())
    {
        qDebug() << "--------------------------------------------------";
        qDebug() << "Description:  " << info.description();
        qDebug() << "Manufacturer: " << info.manufacturer();
        qDebug() << "PortName:     " << info.portName();

        m_ui->serialPortListBox->addItem(info.portName());  // Update SerialPort ComboBox
    }
}

void MainWindow::setupCountdown()
{
    m_time->setHMS(0,0,15,0);                               // 15s countdown

    QPalette *palette = new QPalette();
    palette->setColor(QPalette::Base,Qt::green);
    m_ui->countdownEdit->setPalette(*palette);

    m_ui->countdownEdit->setText(tr("Connected : %1").arg(m_time->toString().remove(0, 3)));

    m_timer->start(1000);                                   // start timeout every 1s
}


void MainWindow::updateCountdown()
{
    *m_time = m_time->addSecs(-1);                          // decrement countdown

    if (*m_time == QTime(0,0,0))                            // stop countdown at 0s
    {
        m_timer->stop();

        QPalette *palette = new QPalette();
        palette->setColor(QPalette::Base,Qt::red);
        m_ui->countdownEdit->setPalette(*palette);

        m_ui->countdownEdit->setText("Time-out ! need to reconnect sensor");
    }
    else
    {
        if (*m_time <= QTime(0,0,5))                            // stop countdown at 0s
        {
            QPalette *palette = new QPalette();
            palette->setColor(QPalette::Base,Qt::yellow);
            m_ui->countdownEdit->setPalette(*palette);

            m_ui->countdownEdit->setText(tr("Timeout in : %1").arg(m_time->toString().remove(0, 3)));
        }
        else
        {
            m_ui->countdownEdit->setText(tr("Connected : %1").arg(m_time->toString().remove(0, 3)));
        }
    }
}



void MainWindow::sendName()
{

    m_serial->write("$02$01$77%XOR00$04");

    m_console->putData("envoie de trame\r");
    m_console->putData("envoie de trame\r");

   m_serialTimeout->setSingleShot(true);
   m_serialTimeout->start(100);


    setupCountdown();
}

void MainWindow::receiveName()
{
    const QByteArray data = m_serial->readAll();
    m_console->putData(data);

    qDebug() << data;



}

void MainWindow::sendFile()
{
    m_serial->write("#CF,07\r");

    m_console->putData("#CF,07\r");

    QByteArray data = m_serial->readAll();

    if (m_serial->waitForReadyRead(1000))
    {
        data = m_serial->readAll();

        while (m_serial->waitForReadyRead(100))
        {
            data += m_serial->readAll();

            qDebug() << "size: " << data.length();
        }
    }

    m_console->putData(data);
    qDebug() << "finished";

}


void MainWindow::sendFileReadyRead()
{
    connect(m_serial, &QSerialPort::readyRead, this, &MainWindow::handleReadyRead);
    m_readyReadTimeout.start(1000);
    dataReadyRead.clear();
    m_serial->write("#CF,07\r");

    m_console->putData("#CF,07\r");
}


void MainWindow::handleReadyRead()
{
    dataReadyRead += m_serial->readAll();
    qDebug() << "size: " << dataReadyRead.length();
    m_readyReadTimeout.start(1000);
}


void MainWindow::readyReadTimeout()
{
    m_readyReadTimeout.stop();
    disconnect(m_serial, &QSerialPort::readyRead, this, &MainWindow::handleReadyRead);
    m_console->putData(dataReadyRead);
    qDebug() << "readyReadFinished";
}


void MainWindow::receiveFile()
{
    QByteArray data = m_serial->readAll();

    while (m_serial->waitForReadyRead(10))
                    data += m_serial->readAll();

    m_console->putData(data);

//    qDebug() << data;
}