#include <stdint.h>
#include <QString>
#include <QDebug>
#include "tslib.h"
//#include "controlBus.h"

// ///////////////////////////////////////////////////////////////////////////////////
//          control serial interface   gui <--> serial
// ///////////////////////////////////////////////////////////////////////////////////

static QString    rs_comportName;   // z.B. "COM48"
static QString    rs_baudStr;       // z.B. "19200"
static int        rs_baudNr;        //0...5 oder -1
static uint8_t    rs_connect;       // 0,1

void epi_setSerial(int BaudNr, QString BaudStr, QString ComName, uint8_t connect)
{
    rs_comportName = ComName;
    rs_baudStr     = BaudStr;
    rs_baudNr      = BaudNr;    // 0=1200  1=9600  2=19200  3=38400  4=57600  5=115200  oder -1
    rs_connect     = connect;     // 0/1

}

void epi_closeSerial(void)
{
    rs_connect=0;
}


void gpi_serialChanged(void)
{
    // serial confirms that port was closed or opened
    rs_connect=2;   // Flanke, nur 1x öffnen/schließen
}

uint8_t gpi_getSerialConn(void)
{
    return rs_connect;
}


int gpi_getBaudNr(void)
{
    return rs_baudNr;
}

QString gpi_getComPortName(void)
{
    return rs_comportName;
}

static bool rs_portIsOpen;

void gpi_serialIsOpen(bool offen)
{
    rs_portIsOpen=offen;
}

bool epi_isSerialPortOpen()
{
    // true: port is open   false: port is closed
    return rs_portIsOpen;
}

// ///////////////////////////////////////////////////////////////////////////////////
//          Control transfer   gui <--> serial
// ///////////////////////////////////////////////////////////////////////////////////


static char       AutoEmissionOn;     // 1: zyklisch Anfragen zum Slave senden

void epi_startEmmision(char start)
{
    AutoEmissionOn=start;
}

bool gpi_isEmmisionOn(void)
{
    return AutoEmissionOn;
}

//-----------------------------------------------------

static uint16_t datif_sendingPeriod;
static bool     datif_sendingPer_changed;

uint16_t gpi_getPeriodicSendTimeVal()
{
    datif_sendingPer_changed=0;
    if (datif_sendingPeriod<3 || datif_sendingPeriod>10000)
        return 130;         // ms, default
    else
        return datif_sendingPeriod;
}

void epi_setPeriodicSendTimeVal(uint16_t val)
{
    if (val>=3 && val<10000)
    {
        datif_sendingPer_changed=1;
        datif_sendingPeriod=val;
    }
}

bool gpi_PeriodicSendTimeHasChanged()
{
    return datif_sendingPer_changed;
}

//-----------------------------------------------------


//-----------------------------------------------------

// ///////////////////////////////////////////////////////////////////////////////////
//          Status Display    gui <--> serial
// ///////////////////////////////////////////////////////////////////////////////////


//              linke Spalte, über Connect Button
static QString txt4comStateLine;

QString epi_getTxt4comStateLine(void)
{
    // GUI: get Text for serial Comport-State Line
    return txt4comStateLine;
}

void gpi_setTxt4comStateLine(QString txtline)     // gpi
{
    // serial: write Text to be displayed in serial Comport-State line (like "connected")
    txt4comStateLine.clear();
    if (txtline=="")
        txt4comStateLine.clear();
    else
        txt4comStateLine=txtline;
}

void epi_clrTxt4comStateLine()
{
    txt4comStateLine.clear();
}


//---------------------------------------------------------------------------------------------

// rechte Spalte, oberste Statuszeile
// I) "Handshakes" (serial Control)   flow.cpp
// geht überhaupt was raus? kommt überhaupt was zurück?
static QString txt4HsStateLine;

QString epi_getTxt4HsStateLine(void)
{
    return txt4HsStateLine;
}

void gpi_setTxt4HsStateLine(QString txtline)
{
    txt4HsStateLine.clear();
    if (txtline=="")
        txt4HsStateLine.clear();
    else
        txt4HsStateLine=txtline;
}

void epi_clrTxt4HsStateLine()
{
    txt4HsStateLine.clear();
}



//---------------------------------------------------------------------------------------------

// II) Master receive state (empfangenes Telgramm OK? crc? length?  )
// Statuszeile Auswertung der SlaveResponse (serial Frame, CRC usw)  (prot.cpp)
static QString txt4masterStateLine;

QString epi_getTxt4masterStateLine(void)
{
    return txt4masterStateLine;
}

void gpi_setTxt4masterStateLine(QString txtline)
{
    txt4masterStateLine.clear();
    if (txtline=="")
        txt4masterStateLine.clear();
    else
        txt4masterStateLine=txtline;
}

void epi_clrTxt4masterStateLine()
{
    txt4masterStateLine.clear();
}



//---------------------------------------------------------------------------------------------

// III   Slave receive (from Master) OK? if then show results, if not then show errors
// entweder Empfangsfehler anzeigen (crc? length?) oder result OUT-OK, OUT_ERR, IN_OK, IN_ERR
// Hintergrund: wenn der Slave Fehler im Master-Telegramm gefunden hat, dann kann er es auch
// nicht verwenden und nichts ausgeben oder einlesen

static QString txt4resultStateLine;

QString epi_getTxt4resultStateLine(void)
{
    return txt4resultStateLine;
}

void gpi_setTxt4resultStateLine(QString txtline)
{
    txt4resultStateLine.clear();
    if (txtline=="")
        txt4resultStateLine.clear();
    else
        txt4resultStateLine=txtline;
}

void epi_clrTxt4resultStateLine()
{
    txt4resultStateLine.clear();
}


//---------------------------------------------------------------------------------------------

// IV  Statuszeile Empfangsdaten
static QString txt4dataLine;

QString epi_getTxt4dataStateLine(void)
{
    // GUI: get Text for serial Comport-State Line
    return txt4dataLine;

}

void gpi_setTxt4dataStateLine(QString txtline)
{
    // serial: write Text to be displayed in serial Comport-State line (like "connected")
    txt4dataLine.clear();
    if (txtline=="")
        txt4dataLine.clear();
    else
        txt4dataLine=txtline;
}

void epi_clrTxt4dataStateLine()
{
    txt4dataLine.clear();
}

//---------------------------------------------------------------------------------------------

// 5. Zeile: Datif Ergebnis, Daten brauchbar?

static QString txt4datifReceive;

QString epi_getTxt4datifLine(void)
{

    return txt4datifReceive;

}

void gpi_setTxt4datifLine(QString txtline)
{

    txt4datifReceive.clear();
    if (txtline=="")
        txt4datifReceive.clear();
    else
        txt4datifReceive=txtline;
}

void epi_clrTxt4datifLine()
{
    txt4datifReceive.clear();
}

//---------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------

static QString txt4diagWindow;

QString epi_getTxt4RsDiagWin(void)
{
    return txt4diagWindow;

}

void gpi_setTxt4RsDiagWin(QString txtline)
{
    txt4diagWindow.clear();
    if (txtline=="")
        txt4diagWindow.clear();
    else
        txt4diagWindow=txtline;
}

void epi_clrTxt4RsDiagWin()
{
    txt4diagWindow.clear();
}

//---------------------------------------------------------------------------------------------

static QString sndTxt4diagWindow;

QString epi_get2ndTxt4RsDiagWin(void)
{
    return sndTxt4diagWindow;

}

void gpi_set2ndTxt4RsDiagWin(QString txtline)
{
    sndTxt4diagWindow.clear();
    if (txtline=="")
        sndTxt4diagWindow.clear();
    else
        sndTxt4diagWindow=txtline;
}

void epi_clr2ndTxt4RsDiagWin()
{
    sndTxt4diagWindow.clear();
}

// ///////////////////////////////////////////////////////////////////////////////////
//          Memory for Slave responses, common data
// ///////////////////////////////////////////////////////////////////////////////////


static bool Sdata_serialTestResult;

void gpi_storeResult_serialTestOK(bool wasOk)
{
    Sdata_serialTestResult=wasOk;
}

bool epi_getResult_serialTestOK()
{
    // retval: true: test was successful, got right response
    return Sdata_serialTestResult;
}



// ///////////////////////////////////////////////////////////////////////////////////
//          Store received data for hwapi
// ///////////////////////////////////////////////////////////////////////////////////



static uint8_t Sdata_pProtResultOk;

void gpi_startNewRequest()
{
    Sdata_pProtResultOk=0;
}

void gpi_storeResultOfLastRequest(bool answisok)
{
    if (answisok)
        Sdata_pProtResultOk=1;
    else
        Sdata_pProtResultOk=2;
}

uint8_t epi_getResultOfLastRequest()
{
    // retval: 0: in progress  1: OK  2: error
    return Sdata_pProtResultOk;
}




static uint16_t Sdata_receivedDataLength;
static uint8_t Sdata_receivedDataBlock[64];

void gpi_storeRecPayLoad(uint8_t RdDlen, uint8_t *receivedData)
{
    Sdata_receivedDataLength=uint16_t(RdDlen);
    if (Sdata_receivedDataLength>64)
        Sdata_receivedDataLength=64;
    tslib_strclr(Sdata_receivedDataBlock,0,64);
    tslib_strcpy(receivedData, Sdata_receivedDataBlock, Sdata_receivedDataLength);

}

uint16_t epi_getLastPayLoad(uint16_t plBufSiz, uint8_t *payLoad)
{
    // get data back in *pl, max 64 byte
    // retval = nr of bytes received. If host buffer too small then
    // only plBufSíz bytes are copied to pl
    // plBufSíz=size of host buffer

    uint16_t ml=plBufSiz;
    if (ml>64) ml=64;
    if (Sdata_receivedDataLength<ml)
        ml=Sdata_receivedDataLength;
    tslib_strcpy(Sdata_receivedDataBlock, payLoad, ml);
    return Sdata_receivedDataLength;
}