#include "mainwindow.h"
#include <iostream>
#include <QNetworkInterface>

MainWindow::MainWindow(QWidget *parent)
    : QWidget(parent)
{
    parsingContinue = false;
    totalOfBytes = 0;
    totalOfPackets = 0;

    analyserSGSEServerTC = new QTcpServer();
    analyserSGSEServerTM = new QTcpServer();

    socketTC = NULL;
    socketTM = NULL;
    socketEchoServer = new QTcpSocket();

    //****
    // XML
    // xml handlers
    xmlHandler = new LFRXmlHandler();
    // xml sources
    sourceTC = new QXmlInputSource();
    // xml writer
    lfrXmlWriter = new LFRXmlWriter();
    // setup xml parser for the echo bridge
    lfrXmlParser = new LFRXmlParser();

    UI = new MainWindowUI();

    lfrXmlParser->generalCCSDSPacketStore = &this->generalCCSDSPacketStore;

    initSocketStatesList();

    this->setLayout(UI->layout());

    connect(this->UI->button_openServerTCTM, SIGNAL(clicked()), this, SLOT(listenOnTCTMPorts()));
    connect(this->UI->button_testServerTCTM, SIGNAL(clicked()), this, SLOT(testTCTMPorts()));
    connect(this->UI->button_openSocketEchoServer, SIGNAL(clicked()), this, SLOT(openEchoServer()));
    //
    connect(this->analyserSGSEServerTC, SIGNAL(newConnection()), this, SLOT(newConnectionOnTCServer()));
    connect(this->analyserSGSEServerTM, SIGNAL(newConnection()), this, SLOT(newConnectionOnTMServer()));
    //
    connect(this, SIGNAL(socketTMHasChanged(QTcpSocket*)), this->lfrXmlWriter, SLOT(setSocketTM(QTcpSocket*)));
    connect(this->UI->button_TCAcknowledgement, SIGNAL(clicked()), this->lfrXmlWriter, SLOT(sendXML_TC_Acknowledgment()));
    connect(this->UI->button_TCRejection, SIGNAL(clicked()), this->lfrXmlWriter, SLOT(sendXML_TC_rejection()));
    connect(this->UI->button_GSEHK, SIGNAL(clicked()), this->lfrXmlWriter, SLOT(sendXML_GSE_HK()));

    // socket echo server
    connect(this->socketEchoServer, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
            this, SLOT(socket_TMEcho_ServerHasChanged()));
    connect(this->socketEchoServer, SIGNAL(readyRead()),
            this, SLOT(readDataOnSocketEchoServer()));

    // display on console
    connect(this->xmlHandler, SIGNAL(displayMessage(QString)),
            this, SLOT(displayOnConsole(QString)));
    connect(this->UI->hkDisplay, SIGNAL(displayMessage(QString)),
            this, SLOT(displayOnConsole(QString)));
    connect(this->lfrXmlParser, SIGNAL(sendMessage(QString)),
            this, SLOT(displayOnConsole(QString)));
    //
    connect(this->lfrXmlParser, SIGNAL(processPacketStore()),
            this, SLOT(processPacketStore()));
    //
    connect(this->UI->button_resetStatistics, SIGNAL(clicked()),
            this, SLOT(resetStatistics()));

    displayNetworkInterfaces();

    this->xmlHandler->packetStoreHasChanged(&generalCCSDSPacketStore);
};

MainWindow::~MainWindow()
{
    
}

void MainWindow::displayNetworkInterfaces()
{
    QList<QHostAddress> list = QNetworkInterface::allAddresses();
    this->displayOnConsole("Network interfaces:");
    for(int nIter=0; nIter<list.count(); nIter++)
    {
        this->UI->displayOnConsole(list[nIter].toString());
    }
}

void MainWindow::listenOnTCTMPorts()
{
    QString str;

    //***
    // TC
    analyserSGSEServerTC->listen(QHostAddress::Any, this->UI->getTCPort());
    str = analyserSGSEServerTC->errorString();
    if (!str.isEmpty())
    {
        this->displayOnConsole(str);
    }
    this->displayOnConsole("Listening TC on port "
                           + QString::number(this->UI->getTCPort())
                           );

    //***
    // TM
    analyserSGSEServerTM->listen(QHostAddress::Any, this->UI->getTMPort());
    str = analyserSGSEServerTM->errorString();
    if (!str.isEmpty())
    {
        this->displayOnConsole(str);
    }
    this->displayOnConsole("Listening TM on port "
                           + QString::number(this->UI->getTMPort())
                           );
}

void MainWindow::testTCTMPorts()
{
    if (socketTC != NULL)
    {
        this->displayOnConsole("TC socket *** " + socketStates.at(socketTC->state()) );
    }
    else
    {
        this->displayOnConsole("TC socket *** not tested, (socketTC) is NULL" );
    }
    if (socketTM != NULL)
    {
        this->displayOnConsole("TM socket *** " + socketStates.at(socketTM->state()) );
    }
    else
    {
        this->displayOnConsole("TM socket *** not tested, (socketTM) is NULL" );
    }
}

void MainWindow::newConnectionOnTCServer()
{
    this->displayOnConsole("got new connection on TC port");
    socketTC = analyserSGSEServerTC->nextPendingConnection();
    this->displayOnConsole("TC socket *** " + socketStates.at(socketTC->state()) );
    connect(this->socketTC, SIGNAL(readyRead()), this, SLOT(readDataOnTCPort()));
}

void MainWindow::newConnectionOnTMServer()
{
    this->displayOnConsole("got new connection on TM port");
    socketTM = analyserSGSEServerTM->nextPendingConnection();
    this->displayOnConsole("TM socket *** " + socketStates.at(socketTM->state()) );
    connect(this->socketTM, SIGNAL(readyRead()), this, SLOT(readDataOnTMPort()));

    emit socketTMHasChanged(this->socketTM);
}

void MainWindow::readDataOnTCPort()
{
    bool ok;
    int nbBytesAvailable = 0;

    nbBytesAvailable = socketTC->bytesAvailable();
    buffer = (char *) malloc(nbBytesAvailable);
    socketTC->read(buffer, nbBytesAvailable);

    this->displayOnConsole("readDataOnTCPort *** "
                           + QString::number(nbBytesAvailable)
                           + " read");

    QByteArray xmlData( buffer, nbBytesAvailable);

    free(buffer);

    sourceTC->setData( xmlData );

    xmlReader.setContentHandler(xmlHandler);
    xmlReader.setErrorHandler(xmlHandler);

    ok = xmlReader.parse(sourceTC);
    if (!ok) {
        std::cout << "Parsing failed." << std::endl;
    }
    else {
        QStringList names = xmlHandler->names();
        QList<int> indentations = xmlHandler->indentations();

        int items = names.count();

        for (int i = 0; i < items; ++i) {
            displayOnConsole(
                        names[i]
                        + " --- identations: "
                        + QString::number(indentations[i]));
        }
    }
}

void MainWindow::readDataOnTMPort()
{
    this->displayOnConsole("TM data received, begin parsing");
}

void MainWindow::readDataOnSocketEchoServer()
{
    QString dataString;

    dataArray.append(socketEchoServer->readAll());
    dataString = QString::fromAscii(dataArray);
    this->lfrXmlParser->processIncomingStr(dataString);
    dataArray.clear();
}

void MainWindow::displayOnConsole(QString message)
{
    this->UI->displayOnConsole( message );
}

void MainWindow::initSocketStatesList()
{
    socketStates.append("The socket is not connected");
    socketStates.append("The socket is performing a host name lookup");
    socketStates.append("The socket has started establishing a connection");
    socketStates.append("A connection is established");
    socketStates.append("The socket is bound to an address and port (for servers)");
    socketStates.append("The socket is about to close (data may still be waiting to be written)");
    socketStates.append("For internal use only");
}

void MainWindow::openEchoServer()
{
    socketEchoServer->connectToHost(this->UI->serverTMEchoDialogBox->getIP(),
                                    this->UI->spinbox_serverTMEchoPort->value());
    //socketEchoServer->open();
}

void MainWindow::socket_TMEcho_ServerHasChanged()
{
    this->displayOnConsole("TM Echo Socket socket *** " + socketStates.at(socketEchoServer->state()) );
}

void MainWindow::preProcessPacket(TMPacketToRead *packet)
{
    unsigned char pid = 0;
    unsigned char cat = 0;
    unsigned char typ = 0;
    unsigned char sub = 0;
    unsigned int sid = 0;
    unsigned int length = 0;
    unsigned int coarse_t = 0;
    unsigned int fine_t = 0;

    //*********************************
    // get the parameters of the packet
    pid = ((packet->Value[4] & 0x07) << 4) + ((packet->Value[5] & 0xf0) >> 4);
    cat = packet->Value[5] & 0x0f;
    typ = packet->Value[11];    // TYPE
    sub = packet->Value[12];    // SUBTYPE
    sid = 0;
    length = packet->Value[8] * 256 + packet->Value[9];
    // compare length in the packet with the size of the packet
    if ( (length + 1 + 10) != (packet->size))
    {
        displayOnConsole("reception of " + QString::number(packet->size)
                         + " bytes instead of " + QString::number(length + 1 + 10));
    }
    coarse_t = packet->Value[14] * pow(2, 24) + packet->Value[15] * pow(2, 16)
            + packet->Value[16] * pow(2, 8) + packet->Value[17];
    fine_t = packet->Value[18] * pow(2, 8) + packet->Value[19];

    if ((pid == 76) & (cat == 1) & (typ == 1) & (sub == 8))
            sid = packet->Value[20] * 256 + packet->Value[21];
    else if ((pid == 76) & (cat == 4) & (typ == 3) & (sub == 25))
            sid = 1;
    else if ((pid == 76) & (cat == 12) & (typ == 21) & (sub == 3))
            sid = packet->Value[20];
    else if ((pid == 79) & (cat == 12) & (typ == 21) & (sub == 3))
            sid = packet->Value[20];

    this->UI->tmStatistics->updateStatistics(pid, cat, typ, sub, sid, length, coarse_t, fine_t);

    //***************************************************
    // if the packet is an HK packet, display its content
    if ( (typ == TYPE_HK) & (sub == SUBTYPE_HK) )
    {
        this->UI->hkDisplay->displayPacket(packet);
    }

    //****************************************
    // if the packet is a waveform, display it
    if ( (typ == 21) & (sub == 3) )
    {
        sid = packet->Value[20];    // SID
        switch (sid){
            case SID_NORMAL_SWF_F0:
                buildWFAndDisplay(packet, &wfPacketNormal[0], 0);
                break;
            case SID_NORMAL_SWF_F1:
                buildWFAndDisplay(packet, &wfPacketNormal[1], 1);
                break;
            case SID_NORMAL_SWF_F2:
                buildWFAndDisplay(packet, &wfPacketNormal[2], 2);
                break;
            case SID_NORMAL_CWF_F3:
                buildWFAndDisplay(packet, &wfPacketNormal[3], 3);
                break;
            case SID_BURST_CWF_F2:
                buildWFAndDisplayBurst(packet, &wfPacketBurst);
                break;
            case SID_SBM1_CWF_F1:
                buildWFAndDisplaySBM1(packet, &wfPacketSBM1);
                break;
            case SID_SBM2_CWF_F2:
                buildWFAndDisplaySBM2(packet, &wfPacketSBM2);
                break;
        }
    }
}

void MainWindow::buildWFAndDisplay(TMPacketToRead *packet, WFPacket *wfPacket, unsigned char num_page)
{
    unsigned int i = 0;
    unsigned int j = 0;
    unsigned char *data;
    unsigned char pkt_nr = 0;
    unsigned int blk_nr = 0;

    pkt_nr = packet->Value[23]; // PKT_NR
    blk_nr = packet->Value[30] * 256 + packet->Value[31];
    data = &packet->Value[32]; // start of the first data block;
    j = (pkt_nr-1) * 340;
    for ( i=0; i<blk_nr; i++ ){
        wfPacket->wf_e1[j + i] = (short) ( (data[ (i * BLK_SIZE)     ] << 8) + (data[ (i*BLK_SIZE) + 1])  );
        wfPacket->wf_v[j + i]  = (short) ( (data[ (i * BLK_SIZE)  + 2] << 8) + (data[ (i*BLK_SIZE) + 3])  );
        wfPacket->wf_b1[j + i] = (short) ( (data[ (i * BLK_SIZE)  + 4] << 8) + (data[ (i*BLK_SIZE) + 5])  );
        wfPacket->wf_e2[j + i] = (short) ( (data[ (i * BLK_SIZE)  + 6] << 8) + (data[ (i*BLK_SIZE) + 7])  );
        wfPacket->wf_b3[j + i] = (short) ( (data[ (i * BLK_SIZE)  + 8] << 8) + (data[ (i*BLK_SIZE) + 9])  );
        wfPacket->wf_b2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 10] << 8) + (data[ (i*BLK_SIZE) + 11]) );
    }
    if (pkt_nr == 7)
    {
        this->UI->wfDisplay->displayOnPlot(wfPacket->wf_v,  num_page, 0);
        this->UI->wfDisplay->displayOnPlot(wfPacket->wf_e1, num_page, 1);
        this->UI->wfDisplay->displayOnPlot(wfPacket->wf_e2, num_page, 2);
        this->UI->wfDisplay->displayOnPlot(wfPacket->wf_b1, num_page, 3);
        this->UI->wfDisplay->displayOnPlot(wfPacket->wf_b2, num_page, 4);
        this->UI->wfDisplay->displayOnPlot(wfPacket->wf_b3, num_page, 5);
    }
}

void MainWindow::buildWFAndDisplayBurst(TMPacketToRead *packet, WFPacket *wfPacket)
{
    unsigned int i = 0;
    unsigned int j = 0;
    unsigned char *data;
    static unsigned char pkt_nr = 1;
    unsigned int blk_nr = 0;

    blk_nr = packet->Value[28] * 256 + packet->Value[29];
    data = &packet->Value[30]; // start of the first data block;
    j = (pkt_nr-1) * 340;
    for ( i=0; i<blk_nr; i++ ){
        wfPacket->wf_e1[j + i] = (short) ( (data[ (i * BLK_SIZE)     ] << 8) + (data[ (i*BLK_SIZE) + 1])  );
        wfPacket->wf_v[j + i]  = (short) ( (data[ (i * BLK_SIZE)  + 2] << 8) + (data[ (i*BLK_SIZE) + 3])  );
        wfPacket->wf_b1[j + i] = (short) ( (data[ (i * BLK_SIZE)  + 4] << 8) + (data[ (i*BLK_SIZE) + 5])  );
        wfPacket->wf_e2[j + i] = (short) ( (data[ (i * BLK_SIZE)  + 6] << 8) + (data[ (i*BLK_SIZE) + 7])  );
        wfPacket->wf_b3[j + i] = (short) ( (data[ (i * BLK_SIZE)  + 8] << 8) + (data[ (i*BLK_SIZE) + 9])  );
        wfPacket->wf_b2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 10] << 8) + (data[ (i*BLK_SIZE) + 11]) );
    }
    pkt_nr = pkt_nr + 1;
    if (blk_nr == 8)
    {
        this->UI->wfPageBurst->displayOnPlot(wfPacket->wf_v, 0);
        this->UI->wfPageBurst->displayOnPlot(wfPacket->wf_e1, 1);
        this->UI->wfPageBurst->displayOnPlot(wfPacket->wf_e2, 2);
        this->UI->wfPageBurst->displayOnPlot(wfPacket->wf_b1, 3);
        this->UI->wfPageBurst->displayOnPlot(wfPacket->wf_b2, 4);
        this->UI->wfPageBurst->displayOnPlot(wfPacket->wf_b3, 5);
        pkt_nr = 1;
    }
}

void MainWindow::buildWFAndDisplaySBM1(TMPacketToRead *packet, WFPacket *wfPacket)
{
    unsigned int i = 0;
    unsigned int j = 0;
    unsigned char *data;
    static unsigned char pkt_nr = 1;
    unsigned int blk_nr = 0;

    blk_nr = packet->Value[28] * 256 + packet->Value[29];
    data = &packet->Value[30]; // start of the first data block;
    j = (pkt_nr-1) * 340;
    for ( i=0; i<blk_nr; i++ ){
        wfPacket->wf_e1[j + i] = (short) ( (data[ (i * BLK_SIZE)     ] << 8) + (data[ (i*BLK_SIZE) + 1])  );
        wfPacket->wf_v[j + i]  = (short) ( (data[ (i * BLK_SIZE)  + 2] << 8) + (data[ (i*BLK_SIZE) + 3])  );
        wfPacket->wf_b1[j + i] = (short) ( (data[ (i * BLK_SIZE)  + 4] << 8) + (data[ (i*BLK_SIZE) + 5])  );
        wfPacket->wf_e2[j + i] = (short) ( (data[ (i * BLK_SIZE)  + 6] << 8) + (data[ (i*BLK_SIZE) + 7])  );
        wfPacket->wf_b3[j + i] = (short) ( (data[ (i * BLK_SIZE)  + 8] << 8) + (data[ (i*BLK_SIZE) + 9])  );
        wfPacket->wf_b2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 10] << 8) + (data[ (i*BLK_SIZE) + 11]) );
    }
    pkt_nr = pkt_nr + 1;
    if (blk_nr == 8)
    {
        this->UI->wfPageSBM1->displayOnPlot(wfPacket->wf_v, 0);
        this->UI->wfPageSBM1->displayOnPlot(wfPacket->wf_e1, 1);
        this->UI->wfPageSBM1->displayOnPlot(wfPacket->wf_e2, 2);
        this->UI->wfPageSBM1->displayOnPlot(wfPacket->wf_b1, 3);
        this->UI->wfPageSBM1->displayOnPlot(wfPacket->wf_b2, 4);
        this->UI->wfPageSBM1->displayOnPlot(wfPacket->wf_b3, 5);
        pkt_nr = 1;
    }
}

void MainWindow::buildWFAndDisplaySBM2(TMPacketToRead *packet, WFPacket *wfPacket)
{
    unsigned int i = 0;
    unsigned int j = 0;
    unsigned char *data;
    static unsigned char pkt_nr = 1;
    unsigned int blk_nr = 0;

    blk_nr = packet->Value[28] * 256 + packet->Value[29];
    data = &packet->Value[30]; // start of the first data block;
    j = (pkt_nr-1) * 340;
    for ( i=0; i<blk_nr; i++ ){
        wfPacket->wf_e1[j + i] = (short) ( (data[ (i * BLK_SIZE)     ] << 8) + (data[ (i*BLK_SIZE) + 1])  );
        wfPacket->wf_v[j + i]  = (short) ( (data[ (i * BLK_SIZE)  + 2] << 8) + (data[ (i*BLK_SIZE) + 3])  );
        wfPacket->wf_b1[j + i] = (short) ( (data[ (i * BLK_SIZE)  + 4] << 8) + (data[ (i*BLK_SIZE) + 5])  );
        wfPacket->wf_e2[j + i] = (short) ( (data[ (i * BLK_SIZE)  + 6] << 8) + (data[ (i*BLK_SIZE) + 7])  );
        wfPacket->wf_b3[j + i] = (short) ( (data[ (i * BLK_SIZE)  + 8] << 8) + (data[ (i*BLK_SIZE) + 9])  );
        wfPacket->wf_b2[j + i] = (short) ( (data[ (i * BLK_SIZE) + 10] << 8) + (data[ (i*BLK_SIZE) + 11]) );
    }
    pkt_nr = pkt_nr + 1;
    if (blk_nr == 8)
    {
        this->UI->wfPageSBM2->displayOnPlot(wfPacket->wf_v, 0);
        this->UI->wfPageSBM2->displayOnPlot(wfPacket->wf_e1, 1);
        this->UI->wfPageSBM2->displayOnPlot(wfPacket->wf_e2, 2);
        this->UI->wfPageSBM2->displayOnPlot(wfPacket->wf_b1, 3);
        this->UI->wfPageSBM2->displayOnPlot(wfPacket->wf_b2, 4);
        this->UI->wfPageSBM2->displayOnPlot(wfPacket->wf_b3, 5);
        pkt_nr = 1;
    }
}

void MainWindow::processIncomingPacket(TMPacketToRead *packet)
{
    totalOfBytes = totalOfBytes + packet->size;
    totalOfPackets = totalOfPackets + 1;
    this->UI->totalOfBytesHasChanged(totalOfBytes);
    this->UI->totalOfPacketsHasChanged(totalOfPackets);
    preProcessPacket(packet);
}

void MainWindow::resetStatistics()
{
    totalOfBytes = 0;
    totalOfPackets = 0;
    this->UI->totalOfBytesHasChanged(totalOfBytes);
    this->UI->totalOfPacketsHasChanged(totalOfPackets);
}

void MainWindow::processPacketStore()
{
    TMPacketToRead *packet;
    while(!generalCCSDSPacketStore.isEmpty())
    {
        packet = generalCCSDSPacketStore.takeFirst();
        processIncomingPacket(packet);
        delete(packet);
    }
}