#include "runProc.h"
#include <QDebug>
#include "controlBus.h"
#include "dcBL.h"
#include "interfaces.h"

static uint32_t hwapi_lastStartAmount;
static uint32_t hwapi_lastTotalAmount;
static uint8_t  hwapi_cash_lastCollectionState;
static uint8_t  hwapi_paymentStarted;
static uint8_t  hwapi_lastDoorState;
static uint8_t  bl_startupStep;



T_runProc::T_runProc()
{

    hwapi_TimerPayment = new QTimer();
    hwapi_TimerPayment->setSingleShot(true);

    hwapi_lastStartAmount=0;
    hwapi_lastTotalAmount=0;
    hwapi_cash_lastCollectionState=0;
    hwapi_paymentStarted=0;
    hwapi_lastDoorState=0;
    bl_startupStep=0;

    QTimer *runProc_callProcesses = new QTimer();
    connect(runProc_callProcesses, SIGNAL(timeout()), this, SLOT(runProc_slotProcess()));
    runProc_callProcesses->setSingleShot(false);
    runProc_callProcesses->start(100);     // in ms

    hwapi_lastDoorState=0;      // default: all doors (should be) closed, coin box inserted
        // bit0: upper door  1:middle 2:lower  3=cash-box out

    hwapi_triggerBL = new QTimer();
    connect(hwapi_triggerBL, SIGNAL(timeout()), this, SLOT(bl_performComplStart()));
    hwapi_triggerBL->setSingleShot(false);
    hwapi_triggerBL->stop();

}


void T_runProc::runProc_slotProcess(void)
{
    cash_paymentProcessing();
    doors_supervise();
    dcBL_cycle();

}

bool T_runProc::cash_startPayment(uint32_t amount)
{
    uint8_t dat1, dat2, dat3, dat4;

    hwapi_lastStartAmount=amount;
    epi_clearCurrentPayment();
    dat1=ulong2uchar(amount, 0);
    dat2=ulong2uchar(amount, 1);
    dat3=ulong2uchar(amount, 2);
    dat4=ulong2uchar(amount, 3);
    hwapi_cash_lastCollectionState=0;
    sendFDcmd_set(155, 0,0, dat1,dat2,dat3,dat4);
        // wird im DC auf 65500 gesetzt wenn 0 (Maximalwert 0 macht keinen Sinn!)

    hwapi_paymentStarted=1;

    hwapi_TimerPayment->start(5000);     // in ms
    hwapi_lastTotalAmount=0;
    epi_setNowCoinPay(true);    // new since 20.9.23
    qDebug() << "payment started with " << amount ;
    return true;

}

uint8_t T_runProc::cash_paymentProcessing(void)
{
    // run this function periodically while coin payment process to generate necessary signals:

    // am 5.10.23 umgebaut, geht jetzt auch fuer MW. Für EMP und MW getestet

    // 12.10.23:  epi_store64BdevParameter() MUSS vorher aufgerufen werden zur Unterscheidung EMP / MW !!!!!

    // return value:
    // 0: stopped   1: starting up   2: coin collection
    // 3: finished by User (Push button)  4: finished, Max-Value collected
    // 5: finished by escrow
    // 6: money encashed
    // 7: cancelled
    // 10,11: error cannot start
    // 12: timeout while payment, coins returned
    // 13: stopped by unexpected error

    struct T_emp empStat;
    struct T_changer chgrStat;

    struct T_dynamicCondition myDynMachCond;
    struct T_devices devParameter;

    uint8_t collActiv=0, payInProg, empState, kcc;
    uint32_t newSum;

    if (hwapi_paymentStarted<1)
        return 0;       // off

    collActiv=1;    // starting up payment
    devParameter.kindOfCoinChecker=0;
    restoreDeviceParameter(&devParameter);
    kcc=devParameter.kindOfCoinChecker;
    /*
            buf66[0]=devPara.kindOfPrinter;
            buf66[1]=devPara.kindOfCoinChecker;
            buf66[2]=devPara.kindOfMifareReader;
            buf66[3]=devPara.suppressSleepMode;
            buf66[4]=devPara.kindOfModem;
            buf66[5]=devPara.kindOfCreditcard;
            buf66[6]=devPara.CoinEscrow;
            buf66[7]=devPara.CoinRejectUnit;
            buf66[8]=devPara.CoinShutter;
            buf66[9]=devPara.BillAcceptor;
            buf66[10]=devPara.usevaultLock;
            buf66[11]=devPara.autoAlarm;
            buf66[12]=devPara.autoOpen;
            buf66[13]=devPara.printAccReceipt;
            buf66[14]=devPara.printDoorReceipt;
            buf66[15]=devPara.printTokenTicket;
            uitmp=devPara.VaultFullWarnLevel;
            buf66[16]=swl_getOneByteFromUint(uitmp, GETLOWBYT);
            buf66[17]=swl_getOneByteFromUint(uitmp, GETHIGHBYT);
            uitmp=devPara.VaultFullErrorLevel;
            buf66[18]=swl_getOneByteFromUint(uitmp, GETLOWBYT);
            buf66[19]=swl_getOneByteFromUint(uitmp, GETHIGHBYT);

*/
    if (kcc<3)
    {
        sub_emp_getAllParameters(&empStat);
        empState=empStat.state;
    } else
    {
        changer_getAllParameters(&chgrStat);
        empState=chgrStat.state;
    }

        // 0=start command
        // 1=powered, do emp ini, send reset
        // 2=delay
        // 3=wait for response, requesting status after response
        // 4,5 through, startup
        // 6: wait for status
        // 7: through, startup
        // 8: IDLE state.   EMP is up and ready, polling is running
        // 9: polling on, payment not yet on
        // 10: payment, check coins
        // 11: through
        // 12: wait 1s for last coin
        // 90: stop all, 1s delay
        // 99: off, all stopped

    sub_getDynMachineConditions(&myDynMachCond);
    payInProg= myDynMachCond.paymentInProgress;
    //	0: stopped by timeout
    //  1: running  2: wait4lastCoin
    //				3: payment stopped manually, coins in Escrow
    //			    4: payment stopped autom, amount collected, coins in Escrow
    //			    5: payment stopped, escrow full, coins in Escrow
    //			    6: coins encashed
    //              7: coins returned 2 cases: due to cancel-button or printer-error
    //				8: CoinChecker or MDB on Error

//    qCritical() << "emitting signal payCancelled";
//    emit runProc_payCancelled();

    if (payInProg==8)
    {
        // coin checker faulty, cannot start
        if (hwapi_paymentStarted==1)
        {
            hwapi_paymentStarted=90;    // stop due to error
            qCritical() << "emitting signal coinCollectionAborted 1";
            emit runProc_coinCollectionAborted();
            //sendFDcmd_set(156, 0,0, 2,0,0,0);       // cancel payment
        }

        return 10;    // error cannot start
    }

    if (empState>=10 && empState<=12 && (payInProg==1 || payInProg==2)  )
    {
        // coin acceptance is active now:
        if (hwapi_paymentStarted==1)    // && (( payInProg==0) || ( payInProg>5)))     //16.6.23
        {                                              // 1=wait for coin checker being ready
            hwapi_paymentStarted=2;     // coins can be inserted now
            qCritical() << "emitting signal coinCollectionJustStarted";
            emit runProc_coinCollectionJustStarted();
        }
    }

    if (hwapi_paymentStarted==2)
    {
        // coins can be inserted now, wait for end
        collActiv=2;    // coin collection active

        newSum=epi_CurrentPaymentGetAmount();
        if (newSum>hwapi_lastTotalAmount)
        {
            hwapi_lastTotalAmount=newSum;
            qCritical() << "emitting signal gotNewCoin";
            emit runProc_gotNewCoin();
        }

        if (payInProg==0)   // timeout, coins returned by DC
        {
            hwapi_paymentStarted=90;
            collActiv=12;   // stop by timeout
            qCritical() << "emitting signal payStopByTimeout";
            emit runProc_payStopByTimeout();

        } else

        if (payInProg==3)   // user pressed "Next/Continue", keep coin
        {
            hwapi_paymentStarted++;
            collActiv=3;
            qCritical() << "emitting signal payStopByPushbutton 1";
            emit runProc_payStopByPushbutton();
        } else

        if (payInProg==4)   // max achieved, keep coins
        {
            hwapi_paymentStarted++;
            collActiv=4;
            qCritical() << "emitting signal payStopByMax";
            emit runProc_payStopByMax();
        } else

        if (payInProg==5)   // escrow full, keep coins
        {
            hwapi_paymentStarted++;
            collActiv=5;
            qCritical() << "emitting signal payStopByEscrow";
            emit runProc_payStopByEscrow();
        }

        /* 5.10.23 raus, geht auf 99 wenn Betrag erreicht, ist aber kein fehler
        if ( (empState<10) || (empState>12)) // error
        {
            collActiv=13;
            hwapi_paymentStarted=90;
            qCritical() << "emitting signal payStopByError" << empState;
            emit runProc_payStopByError();
        }  */

    }

    if (hwapi_paymentStarted==3)
    {
        // coin collection finished, but coins kept until printing done
        collActiv=2;
        if (payInProg==6)   // coins encashed
        {
            collActiv=6;
            hwapi_paymentStarted++;
            qCritical() << "emitting signal coinProcessJustStopped";
            emit runProc_coinProcessJustStopped();
        } else

        if (payInProg==7)   // coins returned, printing failed
        {
            collActiv=7;
            hwapi_paymentStarted++;
            qCritical() << "emitting signal payCancelled";
            emit runProc_payCancelled();
        }
    }

    if (hwapi_paymentStarted==4)
    {
        // transaction finished
        hwapi_paymentStarted=0;
    }

    //if ( (empState<8) || (empState>12))
    //    epi_clearCurrentPayment();      // to avoid wrong "got-coin" messages

    if (hwapi_paymentStarted==90 )
    {
        // EMP error, wait till process finished
        // everything stopped, no more coins in escrow
        hwapi_paymentStarted=0;
    }

    return collActiv;
}





void T_runProc::sub_emp_getAllParameters(struct T_emp *emp)
{
    uint8_t leng, data[66], ii, pp;
    epi_restoreEmpSettings(&leng, data);    // expected length = 64 byte

    // get 64 bytes about EMP: see h-file

    emp->gotSetup   = data[0];
    emp->state      = data[1];
    emp->shaft      = data[2];
    emp->countryCode= uchar2uint(data[4], data[3]);
    emp->scale      = data[5];
    emp->decimals   = data[6];
    for (ii=0; ii<16; ii++)
        emp->coinValues[ii] = data[7+ii];
    emp->coinAccept = uchar2uint(data[24], data[23]);
    emp->tokenChannel = data[25];
    emp->pollingRunning = data[26];
    emp->paymentRunning = data[27];

    pp=28;
    for (ii=0; ii<16; ii++)
    {
        emp->denomination[ii] = uchar2uint(data[pp+1], data[pp]);
        pp+=2;
    }
    emp->routing= uchar2uint(data[61], data[60]);

}

void T_runProc::changer_getAllParameters(struct T_changer *mw)
{
    // requested automatically with 23, same like EMP

    uint8_t leng, data[66], pp, nn;
    epi_restoreEmpSettings(&leng, data);    // expected length = 64 byte

    // get 64 bytes about Changer (mw), see interfaces.h-file
    mw->setup   = data[0];
    mw->state   = data[1];
    mw->level   = data[2];
    mw->countryCode = uchar2uint(data[4], data[3]);
    mw->scale   = data[5];
    mw->decimals= data[6];

    for (nn=0; nn<16; nn++)
        mw->coinSetup[nn]= data[nn+7];   // 7...22
    mw->intendedAcceptance = uchar2uint(data[24], data[23]);
    mw->tokenChannel= data[25];
    mw->pollingRunning= data[26];
    mw->paymentRunning= data[27];
    pp=28;
    for (nn=0; nn<16; nn++)
    {
        mw->denomination[nn] = uchar2uint(data[pp+1], data[pp]);
        pp+=2;
    }
    // bis pp=60
    mw->availableTubes = uchar2uint(data[61], data[60]);
}


void T_runProc::sub_getDynMachineConditions(struct T_dynamicCondition *dynMachCond)
{

    uint16_t LL, nn;
    char *start;
    uint8_t  buf[70], leng;

    epi_restoreDynMachineConditions(&leng, buf);
        // Puffer in struct eintragen:
    LL=sizeof(struct T_dynamicCondition);
    start = &dynMachCond->allDoorsDebounced;
    nn=0;
    do
    {
        *start = buf[nn];
        start++;
    } while(++nn<LL);

}




/*
static uint8_t Sdata_DeviceParameter[64];
static uint8_t Sdata_DevParaLen;

uint8_t T_runProc::epi_store64BdevParameter(uint8_t length, uint8_t *buf)
{
    // HWapi writes data to be stored
    uint8_t nn;
    for (nn=0; nn<length; nn++)
        Sdata_DeviceParameter[nn]=buf[nn];
    for (nn=length; nn<64; nn++)
        Sdata_DeviceParameter[nn]=0;

    Sdata_DevParaLen=length;
    return 0;
}

uint8_t T_runProc::epi_restore64BdevParameter(uint8_t *length, uint8_t *buf)
{

    for (uint8_t nn=0; nn<Sdata_DevParaLen; nn++)
        buf[nn]=Sdata_DeviceParameter[nn];
    *length=Sdata_DevParaLen;

    return 0;
}
*/

void T_runProc::restoreDeviceParameter(struct T_devices *deviceSettings)
{
    // attention: only applies if function "sys_sendDeviceParameter()" was used to send this settings before
    //          cannot be used to see settings programmed by JsonFile
    uint8_t buf[64];
    uint8_t LL, nn;
    tslib_strclr(buf,0,64);
    uint8_t *start;

    //epi_restore64BdevParameter(&LL, buf); schmarrn

    epi_restoreRbDeviceSettings(&LL, buf);
    // Puffer in struct eintragen:
    start = &deviceSettings->kindOfPrinter;
    nn=0;
    do
    {
        *start = buf[nn];
        start++;
    } while(++nn<LL);

}




bool T_runProc::doors_supervise(void)
{
    // new from 2023.06.12, generate some signals:
    //virtual void hwapi_ doorServiceDoorOpened(void) const=0;
    //virtual void hwapi_ doorVaultDoorOpened(void) const=0;
    //virtual void hwapi_ doorCBinAndAllDoorsClosed(void) const=0;
    //virtual void hwapi_ doorAllDoorsClosed(void) const=0;
    //virtual void hwapi_ doorCoinBoxRemoved(void) const=0;

    //hwapi_lastDoorState:      // bit0=1: upper door open    bit1:middle   bit2:lower  bit3=1: cash-box out

    struct T_dynamicCondition myDynMachCond;
    uint8_t uctmp, doorTemp;

    sub_getDynMachineConditions(&myDynMachCond);
    //uint8_t CBinDebounced;  // 0:fehlt  1:drin
    //char upperDoor;         // 99: undefined  0:closed  1:open
    //char middleDoor;		// 99: undefined  0:closed  1:open
    //char lowerDoor;         // 99: undefined  0:closed  1:open
    //char billBox;

    // PlausiCheck mit analogwerten:
    if ( (myDynMachCond.U_Batt<8000) || (myDynMachCond.U_Batt>16000))            // 8...16V erlaubt
        return false;       // Fehler

    if ((myDynMachCond.Temperatur<40) || (myDynMachCond.Temperatur>260))        // -30°C...80°C erleubt
        return false;       // Fehler

    uctmp=(hwapi_lastDoorState & 1);      // 0: upper door is closed
    if (uctmp==0 && myDynMachCond.upperDoor>0)
    {
        hwapi_lastDoorState |= 1;
        qCritical()<<"hwapi emitting signal ServiceDoorOpened";
        emit runProc_doorServiceDoorOpened();
    }

    uctmp=(hwapi_lastDoorState & 2);
    if (uctmp==0 && myDynMachCond.middleDoor>0)
    {
        hwapi_lastDoorState |= 2;
        qCritical()<<"hwapi emitting signal VaultDoorOpened ";
        emit runProc_doorVaultDoorOpened();
    }

    uctmp=(hwapi_lastDoorState & 4);
    if (uctmp==0 && myDynMachCond.lowerDoor>0)
    {
        hwapi_lastDoorState |= 4;
        qCritical()<<"hwapi emitting signal ServiceDoorOpened (Batt)";
        emit runProc_doorServiceDoorOpened();
    }

    uctmp=(hwapi_lastDoorState & 8);      // 0: cash box was in
    if (uctmp==0 && myDynMachCond.CBinDebounced==0)     // 0:fehlt  1:drin
    {
        // wurde gerade entnommen
        hwapi_lastDoorState |= 8;
        qCritical()<<"hwapi emitting signal CoinBoxRemoved ";
        emit runProc_doorCoinBoxRemoved();
    }

    uctmp=(hwapi_lastDoorState & 8);
    if (uctmp>0 && myDynMachCond.CBinDebounced>0)       // 0:fehlt  1:drin
    {
        // war draussen, ist wieder drin
        hwapi_lastDoorState &= ~0x08;
        qCritical()<<"hwapi emitting signal CoinBoxInserted";
        emit runProc_doorCoinBoxInserted();
    }

    uctmp=(hwapi_lastDoorState & 0x07);
    doorTemp=0;
    if (myDynMachCond.upperDoor>0)  doorTemp |=1;
    if (myDynMachCond.middleDoor>0) doorTemp |=2;
    if (myDynMachCond.lowerDoor>0)  doorTemp |=4;

    if (uctmp>0 && doorTemp==0)     // vorher war mind. EINE Tuer offen UND jetzt sind alle zu
    {
        hwapi_lastDoorState &= ~0x07;

        // soeben wurde die letzte Tür geschlossen, prüfe ob Kasse eingesetzt wurde:
        if (myDynMachCond.CBinDebounced)
        {
            qCritical()<<"hwapi emitting signal CBinAndAllDoorsClosed";
            emit runProc_doorCBinAndAllDoorsClosed();
            hwapi_lastDoorState &=~0x08;    // keine Wirkung
        } else
        {
            qCritical()<<"hwapi emitting signal AllDoorsClosed";
            emit runProc_doorAllDoorsClosed();
        }
    }

    return true;

}


uint8_t T_runProc::prn_getHwState(struct Tprn_hw_state *prn_hw_state)
{
    // return printer hardware state: power is on? rs-driver on? rs_switch ok? hw-ready-line ok?
    //        printer on error or ok?
    uint8_t prnHWstate[20];

    epi_restorePrinterState(prnHWstate);
        // byte 1...6 come right from printer, see printer manual
        // byte 0 = all important infos:
        // byte 0 = 0: prnter OK,  >0: error
        // bit0: paper low  1: no paper    2: temperature error
        // 3: head open     4: paper jam in cutter
        // 6: no response   7: bad response from printer

    prn_hw_state->powerRdBk = epi_getDI_printerPwr();
    prn_hw_state->rsSwOk    = epi_getDO_serialMux1isSetToPrinter();   // mux1 off: serial is switched to printer
    prn_hw_state->rsDrvOk   = epi_getDO_serialDriverIsOn();
    prn_hw_state->ReadyLine = epi_getDI_prnReady();

    if (prnHWstate[0]==0)
        prn_hw_state->inIdle = true;    // no errors
    else
        prn_hw_state->inIdle = false;    // off or errors

    if (prnHWstate[0] & 1)
        prn_hw_state->paperNearEnd=true;
    else
        prn_hw_state->paperNearEnd = false;

    if (prnHWstate[0] & 2)
        prn_hw_state->noPaper=true;
    else
        prn_hw_state->noPaper = false;

    if (prnHWstate[0] & 4)
        prn_hw_state->ErrorTemp=true;
    else
        prn_hw_state->ErrorTemp = false;

    if (prnHWstate[0] & 8)
        prn_hw_state->HeadOpen=true;
    else
        prn_hw_state->HeadOpen = false;

    if (prnHWstate[0] & 16)
        prn_hw_state->cutterJam=true;
    else
        prn_hw_state->cutterJam = false;


    if (prnHWstate[0] & 64)
        prn_hw_state->noResponse=true;
    else
        prn_hw_state->noResponse = false;

    if (prnHWstate[0] & 128)
        prn_hw_state->badResponse=true;
    else
        prn_hw_state->badResponse = false;
    return prnHWstate[0];

}




void T_runProc::dc_autoRequest(bool on)
{
    // automatically request ALL digital and analog sensors, get time/date, get status information
    epi_startEmmision(on);
}

void T_runProc::bl_rebootDC(void)
{
    // send command to normal DC-Program requesting a restart
    // BL is working for 5s after power-on-reset.

    uint8_t len, buf[20];

    len=dcBL_restartDC(buf);
    sendWRcmd_setSendBlock160(len, buf);
}

void T_runProc::bl_startBL(void)
{
    // use this function within the first 5s after reboot to startup the BL,
    // otherwise the BL jumps to normal DC application
    uint8_t len, buf[20];

    len=dcBL_activatBootloader(buf);
    sendWRcmd_setSendBlock160(len, buf);
    epi_setNowIsBootload(true);
}

void T_runProc::bl_checkBL(void)
{
    // call this function in order to get information, afterwards use "bl_isUp()"
    uint8_t len, buf[20];

    len=dcBL_readFWversion(buf);
    sendWRcmd_setSendBlock160(len, buf);
}

bool T_runProc::bl_isUp(void)
{
    uint8_t receivedData[160];
    uint8_t LL, nn;

    for (nn=0; nn<160; nn++) receivedData[nn]=0;
    LL=epi_getRawRecLength();
    if (LL>0)
    {
        epi_getRawReceivedData(receivedData);

        // response to "readFWversion"
        if (receivedData[0]==2 && receivedData[1]==146 && receivedData[2]==45 &&
            receivedData[3]==45 && receivedData[4] ==95 && receivedData[5]==176)
        {
            qDebug() << "got BL response to readFWversion";
            epi_clrRawReceivedString();
            return true;
        }
        // response to "start BL"
        if (receivedData[0]==2 && receivedData[1]==101 && receivedData[2]==48 &&
            receivedData[3]==223 && receivedData[4] ==131 )
        {
            qDebug() << "hwapi_bl_isUp: got BL response to start";
            epi_clrRawReceivedString();
            return true;
        }
    }
    return false;
}


void T_runProc::bl_completeStart(void)
{
    bl_startupStep=1;
}

bool T_runProc::bl_performComplStart(void)
{
    // must be called cyclic by timer
    static uint8_t retryCtr;

    if ((bl_startupStep<1) || (bl_startupStep>10))
        return false;

    if (bl_startupStep==1)
    {
        dc_autoRequest(false);
        bl_startupStep++;
    } else

    if (bl_startupStep==2)
    {
        bl_rebootDC();
        hwapi_triggerBL->stop();
        hwapi_triggerBL->start(1000);    // call next step in 1s
        retryCtr=0;
        bl_startupStep++;
    } else

    if (bl_startupStep==3)
    {
        //qDebug()<<"starting BL";
        bl_startBL();
        hwapi_triggerBL->stop();
        hwapi_triggerBL->start(100);
        bl_startupStep++;

    } else

    if (bl_startupStep==4)
    {
        //if (!myTO->isActive())
        //{
        bl_checkBL();
        hwapi_triggerBL->stop();
        hwapi_triggerBL->start(100);
        bl_startupStep++;

        //}

    } else

    if (bl_startupStep==5)
    {
        hwapi_triggerBL->stop();
        if (bl_isUp())
        {
            bl_startupStep=99;
            //  BL is up and running
        } else
        {
            retryCtr++;    // start again
            if (retryCtr>=15)
            {
                bl_startupStep=99;
                //qDebug()<<"BL error!!!";
            } else
            {
                bl_startupStep=3;
                //qDebug()<<"BL retry...";
            }
        }

    }
    return true;
}