#include "CANAnalyzer.h"

#include "GeneralMessagesLogDispatcher.h"
#include "CANDatabase.h"
#include "OtarcikCan.h"


CCANAnalyzer::CCANAnalyzer(QObject *parent) : QObject(parent)
{
 //   mCANDriverIF = new CPCANInterface;
//    mIsCANInitialized = false;
    mDevicePtr = 0;
    mDeviceMessagesList = 0;
    mCANPollPeriod = 0;

    mCANReadTimer = new QTimer;
    mCANReadTimer->setInterval(1000);
    mCANReadTimer->setSingleShot(true);
    connect(mCANReadTimer,SIGNAL(timeout()),this,SLOT(CANTimerExpired()));

    mCANDriverIF = 0;
}

CCANAnalyzer::~CCANAnalyzer()
{
//    mCANDriverIF->DeInit();
//    delete mCANDriverIF;
    delete mCANReadTimer;
 }

int CCANAnalyzer::Init(CPCANInterface *CANDriverIF, quint8 CANDeviceChannel, QList<CCANMessage *> *MsgList, unsigned int PollPeriod)
{
    if(MsgList == 0)
    {
        return RET_GENERAL_ERROR;
    }
    if(PollPeriod < 200)
    {
        PollPeriod = 200;
        qDebug("CANAnalyzer:: Trying to init with poll period lower tan 200ms");
    }

    mCANDeviceChannel = CANDeviceChannel;
    mCANPollPeriod = PollPeriod;
    mCANDriverIF = CANDriverIF;
   // CGeneralMessagesLogDispatcher::instance()->AddLogMessage("Démarrage d'un module CAN...");

    mDeviceMessagesList = MsgList;

//    if(mCANDriverIF->GetDeviceHandle(mCANDeviceChannel,mCANDeviceHandle) != RET_OK)
//    {
//        QString Log = QString("Impossible de trouver le module CAN sur le channel %1").arg(mCANDeviceChannel);
//        CGeneralMessagesLogDispatcher::instance()->AddLogMessage(Log,true,1,CGeneralMessagesLogDispatcher::GEN_MSG_TXT_ERROR_STATUS);
//        mIsCANInitialized = false;
//        return RET_GENERAL_ERROR;
//    }

//    if(mCANDriverIF->Init(mCANDeviceHandle,CANDeviceBaudrate) != RET_OK)
//    {
//        CGeneralMessagesLogDispatcher::instance()->AddLogMessage("Impossible d'initialiser le matériel CAN",true,1,CGeneralMessagesLogDispatcher::GEN_MSG_TXT_ERROR_STATUS);
//        mIsCANInitialized = false;
//        return RET_GENERAL_ERROR;
//    }
//    else
//    {
//        mCANReadTimer->start(mCANPollPeriod);
//        mIsCANInitialized = true;
//    }

    mCANReadTimer->start(mCANPollPeriod);
//    mIsCANInitialized = true;

    return RET_OK;
}

int CCANAnalyzer::ReadCAN()
{
//    TPCANMsg CANMsg;
//    TPCANTimestamp CANTimeStamp;

//    // We execute the "Read" function of the PCANBasic
//    TPCANStatus stsResult = CAN_Read(PcanHandle, &CANMsg, &CANTimeStamp);

//    if (stsResult != PCAN_ERROR_QRCVEMPTY)
//    {
//        // We process the received message
//        ProcessMessageCan(CANMsg, CANTimeStamp);
//    }

//    return stsResult;
    return RET_OK;
}

void CCANAnalyzer::CANTimerExpired()
{
    if(mCANDriverIF == 0)
        return;

    QList<CCANMessage *> NewMessagesList = mCANDriverIF->ReadCANFullBuffer(mCANDeviceHandle);

    int BufferSize = NewMessagesList.size();
//    qDebug("CAN Buffer size: %d",BufferSize);



    for(int i = 0 ; i < NewMessagesList.size(); i++)
    {
        for(int j = 0; j < mDeviceMessagesList->size(); j++)
        {
            if(NewMessagesList.at(i)->mCANMsgID == mDeviceMessagesList->at(j)->mCANMsgID)
            {
                mDeviceMessagesList->at(j)->UpdateValue(NewMessagesList.at(i));
                mDeviceMessagesList->at(j)->mPendingData = true;
            }
        }
    }

    //Don't leak!!
    while(!NewMessagesList.isEmpty())
    {
        delete NewMessagesList.takeFirst();
    }


    mDevicePtr->NewMessageParsed(BufferSize);


    if(NewMessagesList.isEmpty())
    {
         mCANReadTimer->start();
        return;
    }


    NewMessagesList.clear();

    mCANReadTimer->start();

//    mProgramPtr->UpdateCANViewerDataRequest(mLastMessagesList);
}