#include <PMR/Common/MessageContainer.pb-c.h>
#include "include.h"
#include "driverlib/gpio.h"

//#include "usb_serial_adapter.h"
//#include "graphics_adapter.h"
#include "Modules/Stubs_Handler/Calculate.h"
#include "Modules/Stubs_Handler/Progress.h"
#include "Modules/Stubs_Handler/Stub_Cartridge.h"
#include "Modules/Stubs_Handler/Stub_Dispenser.h"
#include "Modules/Stubs_Handler/Stub_GPIO.h"
#include "Modules/Stubs_Handler/Stub_Heater.h"
#include "Modules/Stubs_Handler/Stub_OptLimitSwitch.h"
#include "Modules/Stubs_Handler/Stub_SteperMotor.h"
#include "Modules/Stubs_Handler/Stub_Valve.h"
#include "Modules/Stubs_Handler/Stub_FPGAReadBackReg.h"
#include "Modules/Stubs_Handler/Stub_FPGAReadVersion.h"
//#include "Modules/Stubs_Handler/Stub_L6470.h"
#include "Modules/Stubs_Handler/Stub_Motor.h"
#include "Modules/Stubs_Handler/Stub_HW_Version.h"
#include "Modules/Stubs_Handler/Stub_FPGARWReg.h"
#include "Modules/Stubs_Handler/Stub_ReadEmbeddedVersion.h"
#include "Modules/Stubs_Handler/Stub_TivaReg.h"
#include "Modules/Stubs_Handler/Stub_Dancer.h"
#include "Modules/Stubs_Handler/Stub_SpeedSensor.h"
#include "Modules/Stubs_Handler/Stub_IntADC.h"
#include "Modules/Stubs_Handler/StubRealTimeUsage.h"
#include "Modules/Stubs_Handler/Stub_TempSensor.h"
#include "Modules/Stubs_Handler/Stub_I2C.h"
#include "Modules/Stubs_Handler/Stub_MidTankPressureSensor.h"

#include "Modules/General/GeneralHardware.h"
#include "Modules/General/MachineStatus.h"
#include "Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h"
#include "Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.h"

#include "Modules/heaters/heaters_ex.h"
#include "Modules/AlarmHandling/AlarmHandling.h"
#include "modules/Diagnostics/Diagnostics.h"

#include "Modules/General/process.h"
#include "Modules/Thread/Thread_ex.h"
#include "Modules/Ids/Ids_ex.h"
#include "Modules/waste/waste_ex.h"
#include "Modules/Ifs/Ifs.h"

#include "Common/SWUpdate/FileSystem.h"
#include "Common/SWUpdate/FirmwareUpgrade.h"
#include "Communication/CommunicationTask.h"

#include "drivers/Flash_ram/MCU_E2Prom.h"

#include "StateMachines/Printing/PrintingSTM.h"
#include "StateMachines/Initialization/PowerIdle.h"
#include "StateMachines/Initialization/PowerOffSequence.h"
#include "StateMachines/Initialization/InitSequence.h"

#include "Common/report/report.h"
#include "Connection.h"
#include "Modules/IFS/ifs.h"

#define  MAX_CONT_LOG 199

/*uint16_t TxmsgId[MAX_CONT_LOG+1] = {0};
uint16_t TxLength[MAX_CONT_LOG+1] = {0};
uint32_t TxAddr[MAX_CONT_LOG+1] = {0};
uint16_t Txindex = 0;
uint32_t msgId[MAX_CONT_LOG+1] = {0};
uint32_t Length[MAX_CONT_LOG+1] = {0};
uint32_t DataLength[MAX_CONT_LOG+1] = {0};
byte RxIndex = 0;*/


MessageContainer createContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*))
{
    MessageContainer container = MESSAGE_CONTAINER__INIT;
    container.completed = completed;
    container.token = token;
    container.has_completed = true;
    container.has_data = true;
    container.has_type = true;
    container.type = type;

    uint8_t* response_buffer = my_malloc((*sizePtr)(response));
    size_t response_size = 0;
    if (response_buffer)
    {
        response_size = (*packPtr)(response, response_buffer);
    }
        container.data.data = response_buffer;
        container.data.len = response_size;

    /*if (SuspendLargeMessages == true)
    {
//        Report("EndJobMessage",__FILE__,__LINE__,(int)type,RpWarning,(int)response_size,0);
        TxmsgId[Txindex] = type;
        TxLength[Txindex] = response_size;
        TxAddr[Txindex] = msec_millisecondCounter;
        if (Txindex++>=MAX_CONT_LOG)
            Txindex = 0;
    }*/

    //free(response);
    return container;
}
MessageContainer createAllocatedContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*),uint8_t* response_buffer)
{
    MessageContainer container = MESSAGE_CONTAINER__INIT;
    container.completed = completed;
    container.token = token;
    container.has_completed = true;
    container.has_data = true;
    container.has_type = true;
    container.type = type;

    //uint8_t* response_buffer = my_malloc((*sizePtr)(response));
    size_t response_size = 0;
    if (response_buffer)
    {
        response_size = (*packPtr)(response, response_buffer);
    }
        container.data.data = response_buffer;
        container.data.len = response_size;

    /*if (SuspendLargeMessages == true)
    {
//        Report("EndJobMessage",__FILE__,__LINE__,(int)type,RpWarning,(int)response_size,0);
        TxmsgId[Txindex] = type;
        TxLength[Txindex] = response_size;
        TxAddr[Txindex] = msec_millisecondCounter;
        if (Txindex++>=MAX_CONT_LOG)
            Txindex = 0;
    }*/

    //free(response);
    return container;
}

void receive_callback(char* buffer, size_t length)
{

     MessageContainer* requestContainer = message_container__unpack(NULL, length, (uint8_t*)buffer);
     if (requestContainer == NULL)
         return;
#ifndef DISPESER_TEST
    if ((requestContainer->type>= MESSAGE_TYPE__StartDiagnosticsRequest)&&(requestContainer->type != MESSAGE_TYPE__KeepAliveRequest)&&(requestContainer->type != MESSAGE_TYPE__KeepAliveResponse)) //user action resets the idle counter
    {
         ReportWithPackageFilter(CommFilter,"Message received", __FILE__,__LINE__,requestContainer->type, RpMessage,length, 0);
    }
#endif
    if (requestContainer->type != MESSAGE_TYPE__KeepAliveRequest)
        resetIdleCounter();
    //ReportWithPackageFilter(CommFilter,"Message received", __FILE__,__LINE__,requestContainer->type, RpMessage,length, 0);
    KeepAliveOneSecondCounter = 0;
     /*msgId[RxIndex] = requestContainer->type;
     Length[RxIndex] = length;
     DataLength[RxIndex] = msec_millisecondCounter;
     if (RxIndex++>=MAX_CONT_LOG)
         RxIndex = 0;*/
     switch(requestContainer->type)
     {
         case MESSAGE_TYPE__CalculateRequest:
             Stub_CalculateRequest(requestContainer);
             break;
         case MESSAGE_TYPE__ProgressRequest:
             Stub_ProgressRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubCartridgeReadRequest:
             Stub_CartridgeReadRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubCartridgeWriteRequest:
             Stub_CartridgeWriteRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubDispenserRequest:
             Stub_DispenserRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubGPIOInputSetupRequest:
             Stub_GPIOInputSetupRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubGPIOReadBitRequest:
             Stub_GPIOReadBitRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubGPIOReadByteRequest:
             Stub_GPIOReadByteRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubGPIOWriteBitRequest:
             Stub_GPIOWriteBitRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubGPIOWriteByteRequest:
             Stub_GPIOWriteByteRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubHeaterRequest:
             Stub_HeaterRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubI2CRequest:
             Stub_I2CRequest(requestContainer);
             break;
//         case MESSAGE_TYPE__StubOptLimitSwitchRequest:
//             Stub_OptLimitSwitchRequest(requestContainer);
//             break;
//         case MESSAGE_TYPE__StubSteperMotorRequest:
//             Stub_SteperMotorRequest(requestContainer);
//             break;
         case MESSAGE_TYPE__StubValveRequest:
             Stub_ValveRequest(requestContainer);
             break;
//		case MESSAGE_TYPE__StubFPGAReadBackRegRequest:
//             Stub_FPGAReadBackRegRequest(requestContainer);
//             break;
         case MESSAGE_TYPE__StubFPGAReadVersionRequest:
             Stub_FPGAReadVersionRequest(requestContainer);
             break;
             /*************************************/
         case MESSAGE_TYPE__StubFpgaReadRegRequest:
             Stub_FpgaReadRegRequest(requestContainer);
             break;
         case    MESSAGE_TYPE__StubFpgaWriteRegRequest:
             Stub_FpgaWriteRegRequest(requestContainer);
             break;
             /*************************************/
//         case MESSAGE_TYPE__StubL6470DriverRequest:
//             Stub_L6470DriverRequest(requestContainer);
//             break;
         case MESSAGE_TYPE__StubMotorInitRequest:
             Stub_MotorInitRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorRunRequest:
             Stub_MotorRunRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorStopRequest:
             Stub_MotorStopRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorStatusRequest:
             Stub_MotorStatusRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorPositionRequest:
             Stub_MotorPositionRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorSpeedRequest:
             Stub_MotorSpeedRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorRequest:
             Stub_MotorRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubMotorMovRequest:
             Stub_MotorMovRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubJobRequest:
             Stub_JobRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubAbortJobRequest:
             Stub_AbortJobRequest(requestContainer);
             break;
//         case MESSAGE_TYPE__StubHWVersionRequest:
//             Stub_HWVersionRequest(requestContainer);
//             break;
         case MESSAGE_TYPE__StartDebugLogRequest:
             ReportInitMessage(requestContainer);
             break;
         case MESSAGE_TYPE__StopDebugLogRequest:
             StopReportInitMessage(requestContainer);
             break;
         case MESSAGE_TYPE__SetDebugLogCategoryRequest:
             SetDebugLogCategoryFunc(requestContainer);
             break;
         case MESSAGE_TYPE__SetupDebugDisributorsRequest:
             SetupDebugDisributorsRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__JobRequest:
             JobRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__AbortJobRequest:
             JobAbortFunc(requestContainer);
             break;
         case MESSAGE_TYPE__CurrentJobRequest:
             CurrentJobRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ResumeCurrentJobRequest:
             ResumeCurrentJobRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StartHeadCleaningRequest:
             ThreadCleaningJobFunc(requestContainer);
             break;
         case MESSAGE_TYPE__AbortHeadCleaningRequest:
             ThreadCleaningAbortJobFunc(requestContainer);
             break;
         case MESSAGE_TYPE__UploadHardwareConfigurationRequest:
             HWConfigurationFunc(requestContainer);
             break;
         case MESSAGE_TYPE__UploadProcessParametersRequest:
             ProcessRequestFunc(requestContainer);
             break;
             //functions stolen for thread load process tests
//             void ThreadLoadPollRequest(MessageContainer* requestContainer)
//             void ThreadLoadRequest(MessageContainer* requestContainer)
//             HeatingTestRequest(requestContainer);
//             HeatingTestPollRequest(requestContainer);
         case MESSAGE_TYPE__StubHeatingTestRequest:
             ThreadLoadRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubHeatingTestPollRequest:
             ThreadLoadPollRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubReadEmbeddedVersionRequest:
             Stub_ReadEmbeddedVersionRequest(requestContainer);
             break;
         case MESSAGE_TYPE__SystemResetRequest:
             HWSystemResetRequest(requestContainer);
             break;
//         case MESSAGE_TYPE__StubTivaReadRegRequest:
//             Stub_TivaReadRegRequest(requestContainer);
//             break;
//         case MESSAGE_TYPE__StubTivaWriteRegRequest:
//             Stub_TivaWriteRegRequest(requestContainer);
//             break;
         case MESSAGE_TYPE__StubDancerPositionRequest:
             Stub_DancerPositionRequest(requestContainer);
             break;
//         case MESSAGE_TYPE__StubSpeedSensorRequest:
//             Stub_SpeedSensorRequest(requestContainer);
//             break;
         case MESSAGE_TYPE__StubRealTimeUsageRequest:
             Stub_RealTimeUsageRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubIntADCReadRequest:
             Stub_IntADCReadRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubTempSensorRequest:
             Stub_TempSensorRequest(requestContainer);
             break;
         case MESSAGE_TYPE__ConnectRequest:
             ConnectionRequest(requestContainer);
             break;
         case MESSAGE_TYPE__DisconnectRequest:
             DisconnectionRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StartDiagnosticsRequest:
             StartDiagnosticsRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StopDiagnosticsRequest:
             StopDiagnosticsRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StartEventsNotificationRequest:
             StartEventsNotificationRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__SetHeaterStateRequest:
             SetHeaterStateRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StopEventsNotificationRequest:
             StopEventsNotificationRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ResolveEventRequest:
             ResolveEventRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__MotorAbortHomingRequest:
            MotorAbortHomingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__MotorHomingRequest:
            MotorHomingRequestFunc(requestContainer);
            break;
         case MESSAGE_TYPE__MotorJoggingRequest:
            MotorJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__MotorAbortJoggingRequest:
            MotorAbortJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__DispenserAbortHomingRequest:
            DispenserAbortHomingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__DispenserHomingRequest:
            DispenserHomingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__DispenserJoggingRequest:
            DispenserJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__DispenserAbortJoggingRequest:
            DispenserAbortJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__SetComponentValueRequest:
             SetComponentValueRequestRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__SetDigitalOutRequest:
             SetDigitalOutRequestRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__SetValveStateRequest:
             SetValveStateRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__SetBlowerStateRequest:
             SetBlowerStateRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ThreadJoggingRequest:
             ThreadJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ThreadAbortJoggingRequest:
             ThreadAbortJoggingRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StubI2CReadBytesRequest:
             Stub_I2CReadBytesRequest(requestContainer);
             break;
         case MESSAGE_TYPE__StubI2CWriteBytesRequest:
             Stub_I2CWriteBytesRequest(requestContainer);
             break;
         case MESSAGE_TYPE__KeepAliveRequest:
             KeepAliveRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__KeepAliveResponse:
             KeepAliveResponseFunc(requestContainer);
             break;
         case MESSAGE_TYPE__FileUploadRequest:
             FileUploadRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__FileChunkUploadRequest:
             FileChunkUploadRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__FileDownloadRequest:
             FileDownloadRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__FileChunkDownloadRequest:
             FileChunkDownloadRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ExecuteProcessRequest:
             ExecuteProcessRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__KillProcessRequest:
             KillProcessRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__CreateRequest:
             CreateRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__DeleteRequest:
             DeleteRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__GetStorageInfoRequest:
             GetStorageInfoRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__GetFilesRequest:
             GetFilesRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ActivateVersionRequest:
             ActivateVersionRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ValidateVersionRequest:
             ValidateVersionRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StubMidTankPressureSensorRequest:
             Stub_MidTankPressureSensorRequest(requestContainer);
             break;
         case MESSAGE_TYPE__DispenserDataRequest:
             DispenserDataRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__CartridgeValidationResponse:
             CartridgeValidationResponseFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StartInkFillingStatusRequest:
             StartInkFillingStatusRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__MidTankDataSetupRequest:
             MidTankDataSetupFunc(requestContainer);
             break;
         case MESSAGE_TYPE__MachineCalibrationDataRequest:
             MachineCalibrationDataRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__MainCardStoredDataRequest:
             MainCardStoredItemRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StartMachineStatusUpdateRequest:
             MachineUpdateInitFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StopMachineStatusUpdateRequest:
             StopMachineUpdateFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StartPowerDownRequest:
             PowerDownUpdateFunc(requestContainer);
             break;
         case MESSAGE_TYPE__AbortPowerDownRequest:
             AbortPowerDownFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StartPowerUpRequest:
             PowerUpUpdateFunc(requestContainer);
             break;
         case MESSAGE_TYPE__AbortPowerUpRequest:
             AbortPowerUpFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StartThreadLoadingRequest:
             StartThreadLoadingFunc(requestContainer);
             break;
         case MESSAGE_TYPE__ContinueThreadLoadingRequest:
             ContinueThreadLoadingFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StopThreadLoadingRequest:
             StopThreadLoadingFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StubDispenserEEpromRequest:
             StubDispenserEEpromRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StubWhsEEpromRequest:
             WhsEEpromRequestFunc(requestContainer);
             break;
       case MESSAGE_TYPE__StubMainCardEEpromReadRequest:
             MainCardEEpromReadRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__StubMainCardEEpromWriteRequest:
             MainCardEEpromWriteRequestFunc(requestContainer);
             break;
         case MESSAGE_TYPE__TryThreadLoadingRequest:
             TryThreadLoadingFunc(requestContainer);
             break;
         default:
             //unsupported message type !!
             LOG_ERROR (requestContainer->type,"unsupported message type");
             break;
     }
     message_container__free_unpacked(requestContainer, NULL);

}
bool SendResult,KeepSendResult = true;
/*uint16_t SendmsgId[MAX_CONT_LOG+1] = {0};
uint16_t SendSize[MAX_CONT_LOG+1] = {0};
uint32_t SendTime[MAX_CONT_LOG+1] = {0};
bool Sendresult[MAX_CONT_LOG+1] = {0};
uint16_t Sendindex = 0;*/
bool SendChars(char* buffer,size_t length)
{
/*    SendmsgId[Sendindex] = 0xFFFF;
    SendSize[Sendindex] = length;
    SendTime[Sendindex] = msec_millisecondCounter;
    if (Sendindex++>=MAX_CONT_LOG)
        Sendindex = 0;*/
    SendResult = CommunicationTaskSendMessage(buffer, length);
    if (SendResult == false)
        KeepSendResult = false;
    return SendResult;
}
bool SendCharsWithType(char* buffer,size_t length,MessageType type)
{
//    SendmsgId[Sendindex] = type;
//    SendSize[Sendindex] = length;
//    SendTime[Sendindex] = msec_millisecondCounter;

    SendResult = CommunicationTaskSendMessage(buffer, length);

//    Sendresult[Sendindex] = SendResult;
    //if (Sendindex++>=MAX_CONT_LOG)
    //    Sendindex = 0;
    if (SendResult == false)
        KeepSendResult = false;
    return SendResult;
}