#include "CANDevice.h"
#include "OtarcikCan.h"



CCANDevice::CCANDevice(QObject *parent)
{
    Q_UNUSED(parent)

    mMessageList.clear();
    mMessagesListLoaded = false;
    mCANAnalyzer.mDevicePtr = this;
    mProgramPtr = 0;
}

CCANDevice::CCANDevice(CCANDeviceConfig &SysConfig, CMQTTClientWrapper *MQTTClient, QString DeviceTopicPrefix)
{
    mMessageList.clear();
    mMessagesListLoaded = false;
    mCANAnalyzer.mDevicePtr = this;
    mProgramPtr = 0;

    mDeviceConfigInfo = SysConfig;
    mCANMQTTClient = MQTTClient;
    mDeviceTopicPrefix = DeviceTopicPrefix;
    mCANDriverIF = 0;

}

CCANDevice::~CCANDevice()
{
    mCANDriverIF->DeInit();
    delete mCANDriverIF;

    while (!mMessageList.isEmpty())
    {
        delete mMessageList.takeFirst();
    }
}

int CCANDevice::Init()
{
    if(mDeviceConfigInfo.mCANDeviceID < 0 || mDeviceConfigInfo.mCANDeviceBaudrate < 0 || mDeviceConfigInfo.mDevicePollPeriod == 0 || mDeviceConfigInfo.mCANDeviceDatabaseFilename.isEmpty() == true || mDeviceConfigInfo.mDeviceName.isEmpty() == true)
    {
        qDebug("CCANDevice: trying to initialize a CCANDevice with invalid parameters");
        return RET_GENERAL_ERROR;
    }


    CGeneralMessagesLogDispatcher::instance()->AddLogMessage(QString("Initialisation du dispositif [%1]").arg(mDeviceConfigInfo.mDeviceName));

    CGeneralMessagesLogDispatcher::instance()->AddLogMessage("Démarrage d'un module CAN...");

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

    if(mCANDriverIF->Init(mDeviceHandle,mDeviceConfigInfo.mCANDeviceBaudrate) != 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;
    }


    if(mCANDatabase.Init(mDeviceConfigInfo.mCANDeviceDatabaseFilename) == RET_OK)
    {
        if(mCANDatabase.BuildMessageList(&mMessageList,mDeviceConfigInfo.mDeviceName) == RET_OK)
        {
            mMessagesListLoaded = true;
        }
        else
        {
            mMessagesListLoaded = false;
        }
    }





//    if(mCANAnalyzer.Init(mDeviceConfigInfo.mCANDeviceID,mDeviceConfigInfo.mCANDeviceBaudrate,&mMessageList,mDeviceConfigInfo.mDevicePollPeriod) != RET_OK)
    if(mCANAnalyzer.Init(mCANDriverIF,mDeviceHandle,mDeviceConfigInfo.mCANDeviceID,&mMessageList,mDeviceConfigInfo.mDevicePollPeriod) != RET_OK)
    {
        CGeneralMessagesLogDispatcher::instance()->AddLogMessage(QString("Le dispositif [%1] n'a pas pu s'initialiser").arg(mDeviceConfigInfo.mDeviceName),true,1,CGeneralMessagesLogDispatcher::GEN_MSG_TXT_ERROR_STATUS);
        mProgramPtr->SetCANConnectionStatusRequest(false);
        mProgramPtr->UpdateCANModuleStatusRequest(mDeviceConfigInfo.mDeviceName,"Déconnecté","NOUPDATE");
        return RET_GENERAL_ERROR;
    }

    if(mDeviceConfigInfo.mDeviceWatchdogActivated == true)
    {
        if(mCANWatchdog.Init(mCANDriverIF,mDeviceHandle,mDeviceConfigInfo.mWatchdogPeriod,mDeviceConfigInfo.mWatchdogCANMsgID) != RET_OK)
        {
            CGeneralMessagesLogDispatcher::instance()->AddLogMessage("Impossible d'initialiser un watchdog CAN",true,1,CGeneralMessagesLogDispatcher::GEN_MSG_TXT_ERROR_STATUS);
        }
        mCANWatchdog.StartWDT();

        QString Log = QString("Watchdog CAN initialisé pour le module sur le channel %1").arg(mDeviceConfigInfo.mCANDeviceID);
        CGeneralMessagesLogDispatcher::instance()->AddLogMessage(Log,true,1,CGeneralMessagesLogDispatcher::GEN_MSG_TXT_SUCCESS_STATUS);
    }

    mIsCANInitialized = true;

#ifdef USE_TOPIC_PREFIX
    mCANDataLogger.SetMQTTTopicDevice(QString("%2CANBus/%1/").arg(mDeviceConfigInfo.mDeviceName).arg(mDeviceTopicPrefix));
#else
    mCANDataLogger.SetMQTTTopicDevice(QString("CANBus/%1/").arg(mDeviceConfigInfo.mDeviceName));
#endif
    mCANDataLogger.SetMQTTClient(mCANMQTTClient);
    mProgramPtr->SetCANConnectionStatusRequest(true);
    mProgramPtr->UpdateCANModuleStatusRequest(mDeviceConfigInfo.mDeviceName,"Connecté","NOUPDATE");

    CGeneralMessagesLogDispatcher::instance()->AddLogMessage(QString("Dispositif [%1] initialisé avec succès!").arg(mDeviceConfigInfo.mDeviceName),1,true,CGeneralMessagesLogDispatcher::GEN_MSG_TXT_SUCCESS_STATUS);
    return RET_OK;
}

int CCANDevice::Init(QString DatabaseFileName, TPCANHandle CANDeviceID, TPCANBaudrate CANDeviceBaudRate, QString DevDescription, QString DeviceName, unsigned int DevicePollPeriod)
{
    mDeviceConfigInfo.mCANDeviceID = CANDeviceID;
    mDeviceConfigInfo.mCANDeviceBaudrate = CANDeviceBaudRate;
    mDeviceConfigInfo.mCANDeviceDatabaseFilename = DatabaseFileName;
    mDeviceConfigInfo.mDeviceDescription = DevDescription;
    mDeviceConfigInfo.mDeviceName = DeviceName;
    mDeviceConfigInfo.mDevicePollPeriod = DevicePollPeriod;

    Init();

    return RET_OK;
}

int CCANDevice::NewMessageParsed(int BufferSize)
{
    mCANDataLogger.LogNewData(&mMessageList);
    mProgramPtr->UpdateCANViewerDataRequest(&mMessageList);
    mProgramPtr->UpdateCANModuleStatusRequest(mDeviceConfigInfo.mDeviceName,"NOUPDATE",QString("%1").arg(BufferSize));

    for(int i = 0; i < mMessageList.size(); i++)
        mMessageList.at(i)->mPendingData = false;

    return RET_OK;
}

QList<CMQTTMessage> *CCANDevice::GetMQTTMessagesList()
{
    return mCANDataLogger.GetMQTTMessagesList();
}


QDataStream &operator<<(QDataStream &out, const CCANDevice &source)
{
    out << source.mDeviceConfigInfo;
    return out;
}

QDataStream &operator>>(QDataStream &in, CCANDevice &dest)
{
    in >> dest.mDeviceConfigInfo;
    return in;
}

////CAREFUL!!!  OPERATOR = DOES NOT COPY THE MESSAGES, ONLY THE DEVICE DESCRIPTION !!//
//CCANDevice& CCANDevice::operator=(const CCANDevice *source)
//{
//    if(source == this)
//    {
//        return *this;
//    }

//    this->mDeviceConfigInfo = source->mDeviceConfigInfo;

//    return *this;
//}