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

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

#include <QPluginLoader>
#include <QDateTime>


ATBDeviceControllerPlugin::ATBDeviceControllerPlugin(QObject *parent) : QObject(parent),
    pluginState(PLUGIN_STATE::NOT_INITIALIZED)
{
    this->pluginInfo = QString::fromUtf8(pluginInfoString.c_str());

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




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

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

}

ATBDeviceControllerPlugin::~ATBDeviceControllerPlugin() {}

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

    // 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();


    hw->dc_autoRequest(true);

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


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



    this->pluginState = PLUGIN_STATE::INITIALIZED;

    return pluginState;
}


// 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();
}

void ATBDeviceControllerPlugin::cashCollect()
{
    hw->vend_success();
}

void ATBDeviceControllerPlugin::cashAbort()
{
    hw->vend_failed();
}

// TASKS: Account -------------------------------------------------------------
void ATBDeviceControllerPlugin::requestAccount()
{
    qCritical() << "TODO: implement ATBDeviceControllerPlugin::requestAccount()";
}


// 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;
    }

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



void ATBDeviceControllerPlugin::onPrinterDataPrepared()
{
    this->currentTemplate = 1;
    this->onPrinterPrintNextTemplate();
}


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,
                                   "",
                                   "");
}
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()";

    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()";

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

    QString amountString = QString::number(amountInt);

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

}

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,
                              "",
                              "");
}


bool ATBDeviceControllerPlugin::private_loadCashAgentLib(QString pluginName)
{
    if (pluginName == "") {
        pluginName = "/usr/lib/libCashAgentLib.so";
    }

    if (!QLibrary::isLibrary(pluginName)) {
        qCritical() << "ATBDeviceControllerPlugin: can not load CashAgentLib: " << pluginName;
        this->errorCode = 5;
        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;
        this->errorCode = 6;
        this->errorDescription = "ERROR: can not instantiate CashAgentLib: " + pluginName;
        return false;
    }

    if (plugin == nullptr) {
        qCritical() << "ATBDeviceControllerPlugin: plugin is NULL";
    }

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

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

    if (this->hw == nullptr) {
        qCritical() << "ATBDeviceControllerPlugin: hw is NULL";
    }

    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