/*------------------------------------------------------------------------------
--  This file is a part of the LPPMON Software
--  Copyright (C) 2012, Laboratory of Plasma Physics - CNRS
--
--  This program is free software; you can redistribute it and/or modify
--  it under the terms of the GNU General Public License as published by
--  the Free Software Foundation; either version 3 of the License, or
--  (at your option) any later version.
--
--  This program is distributed in the hope that it will be useful,
--  but WITHOUT ANY WARRANTY; without even the implied warranty of
--  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--  GNU General Public License for more details.
--
--  You should have received a copy of the GNU General Public License
--  along with this program; if not, write to the Free Software
--  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-------------------------------------------------------------------------------*/
/*--                  Author : Paul LEROY
--                     Mail : paul.leroy@lpp.polytechnique.fr
----------------------------------------------------------------------------*/
#include "rmapplugin.h"
#include <QHostAddress>
#include <QIODevice>
#include <QApplication>
#include <rmappluginpythonwrapper.h>
#include <PythonQt.h>
#include <QTimer>
#include <lppmonproxy.h>

rmapplugin::rmapplugin(QWidget *parent)
  :lppmonplugin(parent,false)
{
    this->UI = new rmapPluginUI();
    this->setWindowTitle(tr("RMAP and SPW Communication"));
    this->setWidget((QWidget*)this->UI);

    scanDone = false;
    timeCode = 0;
    time_COARSE = 0;
    time_FINE = 0;
    currentBridge = selectedBridgeIsUnknown;

    connectPythonWrapper();

    //**************
    // get a smart pointer to the __main__ module of the Python interpreter
    PythonQtObjectPtr context = PythonQt::self()->getMainModule();
    // add a QObject as variable of name "BUTTON_rmapOpenCommunication" to the namespace of the __main__ module
    context.addObject("BUTTON_rmapOpenCommunication", UI->rmapOpenCommunicationButton);
    context.addObject("BUTTON_rmapCloseCommunication", UI->rmapCloseCommunicationButton);
    context.addObject("BUTTON_selectStarDundee", UI->selectStarDundee_BUTTON);
    context.addObject("BUTTON_selectGRESB", UI->selectGRESB_BUTTON);
    context.addObject("GRESB_Bridge", UI->gresbBridge);
    //**************

    connect(UI->rmapOpenCommunicationButton, SIGNAL(clicked()), this, SLOT(openBridge()));
    connect(UI->rmapCloseCommunicationButton, SIGNAL(clicked()), this, SLOT(closeBridge()));
    connect(this, SIGNAL(
                updateStatistics(unsigned char,unsigned char,unsigned char,unsigned char,uint,uint,uint,uint)
                ),
            this->UI->tmStatistics, SLOT(
                updateStatistics(unsigned char,unsigned char,unsigned char,unsigned char,uint,uint,uint,uint)
                ));

    //******
    // GRESB
    connect(this->UI->gresbBridge, SIGNAL(sendMessage(QString)), this, SLOT(displayOnConsole(QString)));
    connect(this->UI->gresbBridge, SIGNAL(RMAP_write_reply_setText(QString)), this, SLOT(RMAP_write_reply_setText(QString)));
    connect(this->UI->gresbBridge, SIGNAL(appendToLog(QString)), this, SLOT(appendToLog(QString)));
    connect(this, SIGNAL(ccsdsPacketIsProcessed()), this->UI->gresbBridge, SLOT(ccsdsPacketIsProcessed()));
    connect(this->UI->rmapTargetLogicalAddressSpinBox, SIGNAL(valueChanged(int)),
            this->UI->gresbBridge, SLOT(targetHasChanged(int)));
    connect(this->UI->rmapSourceLogicalAddressSpinBox, SIGNAL(valueChanged(int)),
            this->UI->gresbBridge, SLOT(sourceHasChanged(int)));
    connect(this->UI->gresbBridge, SIGNAL(sendPacket(TMPacketToRead*)),
            this, SLOT(receivePacketFromBridge(TMPacketToRead*)), Qt::DirectConnection);

    //************
    // Star Dundee
    connect(this->UI->starDundee, SIGNAL(sendMessage(QString)), this, SLOT(displayOnConsole(QString)));
    connect(this->UI->starDundee, SIGNAL(RMAP_write_reply_setText(QString)), this, SLOT(RMAP_write_reply_setText(QString)));
    connect(this->UI->starDundee, SIGNAL(appendToLog(QString)), this, SLOT(appendToLog(QString)));
    connect(this, SIGNAL(ccsdsPacketIsProcessed()), this->UI->starDundee, SLOT(ccsdsPacketIsProcessed()));
    connect(this->UI->rmapTargetLogicalAddressSpinBox, SIGNAL(valueChanged(int)),
            this->UI->starDundee, SLOT(targetHasChanged(int)));
    connect(this->UI->rmapSourceLogicalAddressSpinBox, SIGNAL(valueChanged(int)),
            this->UI->starDundee, SLOT(sourceHasChanged(int)));
    connect(this, SIGNAL(spaceWireLinkNumberHasChanged(unsigned char)),
            this->UI->starDundee, SLOT(spaceWireLinkHasChanged(unsigned char)), Qt::DirectConnection);
    connect(this->UI->starDundee, SIGNAL(sendPacket(TMPacketToRead*)),
            this, SLOT(receivePacketFromBridge(TMPacketToRead*)), Qt::DirectConnection);

    connect(this->UI, SIGNAL(bridgeHasChanged(selectedBridge)), this, SLOT(bridgeHasChanged(selectedBridge)));

    ((rmappluginPythonWrapper*)this->pyObject)->ccsdsPacketStore = &(this->generalCCSDSPacketStore);

    //************
    // LFR ACtions
    connect(this->UI->lfrActions, SIGNAL(WriteSPWSig(char*,uint,char,char)),
            this, SLOT(WriteSPW(char*,uint,char,char)));

}

rmapplugin::~rmapplugin()
{
    switch(currentBridge)
    {
    case selectedBridgeIsGRESB :
        this->UI->gresbBridge->writeSettings();
        break;
    case selectedBridgeIsStarDundee :
        break;
    default:
        break;
    }
    this->UI->tmStatistics->writeSettings();
}

unsigned int rmapplugin::Write(unsigned int *Value, unsigned int count, unsigned int address)
{
    unsigned int result;
    switch(currentBridge)
    {
    case selectedBridgeIsGRESB :
        result = UI->gresbBridge->Write(Value, count, address);
        break;
    case selectedBridgeIsStarDundee :
        result = UI->starDundee->Write(Value, count, address);
        break;
    default:
        result = 1;
        break;
    }
    return result;
}

unsigned int rmapplugin::Read(unsigned int *Value, unsigned int count, unsigned int address)
{
    unsigned int result;
    switch(currentBridge)
    {
    case selectedBridgeIsGRESB :
        result = UI->gresbBridge->Read(Value, count, address);
        break;
    case selectedBridgeIsStarDundee :
        result = UI->starDundee->Read(Value, count, address);
        break;
    default:
        result = 1;
        break;
    }
    return result;
}

////////
// SLOTS

unsigned int rmapplugin::WriteSPW(char *Value, unsigned int count, char targetLogicalAddress, char userApplication) // SLOT
{
    unsigned int result;
    switch(currentBridge)
    {
    case selectedBridgeIsGRESB :
        result = UI->gresbBridge->WriteSPW(Value, count, targetLogicalAddress, userApplication);
        break;
    case selectedBridgeIsStarDundee :
        result = UI->starDundee->WriteSPW(Value, count, targetLogicalAddress, userApplication);
        break;
    default:
        result = 1;
        break;
    }
    return result;
}

void rmapplugin::openBridge()
{
    switch(currentBridge)
    {
    case selectedBridgeIsGRESB :
        this->Connected = this->UI->gresbBridge->Open();
        break;
    case selectedBridgeIsStarDundee :
        this->Connected = this->UI->starDundee->Open();
        break;
    default:
        break;
    }
    if((this->scanDone==false)&&(this->Connected == true))
    {
        lppmonproxy::loadChildSysDriver(this,"AMBA_PLUGIN");
        this->scanDone=true;
    }
    emit activateSig( this->Connected );
}

void rmapplugin::closeBridge()
{
    switch(currentBridge)
    {
    case selectedBridgeIsGRESB :
        this->UI->gresbBridge->Close();
        break;
    case selectedBridgeIsStarDundee :
        this->UI->starDundee->Close();
        break;
    default:
        break;
    }
    this->Connected = false;
    emit activateSig( this->Connected );
}

void rmapplugin::RMAP_write_reply_setText(QString text)
{
    this->UI->RMAP_write_reply->setText(text);
}

void rmapplugin::appendToLog(QString text)
{
    APPENDTOLOG(text);
}

void rmapplugin::setValueTargetAddress(unsigned char newAddress)
{
    this->UI->rmapTargetLogicalAddressSpinBox->setValue(newAddress);
}

void rmapplugin::setValueSourceAddress(unsigned char newAddress)
{
    this->UI->rmapSourceLogicalAddressSpinBox->setValue(newAddress);
}

void rmapplugin::setValueSpaceWireLinkNumber(unsigned char linkNumber)
{
//    this->UI->spwLinkSpinBox->setValue( linkNumber );
    emit this->spaceWireLinkNumberHasChanged( linkNumber );
}

void rmapplugin::receivePacketFromBridge(TMPacketToRead *packet)
{
    preProcessPacket(packet);

    // Send the packet to the TM echo bridge for processing
    this->UI->tmEchoBridge->sendTMPacketLESIA(packet);

    this->generalCCSDSPacketStore.append(packet);
    if (this->generalCCSDSPacketStore.size() > 200)
    {
        this->generalCCSDSPacketStore.erase(generalCCSDSPacketStore.begin(),
                                            generalCCSDSPacketStore.begin() + 100);
    }
    this->UI->nbPacketInStore->setText("nb packets in store: " + QString::number(generalCCSDSPacketStore.size()));
    processPacketStore();
}

void rmapplugin::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         = this->UI->tmStatistics->getPID( packet );
    cat         = this->UI->tmStatistics->getCAT( packet );
    typ         = this->UI->tmStatistics->getTYPE( packet );
    sub         = this->UI->tmStatistics->getSUBTYPE( packet );
    length      = this->UI->tmStatistics->getLENGTH( packet );
    coarse_t    = this->UI->tmStatistics->getCoarseTime( packet );
    fine_t      = this->UI->tmStatistics->getFineTime( packet );
    sid         = this->UI->tmStatistics->getSID( packet, pid, cat, typ, sub );

    emit updateStatistics(pid, cat, typ, sub, sid, length, coarse_t, fine_t);

    //**********************************************
    // if the packet is a parameter dump, display it
    if ( (typ == TM_TYPE_PARAMETER_DUMP) & (sub == TM_SUBTYPE_PARAMETER_DUMP) & (sid == SID_PARAMETER_DUMP) )
        this->UI->lfrActions->parameterDump->updateParameterDump(packet);

    if ( (typ == TC_TYPE_TIME) & (sub == TC_SUBTYPE_UPDT_TIME) )    // RE-EMIT THE TC_LFR_UPDATE_TIME PACKET
    {
        emit spaceWireLinkNumberHasChanged( LFR_SPACEWIRE_LINK );
        WriteSPW( (char *) &packet->Value[CCSDS_PROTOCOLE_EXTRA_BYTES],
                  packet->size - CCSDS_PROTOCOLE_EXTRA_BYTES,
                  DEFAULT_TARGET, CCSDS_USER_APP );
    }
}

void rmapplugin::nbPacketHasChanged(int nb)
{
    this->UI->nbPacketInStore->setText("nb packets in store: " + QString::number(nb));
}

/////////////////////
// INTERNAL FUNCTIONS

void rmapplugin::processCCSDSPacket(unsigned char *ccsdsPacket, unsigned int size) // SLOT
{
    QString message;
    unsigned int fine_time_value = 0;
    fine_time_value = ((unsigned int) ccsdsPacket[7]<<24)
            + ((unsigned int) ccsdsPacket[6]<<16)
            + ((unsigned int) ccsdsPacket[5]<<8)
            + ((unsigned int) ccsdsPacket[4]);
    message.append(QTime::currentTime().toString() +":" + QString::number(QTime::currentTime().msec()) + ": ");
    message.append("size "
                   + QString::number(size)
                   +" *** header "
                   + QString::number(ccsdsPacket[0], 16)
                   + " "
                   + QString::number(ccsdsPacket[1], 16)
                   + " "
                   + QString::number(ccsdsPacket[2], 16)
                   + " "
                   + QString::number(ccsdsPacket[3], 16)
                   + " *** coarse time "
                   + QString::number(fine_time_value));
                   //+ QString::number(ccsdsPacket[4], 16)
                   //+" "
                   //+ QString::number(ccsdsPacket[5], 16)
                   //+" "
                   //+ QString::number(ccsdsPacket[6], 16)
                   //+" "
                   //+ QString::number(ccsdsPacket[7], 16));
    displayOnConsole(message);
    //((rmappluginPythonWrapper*)this->pyObject)->storeCCSDSPacket(ccsdsPacket, size);
    emit ccsdsPacketIsProcessed();
}

void rmapplugin::processPacketStore()
{
    ((rmappluginPythonWrapper*)this->pyObject)->processPacketStore();
}

int rmapplugin::fetchPacket()
{
    int ret = 0;

    switch(currentBridge)
    {
    case selectedBridgeIsGRESB :
        break;
    case selectedBridgeIsStarDundee :
        ret = this->UI->starDundee->receiveSPWPacketLoop();
        break;
    default:
        break;
    }

    return ret;
}

void rmapplugin::connectPythonWrapper()
{
    this->pyObject = new rmappluginPythonWrapper(this);
//    connect( this->pyObject, SIGNAL( ReadSig(uint*,uint,uint) ), this, SLOT( Read(uint*,uint,uint) ) );
//    connect( this->pyObject, SIGNAL( WriteSig(uint*,uint,uint) ), this, SLOT( Write(uint*,uint,uint) ) );
    //**
    connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL( WriteSPWSig(char*,uint,char,char) ),
            this, SLOT( WriteSPW(char*,uint,char,char) ), Qt::DirectConnection );
    //**
    connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL( updateTargetLogicalAddress(unsigned char) ),
            this, SLOT( setValueTargetAddress(unsigned char) ) );
    //**
    connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL( updateSourceLogicalAddress(unsigned char) ),
            this, SLOT( setValueSourceAddress(unsigned char) ) );
    //**
    connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL( updateSpaceWireLinkNumber(unsigned char) ),
            this, SLOT( setValueSpaceWireLinkNumber(unsigned char) ) );
    //**
    connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL(sendMessage(QString)),
             this, SLOT(displayOnConsole(QString)) );
    //**
    connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL(fetchPacketSig()),
             this, SLOT(fetchPacket()), Qt::DirectConnection );
    //***
    connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL(nbPacketHasChanged(int)),
             this, SLOT(nbPacketHasChanged(int)));

    //**********
    // TIMECODES
    connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL(sig_sendOneTimecode()),
             this->UI->starDundee, SLOT(sendOneTimecode()) );
    connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL(sig_sendTimecodePeriodically(unsigned char)),
             this->UI->starDundee, SLOT(startSendingTimecodePeriodically(unsigned char)) );
}