/*

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "portcontrol.h"

#include "ui_portcontrol.h"

#include <QSerialPortInfo>

#include <QKeySequence>

#include <QLabel>

#include <QMap>

#include <QtDebug>

#include "setting_defines.h"

#include "utils.h"

#define TBPORTLIST_MINWIDTH (200)

// setting mappings

const QMap<QSerialPort::Parity, QString> paritySettingMap({

        {QSerialPort::NoParity, "none"},

        {QSerialPort::OddParity, "odd"},

        {QSerialPort::EvenParity, "even"},

    });

PortControl::PortControl(QSerialPort* port, QWidget* parent) :

    QWidget(parent),

    ui(new Ui::PortControl),

    portToolBar("Port Toolbar"),

    openAction("Open", this),

    loadPortListAction("↺", this)

{

    ui->setupUi(this);

    serialPort = port;

        if (serialPort->isOpen())

        {

            togglePort();

            // open new selection by toggling

            togglePort();

        }

    }

}

QString PortControl::selectedPortName()

{

    QString portText = ui->cbPortList->currentText();

    int portIndex = portList.indexOf(portText);

    if (portIndex < 0) // not in the list yet

    {

        // return the displayed name as port name

        return portText;

    }

    else

    {

        // get the port name from the 'port list'

        return static_cast<PortListItem*>(portList.item(portIndex))->portName();

    }

}

QToolBar* PortControl::toolBar()

{

    return &portToolBar;

}

void PortControl::openActionTriggered(bool checked)

{

    togglePort();

}

void PortControl::onCbPortListActivated(int index)

{

    tbPortList.setCurrentIndex(index);

}

void PortControl::onTbPortListActivated(int index)

{

    ui->cbPortList->setCurrentIndex(index);

}

void PortControl::onPortError(QSerialPort::SerialPortError error)

{

    switch(error)

    {

        case QSerialPort::NoError :

            break;

        case QSerialPort::ResourceError :

            qWarning() << "Port error: resource unavaliable; most likely device removed.";

            if (serialPort->isOpen())

            {

                qWarning() << "Closing port on resource error: " << serialPort->portName();

                togglePort();

            }

            loadPortList();

            break;

        case QSerialPort::DeviceNotFoundError:

            qCritical() << "Device doesn't exists: " << serialPort->portName();

            break;

        case QSerialPort::PermissionError:

            qCritical() << "Permission denied. Either you don't have \

required privileges or device is already opened by another process.";

            break;

        case QSerialPort::OpenError:

            qWarning() << "Device is already opened!";

            break;

        case QSerialPort::NotOpenError:

            qCritical() << "Device is not open!";

            break;

        case QSerialPort::ParityError:

            qCritical() << "Parity error detected.";

            break;

        case QSerialPort::FramingError:

            qCritical() << "Framing error detected.";

            break;

        case QSerialPort::BreakConditionError:

            qCritical() << "Break condition is detected.";

            break;

        case QSerialPort::WriteError:

            qCritical() << "An error occurred while writing data.";

            break;

        case QSerialPort::ReadError:

            qCritical() << "An error occurred while reading data.";

            break;

        case QSerialPort::UnsupportedOperationError:

            qCritical() << "Operation is not supported.";

            break;

        case QSerialPort::TimeoutError:

            qCritical() << "A timeout error occurred.";

            break;

        case QSerialPort::UnknownError:

            qCritical() << "Unknown error! Error: " << serialPort->errorString();

            break;

        default:

            qCritical() << "Unhandled port error: " << error;

            break;

    }

}

void PortControl::updatePinLeds(void)

{

    auto pins = serialPort->pinoutSignals();

    ui->ledDCD->setOn(pins & QSerialPort::DataCarrierDetectSignal);

    ui->ledDSR->setOn(pins & QSerialPort::DataSetReadySignal);

    ui->ledRI->setOn(pins & QSerialPort::RingIndicatorSignal);

    ui->ledCTS->setOn(pins & QSerialPort::ClearToSendSignal);

}

QString PortControl::currentParityText()

{

    return paritySettingMap.value(

        (QSerialPort::Parity) parityButtons.checkedId());

}

QString PortControl::currentFlowControlText()

{

    if (flowControlButtons.checkedId() == QSerialPort::HardwareControl)

    {

        return "hardware";

    }

    else if (flowControlButtons.checkedId() == QSerialPort::SoftwareControl)

    {

        return "software";

    }

    else // no parity

    {

        return "none";

    }

}

void PortControl::saveSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_Port);

    settings->setValue(SG_Port_SelectedPort, selectedPortName());

    settings->setValue(SG_Port_BaudRate, ui->cbBaudRate->currentText());

    settings->setValue(SG_Port_Parity, currentParityText());

    settings->setValue(SG_Port_DataBits, dataBitsButtons.checkedId());

    settings->setValue(SG_Port_StopBits, stopBitsButtons.checkedId());

    settings->setValue(SG_Port_FlowControl, currentFlowControlText());