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


T_prot::T_prot()
{

    mySerialPort = new T_com();
    connect(mySerialPort, SIGNAL(receivingFinished()), this, SLOT( analyseRecData() ));
    //connect(mySerialPort, SIGNAL(sendingFinished()), this, SLOT(sendeFin()));

    for (int nn=0; nn<FRAME_DATALEN; nn++)
    {
        chOut_Data[nn]=0;
        ui8OutputData[nn]=0;
        InputData[nn]=0;
    }
    for (int nn=0; nn<BL_DATA_LEN; nn++)
    {
        ui8BLsendData[nn]=0;
    }
    WriteCommand=0;
    WriteAddr=0;
    WrDataLength=0;
    SendDataValid=0;
    kindOfData=0;
    slaveAddr=0;
    ReadCommand=0;
    //ReadAddr=0;
    reserve =0;
    RecSlaveAddr =0;
    INdataValid=0;
    readSource =0;
    readAddress=0;
    RdDataLength=0;
    BLsendDataLength=0;

    prot_storeResult=0xFF;
}


// ---------------------------------------------------------------------------------------------------------
// sending.....
// ---------------------------------------------------------------------------------------------------------

bool T_prot::isPortOpen(void)
{
    return mySerialPort->isPortOpen();
}

bool T_prot::isSerialFree(void)
{
    return true;           // ohne HS's kann er nicht blockiert sein
}


// 14.9.23 Fehler!!!!!
// hier wird vorausgesetzt dasss die Empfangslaenge von Sendetelegramm abh. ist.
// also cmd>=100 ist kurze Antwort. das stimmt aber nicht, ist unabh. Wahr ist: cmd>=100 = kurzes Sendetelegramm

// Laenge des request-telegramms (PTU-->DC) ist nur abh. vom WRcmd, die Antwort auf WR ist immer kurz (nur result byte)
// WRcmd kurz oder lang: Antwort immer kurz
// RDcmd kurz oder lang: Antwort genauso
// Also Korrektur dieser Funktion: nur der Variablenname "WriteCmd" -> "ReadCmd"

void T_prot::setRecLen(uint16_t ReadCmd)
{
    if (ReadCmd<100)
    {
        RdDataLength=DATALEN_RECEIVE_LONG;     // 64, store here already because it's no longer returned from slave
        mySerialPort->receiveFixLen(TELEGRAMLEN_RECEIVE_LONG);      // 68
    } else
    {
        RdDataLength=DATALEN_RECEIVE_FAST;      // 8
        mySerialPort->receiveFixLen(TELEGRAMLEN_RECEIVE_FAST);      // 12
    }
}

/*
 * void T_prot::setRecLen(uint16_t WriteCmd)
{
    if (WriteCmd<100)
    {
        RdDataLength=DATALEN_RECEIVE_LONG;      // store here already because it's no longer
                                                // returned from slave
        mySerialPort->receiveFixLen(TELEGRAMLEN_RECEIVE_LONG);      // 68
    } else
    {
        RdDataLength=DATALEN_RECEIVE_FAST;
        mySerialPort->receiveFixLen(TELEGRAMLEN_RECEIVE_FAST);      // 12
    }
}
*/

void T_prot::setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr, uint8_t  WrDatLen, uint8_t *data)
{
    WriteCommand=WriteCmd;
    WriteAddr=WrAddr;
    WrDataLength=WrDatLen;
    if (WrDataLength>FRAME_DATALEN)
        WrDataLength=FRAME_DATALEN;

    for (int nn=0; nn<WrDataLength; nn++)
        ui8OutputData[nn]=data[nn];
    SendDataValid=1;    // always set WR first
    kindOfData=0;    // 0: binaries, 1:text
    this->setRecLen(100);   // default: short response

}

void T_prot::setUserWriteData(uint16_t WriteCmd, uint16_t WrAddr)
{
    WriteCommand=WriteCmd;
    WriteAddr=WrAddr;
    WrDataLength=0;
    for (int nn=0; nn<FRAME_DATALEN; nn++)
        ui8OutputData[nn]=0;
    SendDataValid=1;    // always set WR first
    kindOfData=0;    // 0: binaries, 1:text
    this->setRecLen(100);   // default: short response

}

void T_prot::setUserWriteData(uint16_t WriteCmd)
{
    WriteCommand=WriteCmd;
    WriteAddr=0;
    WrDataLength=0;
    for (int nn=0; nn<FRAME_DATALEN; nn++)
        ui8OutputData[nn]=0;
    SendDataValid=1;    // always set WR first
    kindOfData=0;    // 0: binaries, 1:text
    this->setRecLen(100);   // default: short response

}

void T_prot::setUserWrite1DB(uint16_t WriteCmd, uint16_t WrAddr, uint8_t val)
{
    // wie oben, jedoch einfachere Datenübergabe
    WriteCommand=WriteCmd;
    WriteAddr=WrAddr;
    WrDataLength=1;
    ui8OutputData[0]=val;
    SendDataValid=1;    // always set WR first
    kindOfData=0;    // 0: binaries, 1:text
    this->setRecLen(100);   // default: short response

}

void T_prot::setUserWrite2DB(uint16_t WriteCmd, uint16_t WrAddr, uint8_t val0, uint8_t val1)
{
    WriteCommand=WriteCmd;
    WriteAddr=WrAddr;
    WrDataLength=2;
    ui8OutputData[0]=val0;
    ui8OutputData[1]=val1;
    SendDataValid=1;    // always set WR first
    kindOfData=0;    // 0: binaries, 1:text
    this->setRecLen(100);   // default: short response

}

void T_prot::setUserWriteText(uint16_t WriteCmd, uint16_t WrAddr, uint8_t  WrDatLen, char *data)
{
    WriteCommand=WriteCmd;
    WriteAddr=WrAddr;
    WrDataLength=WrDatLen;
    if (WrDataLength>FRAME_DATALEN)
        WrDataLength=FRAME_DATALEN;

    for (int nn=0; nn<WrDataLength; nn++)
        chOut_Data[nn]=data[nn];
    SendDataValid=1;    // always set WR first
    kindOfData=1;    // 0: binaries, 1:text
    this->setRecLen(100);   // default: short response

}

void T_prot::setUserReadData( uint16_t ReadCmd)
{
    ReadCommand=ReadCmd;
    //ReadAddr=WriteAddr;
    reserve=0;
    SendDataValid |=2;
    readAddress=WriteAddr;    // store here already because it's no longer returned from slave

    //qDebug()<<"prot_setUserReadData, read address : " << readAddress;

    this->setRecLen(ReadCmd);   // long response (68byte) only for ReadCmd < 100
    readSource=ReadCmd;
}

void T_prot::setBLsendData( uint8_t len, uint8_t *buf)
{
    for (int nn=0; nn<BL_DATA_LEN; nn++)
        ui8BLsendData[nn]=0;

    BLsendDataLength=len;
    if ( BLsendDataLength>BL_DATA_LEN) BLsendDataLength=BL_DATA_LEN;
    for (int nn=0; nn<BLsendDataLength; nn++)
        ui8BLsendData[nn]=buf[nn];
    WriteCommand=0xFFFF;
    this->setRecLen(100);


    //qDebug()<<"prot: got BL data " << len << "bytes, ";
    //for (int i=0; i<len; ++i) {
    //    printf("%02x ", (unsigned char)buf[i]);
    //} printf("\n");

    /*
qDebug()<<buf[0] <<buf[1] <<buf[2] <<buf[3] <<buf[4] <<buf[5] <<buf[6] <<buf[7];
qDebug() <<buf[8] <<buf[9] <<buf[10] <<buf[11] <<buf[12] <<buf[13]<<buf[14]<<buf[15];
qDebug() <<buf[16] <<buf[17] <<buf[18] <<buf[19] <<buf[20] <<buf[21]<<buf[22]<<buf[23];
qDebug() <<buf[24] <<buf[25] <<buf[26] <<buf[27] <<buf[28] <<buf[29]<<buf[30]<<buf[31];
qDebug() <<buf[32] <<buf[33] <<buf[34] <<buf[35] <<buf[36] <<buf[37]<<buf[38]<<buf[39];
qDebug() <<buf[40] <<buf[41] <<buf[42] <<buf[43] <<buf[44] <<buf[45]<<buf[46]<<buf[47];
qDebug() <<buf[48] <<buf[49] <<buf[50] <<buf[51] <<buf[52] <<buf[53] <<buf[54]<<buf[55];
qDebug() <<buf[56] <<buf[57] <<buf[58] <<buf[59] <<buf[60] <<buf[61] <<buf[62]<<buf[63];
qDebug() <<buf[64] <<buf[65] <<buf[66] <<buf[67] <<buf[68] <<buf[69] <<buf[70]<<buf[71];
qDebug() <<buf[72] <<buf[73] <<buf[74] <<buf[75] <<buf[76] <<buf[77] <<buf[78]<<buf[79];
*/

}

void T_prot::receiveFixLen(int64_t nrOfbytesToReceive)
{
    mySerialPort->receiveFixLen(nrOfbytesToReceive);
}

void T_prot::sendUserData(uint16_t slaveAdr)
{
    // man könnte hier noch "SendDataValid" abfragen,
    // muss immer 3 sein, muss man aber nicht

    //qDebug()  << "prot send user data "<<slaveAdr;    
    QByteArray  packBuf_2;
    slaveAddr=slaveAdr;

    if (WriteCommand==0xFFFF)
    {
        // Bypass for bootloader, no protocol frame but send as is...
        packBuf_2.clear();
        for (int nn=0; nn<BLsendDataLength; nn++)
        {
        //    packBuf_2[nn]=char(ui8BLsendData[nn]);      // program crash, 4.9.23
            packBuf_2.append(ui8BLsendData[nn]);

        }
        mySerialPort->writeToSerial(packBuf_2, BLsendDataLength);

    } else
        startFastPacking();     // quicker since 15.12.21TS
        //startPacking();
}

void T_prot::startFastPacking(void)
{
    uint16_t  mycrc;
    uint16_t  sendLen;
    uint8_t   uctmp, nn, pp, CrcLp;
    char      sendBuffer[FRAME_MAXLEN], ctmp;

    //qDebug()  << "prot start fast packing "<<slaveAddr;

    for (int nn=0; nn<FRAME_MAXLEN; nn++)
        sendBuffer[nn]=0;

    if (WriteCommand>9 && WriteCommand<100)
    {
        // long command 10...99
        // WriteCommand==0 if only read request, then use short sending
        sendBuffer[0]=STARTSIGN_SEND_LONG;
        WrDataLength=DATALEN_SEND_LONG;    // immer
        //qDebug()  << "send long cmd, len: " << WrDataLength;
    } else
    {
        // fast command
        sendBuffer[0]=STARTSIGN_SEND_FAST;
        WrDataLength=DATALEN_SEND_FAST;    // immer
        //qDebug()  << "send fast cmd, len: " << WrDataLength;
    }
    sendBuffer[1]= uint8_t(WriteCommand);
    sendBuffer[2]= uint8_t(ReadCommand);
    //if (WriteAddr>0)
        sendBuffer[3]= char(WriteAddr);  // bei fast nur EINE adresse, wr hat Vorrang
    //else
    //    sendBuffer[3]= char(ReadAddr);
    // beim Fast prot. ist das reserve dann ists egal was drin steht

    if (kindOfData)   // 0: binaries, 1:text
    {
        for (nn=0; nn<WrDataLength; nn++)
        {
            pp=HEADERLEN_SEND+nn;
            ctmp=(chOut_Data[nn]);      // text
            sendBuffer[pp]= char(ctmp);
        }

    } else
    {
        for (nn=0; nn<WrDataLength; nn++)
        {
            pp=HEADERLEN_SEND+nn;
            uctmp=(ui8OutputData[nn]);      // bin
            sendBuffer[pp]= char(uctmp);
        }
    }

    CrcLp= HEADERLEN_SEND + WrDataLength;
    mycrc=0;
    for (nn=0; nn<CrcLp; nn++)
    {
        uctmp=sendBuffer[nn];
        mycrc+=uint16_t(uctmp);
        //qDebug() << mycrc;
    }
    sendBuffer[CrcLp]=char(mycrc);
    mycrc>>=8;
    sendBuffer[CrcLp+1]=char(mycrc);
    sendLen=CrcLp+2;

    // send to VCP:
    QByteArray  packBuff;
    packBuff.clear();
    packBuff.append(sendBuffer, sendLen);  // ohne sendLen wird beim ersten \0 abgeschnitten!!!
    mySerialPort->writeToSerial(packBuff, sendLen);

}


// ---------------------------------------------------------------------------------------------------------
// receiving.....
// ---------------------------------------------------------------------------------------------------------


void T_prot::analyseRecData(void)
{
    // Aufruf per connect aus serialcontrol wenn Daten empfangen wurden
    // getRecData(QByteArray &data, uint16_t &sendLength);

    QByteArray Indata;
    QString myString, tempStr;
//char recBuffer[FRAME_MAXLEN];
uint8_t recBuffer[FRAME_MAXLEN];

    uint16_t recLength;

    INdataValid=false;

    gpi_setTxt4HsStateLine("");
    gpi_setTxt4masterStateLine("");
    gpi_setTxt4resultStateLine("");
    gpi_setTxt4dataStateLine("");
    gpi_setTxt4datifLine("");

    // read from "VCP":
    mySerialPort->readFromSerial(Indata, recLength);
//qDebug()<<"prot: got data " << recLength;
    if (recLength>FRAME_MAXLEN)
        recLength=FRAME_MAXLEN;
    for (int nn=0; nn<recLength; nn++)
        recBuffer[nn]=uint8_t(Indata.at(nn));

    myString.clear();
    tempStr.clear();
    uint8_t result=FastCheckInData(recBuffer, recLength);  // check input data (response from slave)
    if (result>0)
    {
        // dann anzeige
        switch (result)
        {
          case 1: gpi_setTxt4masterStateLine("wrong length received"); break;
          case 2: gpi_setTxt4masterStateLine("wrong start sign received"); break;
          case 3: gpi_setTxt4masterStateLine("received datalen too big"); break;
          case 4: gpi_setTxt4masterStateLine("wrong data len received"); break;
          case 5: gpi_setTxt4masterStateLine("wrong crc received"); break;
          case 6: gpi_setTxt4masterStateLine("slave: master cmd was wrong"); break;
          case 7: gpi_setTxt4masterStateLine("slave: could not write/read data"); break;

        }
        myString.setNum(result);

//        qDebug()<<"T_prot_analyseRecData: got BL data"<< recLength <<
//            recBuffer[0]<< recBuffer[1]<<  recBuffer[2]<<  recBuffer[3] <<
//            recBuffer[4]<< recBuffer[5]<< recBuffer[6]<< recBuffer[7];

        // Daten abspeichern, könnten vom BL sein:
        gpi_storeRawReceivedData(uint8_t(recLength), recBuffer);
        INdataValid=false;
        emit rawDataRecieved();
    } else
    {
        gpi_setTxt4masterStateLine("slave response OK");
        INdataValid=true;
        ShowFastInData(recBuffer);    // Eingangs-Daten des Slaves anzeigen
    }
    prot_storeResult=result;
    emit framerecieved();       // always emit, no matter if data valid or not

}


uint8_t T_prot::FastCheckInData(uint8_t *Inbuf, uint16_t LL)
{

    uint16_t rawInLen=LL, crcL_Addr, recCrc, myCrc, nn, datalen, nxt;


    if (Inbuf[0]!=STARTSIGN_RECEIVE_FAST && Inbuf[0]!=STARTSIGN_RECEIVE_LONG)
    {
        //qDebug() << "prot: got wrong start sign: " << Inbuf[0];
        return 2;       // wrong start sign
    }
    if ( (rawInLen<TELEGRAMLEN_RECEIVE_FAST && Inbuf[0]==STARTSIGN_RECEIVE_FAST) ||
         (rawInLen<TELEGRAMLEN_RECEIVE_LONG && Inbuf[0]==STARTSIGN_RECEIVE_LONG)   )
    {
        //qDebug("prot: got %d bytes only", rawInLen);
        return 1;       // wrong length
    }
    if (Inbuf[0]==0x5F)
        datalen=DATALEN_RECEIVE_FAST;
    else
        datalen=DATALEN_RECEIVE_LONG;

    crcL_Addr=datalen+HEADERLEN_RECEIVE;  // weil im definierten protocol 2 bytes vor den Daten stehen
    recCrc=0;
    recCrc=uchar2uint(uint8_t(Inbuf[crcL_Addr+1]), uint8_t(Inbuf[crcL_Addr]));
    myCrc=0;
    for (nn=0; nn<crcL_Addr; nn++)
    {
        nxt=uint16_t (Inbuf[nn]);
        nxt &=0x00FF;   // the casting makes 0xFFFF out of 0xFF !!!!!!!!!
        myCrc+=nxt;
        //qDebug("CRC: nxt: %d  sum: %d", nxt, myCrc);
    }

    if (myCrc != recCrc)
    {
        //qDebug() << "crc does not match";   //:   mycrc=" << myCrc<< "   receivedCRC=" << recCrc;
        //qDebug("calculated over %d bytes", crcL_Addr);
        return 5;       // crc wrong
    }

    uint8_t result=Inbuf[1];
        // slave reports that   0: OK
        // bit 2,1,0:  master command was wrong
        // bit 4,3:    could not write data
        // bit 6,5:    could not read data


// NEU 17.7.23:
    if (result & 0x07)
        return 6;       // slave: master cmd was wrong
    if (result & 0x78)
        return 7;       // slave: could not write/read data

    //if (result>0)   schmarrn, kann nie kommen
    //    qDebug() << "prot, got DC-result: "<< result;

    return 0;
}

/*
uint8_t T_prot::CheckInResult(uint8_t *Inbuf)
{
    char slaveresult;
    QString myString=nullptr, tempStr=nullptr;

    // slave results anzeigen

    slaveresult=Inbuf[2];    // hier steht das "Command Result" des slaves,
                            // d.h das Ergebnis der Protokol-Prüfung (Master->Slave)
    switch (slaveresult)
    {
//        received message (from master) analysis:
//        0: got valid request
// this errors can only come back from a single device (not bus)
// or from a bus slave in local mode
//        1: wrong start     2: wrong length
//        3: wrong crc       4: wrong addr

        case 1: gpi_setTxt4resultStateLine("slave got wrong start sign"); break;
        case 2: gpi_setTxt4resultStateLine("slave got wrong length"); break;
        case 3: gpi_setTxt4resultStateLine("slave got wrong crc"); break;
        case 4: gpi_setTxt4resultStateLine("slave got wrong addr"); break;

        case 10: gpi_setTxt4resultStateLine("slave is in local mode"); break;
        case 13: gpi_setTxt4resultStateLine("local mode with wrong crc"); break;
        case 14: gpi_setTxt4resultStateLine("local mode with wrong addr"); break;
           // wenn 1..4 dann konnte der Slave das Mastertelegramm gar nicht verwenden, also hier Stoppen
    }
    if (slaveresult>0 && slaveresult<10)
        return 1;

    // Slave hat gültiges Kommando empfangen:
    // 2.result auswerten:
    // recBuffer[3];   // Write result, d.h. Ergebnis des Schreibvorganges (z.B. DOs) des Slaves
    // recBuffer[4];   // Read result, d.h. Ergebnis des Lesevorganges (z.B. DIs) des Slaves
    // bisher nicht bekannt welche Fehlercodes es gibt, also den code direkt ausgeben.
    // bisher bekannt: 0=OK

    myString.clear();
    myString = "Slave OUT and IN Result: ";
    tempStr.setNum(Inbuf[3],16);
    myString.append(tempStr);
    myString.append(" ");
    tempStr.setNum(Inbuf[4],16);
    myString.append(tempStr);
    gpi_setTxt4resultStateLine(myString);
    return 0;
}
*/


uint8_t T_prot::ShowFastInData(uint8_t *recBuffer)
{
    QString myString=nullptr, tempStr=nullptr;
    uint8_t result;

    RecSlaveAddr=0;
    result=recBuffer[1];    // total result
    result &=0x60;          // only read result (bit 5,6)

    if (result==0)     // read result =OK,
                       // dann sind die Eingangsdaten gültig
    {
        myString.append("valid INdata: ");
        //INdataValid=true;     // 17.7. hier raus!
        //readSource   already set with sending
        //readAddress=0;        großer Fehler!!!! raus am 17.7
        // RdDataLength already set with sending
        if (RdDataLength>FRAME_DATALEN)
            RdDataLength=FRAME_DATALEN;
        for (int ii=0; ii<RdDataLength; ii++)
            InputData[ii]=uint8_t(recBuffer[ii+HEADERLEN_RECEIVE]);

        tempStr.setNum(readSource,16);
        myString.append(tempStr);
        myString.append(" add:");

        tempStr.setNum(readAddress);
        myString.append(tempStr);
        //myString.append(" wakeSrc:");
        //tempStr.setNum(lastWakeSrc);
        //myString.append(tempStr);
        myString.append(" Dlen:");
        tempStr.setNum(RdDataLength);
        myString.append(tempStr);        

    } else
    {
        myString=" ";   // Eingangsdaten nicht gültig, sieht man aber weiter oben schon

    }

    gpi_setTxt4dataStateLine(myString);
    //qDebug() << myString;
    //qDebug("prot_checkInData_bindata: %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d ",
    //        InputData[0], InputData[1], InputData[2], InputData[3],
    //        InputData[4], InputData[5], InputData[6], InputData[7],
    //        InputData[8], InputData[9], InputData[10], InputData[11],
    //        InputData[12], InputData[13], InputData[14], InputData[15]);
    return 0;
}


uint8_t T_prot::ifDataReceived()
{
    // return: 0xFF: result unknown      0=OK
    // 1= wrong length    2=wrong start sign           5= wrong crc
    // 6= slave: master cmd was wrong       7: slave: could not write/read data
    return  prot_storeResult;

}

bool T_prot::getReceivedInData(uint8_t  *SlavAddr, uint16_t *readSrc, uint16_t *readAddr,
                                    uint8_t  *RdDlen, uint8_t *receivedData)
{
    uint8_t nn;
    *SlavAddr=RecSlaveAddr;
    *readSrc=readSource;        // diese (Eingangs-)Daten stehen im Puffer
    *readAddr=readAddress;       // von dieser Adr wurden die Daten gelesen

//qDebug()<<"prot_get_ReceivedInData, read address : " << readAddress;

    //*lastWakSourc=lastWakeSrc;       // falls der Slave den Master geweckt hat
    *RdDlen=RdDataLength;
    for (nn=0; nn<FRAME_DATALEN; nn++)
        receivedData[nn]=0;
    for (nn=0; nn<RdDataLength; nn++)
        receivedData[nn]=InputData[nn];

    // neu, 17.10.23: lokalen Puffer löschen
    //for (nn=0; nn<FRAME_DATALEN; nn++)
    // {
    //    InputData[nn]=0;
    //}
    // wieder raus, keinen Vorteil erkannt. Unklar ob das irgendwo Probleme macht! (bootloader?)

    RdDataLength=0;
    //-------------------------------------------

    return INdataValid;           // nur true wenn CommandState OK und readState OK
}