/*******************************************************************************
*                                                                              *
* Gros Gin électronique                                                  	   *
* 2023                                                                         *
*                                                                              *
* Project: Otarcik CAN                                                         *
*                                                                              *
*                                                                              *
*                                                                              *
*******************************************************************************/
/*
    Description:
    This is our main program

*/

#include "OtarcikCan.h"
#include "PCANBasic.h"
#include "QtEndian"


COtarcikCan::COtarcikCan(QObject *parent) : QObject(parent)
{
    mGPTimer = new QTimer;
    connect(mGPTimer,SIGNAL(timeout()),this,SLOT(GPTimerExpired()));
    mCANBusMQTTClient.mProgramPtr = this;
    mWatchdogTimer = new QTimer;
    connect(mWatchdogTimer,&QTimer::timeout,this,&COtarcikCan::WatchdogUpdateTimerExpired);
    mWatchdogTimer->setSingleShot(false);
    mWatchdogTimer->setInterval(1000);
}

COtarcikCan::~COtarcikCan()
{
    qDebug("Destruction");


    while (!mCANDevicesList.isEmpty())
    {
          delete mCANDevicesList.takeFirst();
    }
    mCANDevicesList.clear();

    mCANBusMQTTClient.DisconnectFromBroker();


    delete mGPTimer;
    delete mWatchdogTimer;
}

int COtarcikCan::Start()
{
    mMainWindow.mCANbusSettingsPage->mProgramPtr = this;
    mMainWindow.mDataLoggingSettingsPage->mProgramHandle = this;
    mMainWindow.mGeneralStatusPage->mProgramPtr = this;
    mMainWindow.mGeneralStatusPage->mCPUInterface = &mCPUInterface;
//    mMainWindow.mCANWatchdogSettingsPage->mProgramHandle = this;

    mMainWindow.show();

    mSysLogger.Start("10.8.0.6",514);
    CGeneralMessagesLogDispatcher::instance()->BindGuiPageHandle(mMainWindow.mGeneralStatusPage);
    CGeneralMessagesLogDispatcher::instance()->Init(&mSysLogger);

    mCPUInterface.Init();

    if(mSystemConfig.LoadConfig() == RET_OK)
    {


        QList<CCANDeviceConfig*> *CANDeviceConfigList;
        CANDeviceConfigList = mSystemConfig.GetCANDevicesConfigList();
        if(CANDeviceConfigList != 0)
        {
            PopulateCANDevicesList(CANDeviceConfigList);
        }
        mMainWindow.mCANbusSettingsPage->SetDevicesList(&mCANDevicesList);
        mMainWindow.mCANViewerPage->InitCANTable(&mCANDevicesList);

        mCloudLoggingParams = *mSystemConfig.GetCloudParams();
        mMainWindow.mDataLoggingSettingsPage->SetCloudParams(&mCloudLoggingParams);
        mCANBusMQTTClient.SetMQTTParams(&mCloudLoggingParams);
        mCANBusMQTTClient.SetCANDevicesList(&mCANDevicesList);
        mCANBusMQTTClient.SetCPUInterface(&mCPUInterface);

        mGeneralSystemParams = *mSystemConfig.GetGeneralSystemSettings();
        mMainWindow.mDataLoggingSettingsPage->SetGeneralSettingsParams(&mGeneralSystemParams);
        CGeneralMessagesLogDispatcher::instance()->SetLogVerbosities(mGeneralSystemParams.mLogFileVerbosity,mGeneralSystemParams.mLocalLogVerbosity);

        mCPUWatchdogParams = *mSystemConfig.GetCPUWatchdogSettings();
        mCPUInterface.SetWatchdogSettings(&mCPUWatchdogParams);
        mMainWindow.mDataLoggingSettingsPage->SetCPUWatchdogSettings(mSystemConfig.GetCPUWatchdogSettings());

 //       mMainWindow.mCANWatchdogSettingsPage->SetCANWatchdogConfig(mSystemConfig.GetCANWatchdogConfig());

//        mGPTimer->setSingleShot(false);
//        mGPTimer->start(5000);

        mCPUInterface.StartCPUWatchdog();
        mWatchdogTimer->start();

        mMainWindow.mGeneralStatusPage->UpdateBoardStatusTimerExpired();

    }
    else
    {
        mCPUInterface.StartCPUWatchdog();
        mWatchdogTimer->start();
    }


    CGeneralMessagesLogDispatcher::instance()->AddLogMessage(QString("Démarrage du logiciel OtarcikCAN"),"CPCANInterface");

//    mCANBusMQTTClient.ConnectToBroker();
    mCANBusMQTTClient.StartMQTTClient();
    mMainWindow.mCANbusSettingsPage->SetDevicesList(&mCANDevicesList);

    connect(&mInternetMonitor,&CInternetMonitor::InternetStateChanged,mMainWindow.mGeneralStatusPage,&CGeneralStatusPage::InternetStatusChanged);
    mInternetMonitor.Start();


    return 0;
}

int COtarcikCan::UpdateCANViewerDataRequest(QList<CCANMessage *> *MsgList)
{
    return mMainWindow.mCANViewerPage->UpdateCANTable(MsgList);

}


//The device configuration has been modified directly in the master list
//Just save it and refresh display.
int COtarcikCan::SaveCANDevicesConfigRequest(QList<CCANDeviceConfig *> *DevicesConfigList)
{

    if(DevicesConfigList == 0)
    {
        return RET_GENERAL_ERROR;
    }

    if(mSystemConfig.SetCANDevicesConfigList(DevicesConfigList) != RET_OK)
    {
        return RET_GENERAL_ERROR;
    }

    if(mSystemConfig.SaveConfig() == RET_OK)
    {
        //Config saving is successful.  To apply changes we need to reload the devices.
        //The easiest way is to delete everything and reload.
         mMainWindow.mGeneralStatusPage->ClearCANModuleStatusTable();
        PopulateCANDevicesList(DevicesConfigList);
        mMainWindow.mCANbusSettingsPage->SetDevicesList(&mCANDevicesList);
        mMainWindow.mCANViewerPage->InitCANTable(&mCANDevicesList);

    }
    else
    {
        return RET_GENERAL_ERROR;
    }

    return RET_OK;
}


int COtarcikCan::PopulateCANDevicesList(QList<CCANDeviceConfig *> *CANDeviceConfigList)
{
    if(CANDeviceConfigList == 0)
    {
        return RET_GENERAL_ERROR;
    }

    while(mCANDevicesList.size() != 0)
    {
        delete mCANDevicesList.takeFirst();
    }

    for(int i = 0; i < CANDeviceConfigList->size(); i++)
    {
        CCANDevice *NewDevice = new CCANDevice(*CANDeviceConfigList->at(i),&mCANBusMQTTClient,mSystemConfig.mCloudLoggingParams.mMQTTTopicPrefix);
        NewDevice->mProgramPtr = this;
        NewDevice->Init();
        mCANDevicesList.append(NewDevice);
    }



    return RET_OK;
}

int COtarcikCan::SaveCloudLoggingConfigRequest(CCloudParams *CloudParams)
{
    if(CloudParams == 0)
    {
        return RET_GENERAL_ERROR;
    }

    mCloudLoggingParams = *CloudParams;
    mSystemConfig.SetCloudParams(&mCloudLoggingParams);
    mCANBusMQTTClient.SetMQTTParams(&mCloudLoggingParams);

    if(mSystemConfig.SaveConfig() == RET_OK)
    {


        //TODO: Reset the MQTT driver with new parameters.
    }
    else
    {
        return RET_GENERAL_ERROR;
    }

    return RET_OK;
}

int COtarcikCan::SaveGeneralParametersSettingsRequest(CGeneralSystemParams *GeneralParams)
{
    mGeneralSystemParams = *GeneralParams;
    mSystemConfig.SetGeneralSystemParams(&mGeneralSystemParams);
    if(mSystemConfig.SaveConfig() == RET_OK)
    {

    }
    else
    {
        return RET_GENERAL_ERROR;
    }
    CGeneralMessagesLogDispatcher::instance()->SetLogVerbosities(mGeneralSystemParams.mLogFileVerbosity,mGeneralSystemParams.mLocalLogVerbosity);

    return RET_OK;
}

int COtarcikCan::SaveCPUWatchdogSettingsRequest(CCPUWatchdogConfig *CPUWatchdogParams)
{
    mCPUWatchdogParams = *CPUWatchdogParams;
    mSystemConfig.SetCPUWatchdogPArams(&mCPUWatchdogParams);
    mSystemConfig.SaveConfig();

    mCPUInterface.SetWatchdogSettings(&mCPUWatchdogParams);
    mCPUInterface.StopCPUWatchdog();
    if(mCPUWatchdogParams.mWatchdogEnabled == true)
    {
        mCPUInterface.StartCPUWatchdog();
    }

    return RET_OK;
}

void COtarcikCan::GPTimerExpired()
{
   // mCANBusMQTTClient.SendMQTTTestMessage();
}

int COtarcikCan::SetCANConnectionStatusRequest(bool Connected)
{
    return mMainWindow.mGeneralStatusPage->SetCANConnectionStatus(Connected);
}

int COtarcikCan::SetMQTTConnectionSatusRequest(bool Connected)
{
    return mMainWindow.mGeneralStatusPage->SetMQTTConnectionStatus(Connected);
}

int COtarcikCan::UpdateCANModuleStatusRequest(QString ModuleName, QString ModuleStatus, QString Buffer)
{
    return mMainWindow.mGeneralStatusPage->UpdateCANModuleStatus(ModuleName,ModuleStatus,Buffer);
}

int COtarcikCan::UpdateMQTTBufferingStatusRequest(QString BufferingMode, QString FIFOSize, QString RemainingTime)
{
    mMainWindow.mGeneralStatusPage->UpdateMQTTBufferingStatus(BufferingMode,FIFOSize,RemainingTime);
    return RET_OK;
}

int COtarcikCan::SaveCANWatchdogSettingsRequest(CCANWatchdogConfig *CANWatchdogConfig)
{
    mSystemConfig.SetCANWatchdogConfig(CANWatchdogConfig);
    return mSystemConfig.SaveConfig();
}

void COtarcikCan::WatchdogUpdateTimerExpired()  //Time to kick the CPU watchdog
{
    mCPUInterface.KickCPUWatchdog();
}

void COtarcikCan::QuitApplicationRequest()
{
    qDebug("Quit app request");
    mWatchdogTimer->stop();
    mCPUInterface.StopCPUWatchdog();
    mCPUInterface.DeInit();

    QCoreApplication::quit();
}