#include "src/ATBAPP/ATBDeviceControllerPlugin.h"
#include "src/ATBAPP/ATBHealthEvent.h"
#include "src/ATBAPP/ATBMachineEvent.h"
#include "src/ATBAPP/Utils.h"

#include <QTimer>
#include <QTextCodec>
#include <QDebug>

#include <QPluginLoader>
#include <QDateTime>
#include <QFileInfo>
#include <QCoreApplication>
#include <QUuid>

#include <cstdlib>



ATBDeviceControllerPlugin::ATBDeviceControllerPlugin(QObject *parent)
    : pluginState(PLUGIN_STATE::NOT_INITIALIZED)
    , eventReceiver(nullptr)
{
    this->setParent(parent);

    this->pluginInfo = QString::fromUtf8(pluginInfoString.c_str());

    if (!this->private_loadCashAgentLib("")) {
        return;
    }

    //connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_templatePrintFinished_OK()),  this, SLOT(onPrintFinishedOK()),  Qt::QueuedConnection);
    //connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_templatePrintFinished_Err()), this, SLOT(onPrintFinishedERR()), Qt::QueuedConnection);

    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_gotNewCoin()),       this, SLOT(onCashGotCoin()),                Qt::QueuedConnection);
    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByMax()),     this, SLOT(onCashPayStopByMax()),           Qt::QueuedConnection);
    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByEscrow()),  this, SLOT(onCashPayStopByEscrow()),        Qt::QueuedConnection);
    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByError()),   this, SLOT(onCashPayStopByError()),         Qt::QueuedConnection);
    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_payStopByTimeout()), this, SLOT(onCashPayStopByTimeout()),       Qt::QueuedConnection);

    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorServiceDoorOpened()),     this, SLOT(onServiceDoorOpened()), Qt::QueuedConnection);  // switch to ModeSERVICE
    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorVaultDoorOpened()),       this, SLOT(onVaultDoorOpened()),   Qt::QueuedConnection);    // Screen?? with message
    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorCoinBoxRemoved()),        this, SLOT(onCoinBoxRemoved()),    Qt::QueuedConnection);     // Create/Send Account
    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorCoinBoxInserted()),       this, SLOT(onCoinBoxInserted()),   Qt::QueuedConnection);
    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorCBinAndAllDoorsClosed()), this, SLOT(onCBinAndAllDoorsClosed()), Qt::QueuedConnection);
    connect(dynamic_cast<QObject*>(hw), SIGNAL(hwapi_doorAllDoorsClosed()),        this, SLOT(onAllDoorsClosed()),    Qt::QueuedConnection);     // check for errors, switch to mode IDLE


    this->diag = new DeviceControllerDiag(this);


    this->currentSelectedTicketType = 0;
    this->currentCashState = CASH_STATE::CACHE_EMPTY;
}

ATBDeviceControllerPlugin::~ATBDeviceControllerPlugin() {}

PLUGIN_STATE ATBDeviceControllerPlugin::initDCPlugin(QObject *eventReceiver, const QSettings & settings)
{
    this->eventReceiver = eventReceiver;

    // read variables from setting
    QString serialPort = settings.value("DEVICE_CONTROLLER/serialPort", "ttymxc2").toString();
    QByteArray printerEncoding = settings.value("DEVICE_CONTROLLER/printerEnconding", "ISO 8859-2").toString().toLatin1();

    // open serial port
    hw->dc_openSerial(5, "115200", serialPort, 1);

    hw->dc_autoRequest(true);

    hw->rtc_setDateTime();

    // this is necessary to init the CashAgentLib (!)
    hw->vend_failed();


    // text encoding for printer
    this->codec = QTextCodec::codecForName(printerEncoding);

    this->diag->init(this->hw, this->eventReceiver);

    this->pluginState = PLUGIN_STATE::INITIALIZED;

    return pluginState;
}


// Handle Mode-Changes --------------------------------------------------------

void ATBDeviceControllerPlugin::onChangedProgramModeToSELL()
{
    //hw->dc_autoRequest(true);
}

void ATBDeviceControllerPlugin::onChangedProgramModeToSERVICE()
{
    //hw->dc_autoRequest(true);
}

void ATBDeviceControllerPlugin::onChangedProgramModeToIDLE()
{
    //hw->dc_autoRequest(false);  // <-- TODO: ???
}

void ATBDeviceControllerPlugin::onChangedProgramModeToOOO()
{

}


// TASKS: Cash handling -------------------------------------------------------
void ATBDeviceControllerPlugin::requestStartCashInput(const QString & amount)
{
    qCritical() << "Start Cash vending with amount = " << amount;

    uint32_t amountInt = static_cast<uint32_t>(amount.toUInt());

    if (amountInt == 0) amountInt = UINT_MAX;

    hw->cash_startPayment(amountInt);
}

void ATBDeviceControllerPlugin::requestStopCashInput()
{
    hw->cash_stopPayment();

    // we need new cash value in application...
    QTimer::singleShot(500, this, SLOT(onCashPayStopedSuccess()));
}

void ATBDeviceControllerPlugin::cashCollect()
{
    hw->vend_success();
    this->currentCashState = CASH_STATE::CACHE_EMPTY;
}

void ATBDeviceControllerPlugin::cashAbort()
{
    hw->vend_failed();
    this->currentCashState = CASH_STATE::CACHE_EMPTY;
}

// TASKS: Account -------------------------------------------------------------

// for an external account request, e.g. by an ui-button:
void ATBDeviceControllerPlugin::requestAccount()
{
    qCritical() << "ATBDeviceControllerPlugin::requestAccount()";

    this->private_startAccount();
}

void ATBDeviceControllerPlugin::private_startAccount()
{
    uint16_t backupedAccNumbers[8];    // array of account numbers
    uint8_t nrOfVals;                  // number of saved accounts

    // it is not defined which one is the latest account
    hw->log_getHoldAccountNumbers(&nrOfVals, backupedAccNumbers);

    // DEBUG
    qCritical() << "Start account: ";
    qCritical() << "                  nrOfVals = " << nrOfVals;
    for (int i=0; i<nrOfVals; ++i) {
        qCritical() << "      backupedAccNumbers[" << i << "] = " << backupedAccNumbers[0];
    }

    qsort( backupedAccNumbers, nrOfVals, sizeof (uint16_t), Utils::compare );

    uint16_t latestAccountNumber = backupedAccNumbers[nrOfVals-1];


    // DEBUG
    qCritical() << "       latestAccountNumber = " << latestAccountNumber;

    hw->log_selectVaultRecord(latestAccountNumber);

    this->accountCheckCounter = 0;
    QTimer::singleShot(500, this, SLOT(private_checkAccountData()));
}

void ATBDeviceControllerPlugin::private_checkAccountData()
{
    // DEBUG
    qCritical() << "      --> private_checkAccountData()";

    if (hw->log_chkIfVaultRecordAvailable()) {
        this->private_getAccountData();
    }
    else {
        if (this->accountCheckCounter < 10) {
            this->accountCheckCounter++;
            QTimer::singleShot(500, this, SLOT(private_checkAccountData()));
        }
        else {
            // cannot get accountData within ~10*500ms
            qCritical() << "checkAccountData() failed";

            // TODO: create and send an HealthEvent...
        }
    }
}


void ATBDeviceControllerPlugin::private_getAccountData()
{
    // DEBUG
    qCritical() << "      --> private_getAccountData()";

    struct T_vaultRecord retVR;

    hw->log_getVaultRecord(&retVR);

    QHash<QString, QVariant> accountData;

    accountData.insert("AccountingNumber", QString::number(retVR.AccountingNumber));

    int numberOfCoinVariants = sizeof(retVR.coinsInVault);

    // limit numberOfCoinVariants:
    if (numberOfCoinVariants > 16) { numberOfCoinVariants = 16; }

    accountData.insert("NumberOfCoinVariants", numberOfCoinVariants);
    for (int i = 0; i < numberOfCoinVariants; ++i) {
        accountData.insert("COIN_" + QString::number(i) + "_Quantity",  retVR.coinsInVault[i]);
        accountData.insert("COIN_" + QString::number(i) + "_Value",     retVR.coinDenomination[i]);

        // DEBUG
        qCritical() << "COIN_" + QString::number(i) + "_Quantity = " << accountData["COIN_" + QString::number(i) + "_Quantity"];
        qCritical() << "COIN_" + QString::number(i) + "_Value    = " << accountData["COIN_" + QString::number(i) + "_Value"];
    }

    emit requestAccountResponse(accountData);
}


// Door Events / Hardware contacts --------------------------------------------
void ATBDeviceControllerPlugin::onServiceDoorOpened()
{
    qCritical() << "ATBDeviceControllerPlugin::onServiceDoorOpened()";

    // switch to mode service
    emit this->requestModeSERVICE();

    // TODO:
    // - create an HealthEvent (-> ISMAS-Event)
}

void ATBDeviceControllerPlugin::onVaultDoorOpened()
{
    // TODO:
    // - show special screen / message on screen
    // - create an HealthEvent (-> ISMAS-Event)
    qCritical() << "ATBDeviceControllerPlugin::onVaultDoorOpened()";

    // TODO: Start background task "ACCOUNT"

    // do not: emit this->requestModeSERVICE();
}

void ATBDeviceControllerPlugin::onCoinBoxRemoved()
{
    qCritical() << "ATBDeviceControllerPlugin::onCoinBoxRemoved()";

    this->private_startAccount();
}

void ATBDeviceControllerPlugin::onCoinBoxInserted()
{
    qCritical() << "ATBDeviceControllerPlugin::onCoinBoxInserted()";
}

void ATBDeviceControllerPlugin::onCBinAndAllDoorsClosed()
{
    qCritical() << "ATBDeviceControllerPlugin::onCBinAndAllDoorsClosed()";

    this->diag->diagRequest();

    // TODO: Stop background task "ACCOUNT"

    QTimer::singleShot(2000, this, SIGNAL(requestModeIDLE()));
}


void ATBDeviceControllerPlugin::onAllDoorsClosed()
{
    qCritical() << "ATBDeviceControllerPlugin::onAllDoorsClosed()";

    emit this->requestModeIDLE();
}


// TASKS: printing ------------------------------------------------------------
void ATBDeviceControllerPlugin::requestPrintTicket(const QHash<QString, QVariant> & printingData)
{
    struct T_dynDat *dynTicketData = new T_dynDat;
    memset(dynTicketData, 0, sizeof(*dynTicketData));

    qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket( "         << endl
                << "     licenseplate = " << printingData["licenseplate"]    << endl
                << "           amount = " << printingData["amount"]          << endl
                << "       parkingEnd = " << printingData["parkingEnd"]      << endl
                << "  currentDateTime = " << printingData["currentDateTime"] << endl;

    QDateTime parkingEndDateTime = QDateTime::fromString(printingData["parkingEnd"].toString(),  Qt::ISODate);
    QDateTime currentDateTime    = QDateTime::fromString(printingData["currentDateTime"].toString(), Qt::ISODate);

    /* -----------------------------------------------------------------------------------------
     * note: the following highly depends on printer template files!
     * -----------------------------------------------------------------------------------------
     */

    // set dynamic printer data:
    QByteArray ba_licenseplate = codec->fromUnicode(printingData["licenseplate"].toString());
    memcpy((char*)dynTicketData->licensePlate, ba_licenseplate.data(), std::min(ba_licenseplate.size(),8));

    QByteArray ba_amount = codec->fromUnicode(printingData["amount"].toString());
    memcpy((char*)dynTicketData->vendingPrice,  ba_amount.data(), std::min(ba_amount.size(),8));

    QByteArray ba_parkingEndTime = codec->fromUnicode(parkingEndDateTime.toString("hh:mm"));
    memcpy((char*)dynTicketData->parkingEnd,  ba_parkingEndTime.data(), std::min(ba_parkingEndTime.size(),8));

    QByteArray ba_parkingEndDate = codec->fromUnicode(parkingEndDateTime.toString("dd.MM.yy"));
    memcpy((char*)dynTicketData->currentTime,  ba_parkingEndDate.data(), std::min(ba_parkingEndDate.size(),8));
    // ! and yes... 'ParkingEndDate' is 'currentTime'

    QByteArray ba_currentDate = codec->fromUnicode(currentDateTime.toString("dd.MM.yy"));
    memcpy((char*)dynTicketData->currentDate,  ba_currentDate.data(), std::min(ba_currentDate.size(),8));


    // DEBUG
    /*
    uint8_t* buf = dynTicketData->licensePlate;
    int length = 64;
    for (int i = 0; i < length; ++i) {
            fprintf(stderr, "%d %02x %c\n", i, buf[i], buf[i]);
    }
    fprintf(stderr, "\n");
    */

    // DEBUG
    qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket()";

    if (!this->hw->dc_isPortOpen()) {
        qCritical() << "    ... serial port is not open!";
        this->onPrintFinishedERR();
        return;
    }


    // TODO: wird hier nur 'licensePlate' gedruckt?
    if (!this->hw->prn_sendDynamicPrnValues(dynTicketData->licensePlate)) {
        this->errorCode = "hwapi::prn_sendDynamicPrnValues";
        this->errorDescription = "hwapi method 'hwapi::prn_sendDynamicPrnValues' result is false";

        qCritical() << "ERROR:";
        qCritical() << "ATBDeviceControllerPlugin::requestPrintTicket( "        << endl
                    << "     licenseplate = " << printingData["licenseplate"]   << endl
                    << "           amount = " << printingData["amount"]         << endl
                    << "       parkingEnd = " << printingData["parkingEnd"]     << endl
                    << "      currentTime = " << printingData["currentTime"]    << endl
                    << "      currentDate = " << printingData["currentDate"]    << endl;


        this->onPrintFinishedERR();
        return;
    }

    // set ticket type:
    //      00281 - Szeged:
    //          1 - Cash / ShortTimeParking
    //          2 - Card / ShortTimeParking
    //          3 - Cash / DayTicket
    //          4 - Card / DayTicket
    QString paymentType = printingData["paymentType"].toString(); // must be "CASH" | "CARD"
    QString productName = printingData["product"].toString();     // must be "ShortTimeParking" | "DayTicket"

    if ( (paymentType == "CASH") && (productName == "ShortTimeParking") ) {
        this->currentSelectedTicketType = 1;
    }
    else
    if ( (paymentType == "CARD") && (productName == "ShortTimeParking") ) {
        this->currentSelectedTicketType = 2;
    }
    else
    if ( (paymentType == "CASH") && (productName == "DayTicket") ) {
        this->currentSelectedTicketType = 3;
    }
    else
    if ( (paymentType == "CARD") && (productName == "DayTicket") ) {
        this->currentSelectedTicketType = 4;
    }
    else {
        qCritical() << "ERROR: requestPrintTicket(): invalid payment data:";
        qCritical() << "       paymentType = " << paymentType   << endl
                    << "       productName = " << productName   << endl;
        this->onPrintFinishedERR();
        return;
    }

    QTimer::singleShot(1000, this, SLOT(onPrinterDataPrepared()));
}



void ATBDeviceControllerPlugin::onPrinterDataPrepared()
{
    this->hw->prn_printKombiticket(this->currentSelectedTicketType);

    // note: calling prn_getPrintResult() immediately may result in wrong answer!
    // We have to wait "about some seconds" until calling this function!
    QTimer::singleShot(4000, this, SLOT(onPrinterWaitForPrinting()));

    // old: use printer templates:
    // this->currentTemplate = 1;
    // this->onPrinterPrintNextTemplate();
}

void ATBDeviceControllerPlugin::onPrinterWaitForPrinting()
{
    quint8 printerResult = this->hw->prn_getPrintResult();

    switch (printerResult) {
    case 0:    // still printing
        qCritical() << "--> printer: WaitForPrinting";
        QTimer::singleShot(2000, this, SLOT(onPrinterWaitForPrinting()));
        break;
    case 1:    // printing finished, Ok
        this->onPrintFinishedOK();
        break;
    case 2:    // printing finished, Error
        this->onPrintFinishedERR();
        break;
    default:
        qCritical() << "DC Error: wait for printing";
        this->onPrintFinishedERR();
        break;
    }

}


void ATBDeviceControllerPlugin::onPrinterPrintNextTemplate()
{
    qCritical() << "     ... print template " << this->currentTemplate;

    if (!this->hw->prn_printTemplate(this->currentTemplate)) {
        this->errorCode = "hwapi::prn_printTemplate";
        this->errorDescription = QString("hwapi method 'hwapi::onPrinterPrintNextTemplate(%1)' result is false").arg(this->currentTemplate);
        this->onPrintFinishedERR();
        return;
    }

    if (this->currentTemplate >= 3) {
        // all templates are printed
        this->currentTemplate = 0;

        // FAKE SIGNAL:
        QTimer::singleShot(500, this, SLOT(onPrintFinishedOK()));
    }
    else {
        // print next template
        this->currentTemplate++;
        QTimer::singleShot(2000, this, SLOT(onPrinterPrintNextTemplate()));
    }

}


/************************************************************************************************
 * private slots, interface to low level hwapi
 *
 */
void ATBDeviceControllerPlugin::onPrintFinishedOK()
{
    // DEBUG
    qCritical() << "ATBDeviceControllerPlugin::onPrintFinishedOK()";

    emit this->printTicketFinished(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
                                   // TODO: TicketNumber
                                   "",
                                   "");
}
void ATBDeviceControllerPlugin::onPrintFinishedERR()
{
    // DEBUG
    qCritical() << "ATBDeviceControllerPlugin::onPrintFinishedERR()";


    this->errorCode = "PRINTER";               // TODO: get more detailed error code from low level API
    this->errorDescription = "Printer error";  // TODO: get more detailed error description from low level API

    emit this->printTicketFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
                                   this->errorCode,
                                   this->errorDescription);
}



/************************************************************************************************
 * cash payment
 */
void ATBDeviceControllerPlugin::onCashGotCoin()
{
    // DEBUG
    qCritical() << "ATBDeviceControllerPlugin::onGotCoin()";

    this->currentCashState = CASH_STATE::CACHE_INPUT;

    uint32_t amountInt = this->hw->getInsertedAmount();

    QString amountString = QString::number(amountInt);


    emit this->cashInputEvent(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
                              nsDeviceControllerInterface::CASH_STATE::CACHE_INPUT,
                              amountString,
                              "",
                              "");
}


void ATBDeviceControllerPlugin::onCashPayStopByMax()
{
    // DEBUG
    qCritical() << "ATBDeviceControllerPlugin::onCashVendStopByMax()";

    // we need new cash value in application...
    QTimer::singleShot(500, this, SLOT(onCashPayStopedSuccess()));

}

void ATBDeviceControllerPlugin::onCashPayStopByEscrow()
{
    // DEBUG
    qCritical() << "ATBDeviceControllerPlugin::onCashPayStopByEscrow()";

    uint32_t amountInt = this->hw->getInsertedAmount();

    QString amountString = QString::number(amountInt);

    emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
                              amountString,
                              "",
                              "");
}

void ATBDeviceControllerPlugin::onCashPayStopByError()
{
    // DEBUG
    qCritical() << "ATBDeviceControllerPlugin::onCashPayStopByError()";

    uint32_t amountInt = this->hw->getInsertedAmount();

    QString amountString = QString::number(amountInt);

    emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
                              amountString,
                              "",
                              "");
}

void ATBDeviceControllerPlugin::onCashPayStopByTimeout()
{
    // DEBUG
    qCritical() << "ATBDeviceControllerPlugin::onCashPayStopByTimeout()";

    uint32_t amountInt = this->hw->getInsertedAmount();

    QString amountString = QString::number(amountInt);

    emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND,
                              amountString,
                              "",
                              "");
}

void ATBDeviceControllerPlugin::onCashPayStopedSuccess()
{
    // DEBUG
    qCritical() << "ATBDeviceControllerPlugin::onCashPayStoped()";

    uint32_t amountInt = this->hw->getInsertedAmount();

    QString amountString = QString::number(amountInt);

    qCritical() << "      insertedAmount (int) = " << amountInt;
    qCritical() << "            insertedAmount = " << amountString;

    emit this->cashInputFinished(nsDeviceControllerInterface::RESULT_STATE::SUCCESS,
                              amountString,
                              "",
                              "");
}



/**
 * Load CashAgentLib
 * @brief ATBDeviceControllerPlugin::private_loadCashAgentLib
 * @param pluginName
 * @return
 */
bool ATBDeviceControllerPlugin::private_loadCashAgentLib(QString pluginName)
{
    if (pluginName == "") {

        // search list for plugin (.so) file:
        QStringList pluginNameList;
        pluginNameList << "/usr/lib/libCAmaster.so"
                       << "/usr/lib/libCashAgentLib.so";
        // using C++11 range based loop:
        for (const auto& filename : pluginNameList) {
            if (QFileInfo(filename).isReadable()) {
                pluginName = filename;
                break;
            }
        }

        if (pluginName == "") {
            qCritical() << "ATBDeviceControllerPlugin: CashAgentLib not installed!";
            this->errorCode = "CashAgentLib::NOT_FOUND";
            this->errorDescription = "ERROR: no CashAgentLib: ";
            return false;
        }

    }

    if (!QLibrary::isLibrary(pluginName)) {
        qCritical() << "ATBDeviceControllerPlugin: can not load CashAgentLib: " << pluginName;
        this->errorCode = "CashAgentLib::NO_LIBRARY";
        this->errorDescription = "ERROR: can not load CashAgentLib: " + pluginName;
        return false;
    }

    QPluginLoader* pluginLoader = new QPluginLoader();
    pluginLoader->setFileName(pluginName);

    QObject* plugin = pluginLoader->instance();
    if (!pluginLoader->isLoaded()) {
        qCritical() << "ATBDeviceControllerPlugin: can not instantiate CashAgentLib: " << pluginName;
        qCritical() << "               error: " << pluginLoader->errorString();
        this->errorCode = "CashAgentLib::NO_INSTANCE";
        this->errorDescription = "ERROR: can not instantiate CashAgentLib: " + pluginName;
        return false;
    }

    if (plugin == nullptr) {
        qCritical() << "ATBDeviceControllerPlugin: plugin is NULL";
        this->errorCode = "CashAgentLib::INSTANCE_IS_NULL";
        this->errorDescription = "ERROR: CashAgentLib instance is NULL: " + pluginName;
    }

    qCritical() << "ATBDeviceControllerPlugin: instantiate CashAgentLib: " << pluginName;

    this->hw = qobject_cast<hwinf*>(plugin);

    if (this->hw == nullptr) {
        qCritical() << "ATBDeviceControllerPlugin: hw is NULL";
        this->errorCode = "CashAgentLib::HW_IS_NULL";
        this->errorDescription = "ERROR: CashAgentLib object_cast is NULL: " + pluginName;
        return false;
    }

    qCritical() << "ATBDeviceControllerPlugin: loaded CashAgentLib";

    return true;
}



/************************************************************************************************
 * Mandatory plugin methods
 *
 */

PLUGIN_STATE ATBDeviceControllerPlugin::getState()
{
    return this->pluginState;
}

QString & ATBDeviceControllerPlugin::getLastError()
{
    return this->errorCode;
}

const QString & ATBDeviceControllerPlugin::getLastErrorDescription()
{
    return this->errorDescription;
}

const QString & ATBDeviceControllerPlugin::getPluginInfo()
{
    return this->pluginInfo;
}


const QString ATBDeviceControllerPlugin::getString(nsDeviceControllerInterface::RESULT_STATE resultState)
{
    QString str;

    switch (resultState) {
    case nsDeviceControllerInterface::RESULT_STATE::SUCCESS:
        str = QString("RESULT_STATE::SUCCESS");
        break;
    case nsDeviceControllerInterface::RESULT_STATE::ERROR_BACKEND:
        str = QString("RESULT_STATE::ERROR_BACKEND");
        break;
    case nsDeviceControllerInterface::RESULT_STATE::ERROR_TIMEOUT:
        str = QString("RESULT_STATE::ERROR_TIMEOUT");
        break;
    case nsDeviceControllerInterface::RESULT_STATE::ERROR_PROCESS:
        str = QString("RESULT_STATE::ERROR_PROCESS");
        break;
    case nsDeviceControllerInterface::RESULT_STATE::ERROR_RETRY:
        str = QString("RESULT_STATE::ERROR_RETRY");
        break;
    case nsDeviceControllerInterface::RESULT_STATE::INFO:
        str = QString("RESULT_STATE::INFO");
        break;
    }
    return str;

}



/************************************************************************************************
 * ... end
 */

#if QT_VERSION < 0x050000
Q_EXPORT_PLUGIN2( ATBDeviceControllerPlugin, ATBDeviceControllerPlugin )
#endif