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

#include "Communication/Connection.h"

#include "Drivers/USB_Communication/USBCDCD.h"
#include "drivers/Flash_Memory/FATFS/ff.h"
#include "drivers/Flash_Memory/FATFS/Control_File_System.h"
#include "drivers/Flash_ram/FlashProgram.h"
#include "drivers/adc_sampling/adc.h"
#include "drivers/Heater/TemperatureSensor.h"
#include "drivers/ADC_Sampling/adc.h"
#include "drivers/Flash_ram/MCU_E2Prom.h"
#include "Drivers/SSI_Comm/Dancer/Dancer.h"
#include "Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.h"
#include "Drivers/I2C_Communication/Head_Card/Fan/fan_click.h"
#include "Drivers/I2C_Communication/Head_Card/Fan/Head_Fan.h"
#include "drivers/Motors/Motor.h"
#include "drivers/Valves/Valve.h"
#include "drivers/FPGA/FPGA_SPI_Comm.h"
#include <Drivers/I2C_Communication/I2C.h>
#include <Drivers/I2C_Communication/Head_Card/I2C_Head_Mux.h>
#include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
#include "drivers/adc_sampling/adc.h"
#include <Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.h>
#include <Drivers/I2C_Communication/WHS_Card/WHS_data.h>
#include <Drivers/I2C_Communication/I2C_Task.h>
#include <Drivers/I2C_Communication/WHS_Card/D_AD5272_Rheostat/WHS_Rheostat.h>
#include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
#include <Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.h>
#include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h>
#include "Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h"
#include "drivers/Uart_Comm/WHS_Controller_Comm/WHS_UART/WHS_Uart.h"
#include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h>
#include "drivers/Heater/TemperatureSensor.h"
#include "Drivers/I2C_Communication/Head_Card/PT100/ADS122X04.h"

#include "Modules/IFS/ifs.h"
#include "Modules/IDS/ids_ex.h"
#include "Modules/IDS/ids.h"
#include "Modules/Control/MillisecTask.h"
#include "modules/thread/thread_ex.h"
#include "modules/heaters/heaters_ex.h"
#include "modules/waste/waste_ex.h"
#include "AlarmHandling/AlarmHandling.h"

#include "StateMachines/Initialization/PowerOffSequence.h"
#include "StateMachines/Initialization/PowerIdle.h"

extern HeadBoardTempSensConfigStruc  HeadTempSensConfig[MAX_HEAD_CARD_TEMP_SENS_ID];
extern float NumberOfRotationPerPassage;  // how many rotations per spool passage
extern void HeaterSafetyTestSetLimits(int limit);

//#include "graphics_adapter.h"
extern uint8_t Input_Voltage;
extern uint8_t Test_Read_Buf[4];

extern uint8_t Head_Fan_PWM_Command[2];
extern uint16_t Head_Fan_Tach[2];
extern bool doorState;

uint32_t temp1,temp2;

void Stub_ProcedureRequest(MessageContainer* requestContainer)
{
    MessageContainer responseContainer;
    bool ResetNeeded = false;

    ProcedureRequest* request = procedure_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
    int rc, i,n_param = request->n_param;
    ProcedureResponse response = PROCEDURE_RESPONSE__INIT;
    BTSRParameters *BtsrPrameters = NULL;
    char str[200];
/*  protobuf_c_boolean has_type;
  int32_t type;
  protobuf_c_boolean has_timeout;
  int32_t timeout;
  char *testname;
  size_t n_param;
  float *param;
 * */
    //writeLine("Procedure Request...");
    Report(request->testname,__FILE__,__LINE__,(int)request->type,RpWarning,(int) request->n_param,0);

    if (request->has_type)
    {
        switch (request->type)
        {
        case 1:
            BtsrPrameters = my_malloc(sizeof(BTSRParameters));
            BtsrPrameters->btsryarntype = request->param[0];
            BtsrPrameters->btsrapplicationtype = request->param[1];
            BtsrPrameters->feedingtension = request->param[2];
            BtsrPrameters->exittension =  request->param[3];
            BtsrPrameters->tensionerror = request->param[4];
            BtsrPrameters->threadlengthfactor = request->param[5];
            rc = BtsrSaveParamsToEeprom(BtsrPrameters);
            free(BtsrPrameters);
            response.replymessage = request->testname;
            if (n_param)
            {
                response.replyvalue = (float*)my_malloc(sizeof(float *)*(request->n_param));
                response.n_replyvalue = request->n_param;
                for(i=0;i<n_param;i++)
                {
                    Report(request->testname,__FILE__,__LINE__,(int)request->type,RpWarning,(int) request->n_param,0);
                    response.replyvalue[i] = request->param[i];
                }
            }
            response.time = msec_millisecondCounter;
            response.type = request->type;
            break;
        case 2:
            BtsrPrameters = my_malloc(sizeof(BTSRParameters));
            rc = BtsrReadParamsFromEeprom(BtsrPrameters);
            sprintf(str, "type = %d, app = %d, tension = %f, exittension = %f, tensionerror = %f, lengthfactor = %f", BtsrPrameters->btsryarntype,
                    BtsrPrameters->btsrapplicationtype, BtsrPrameters->feedingtension, BtsrPrameters->exittension, BtsrPrameters->tensionerror, BtsrPrameters->threadlengthfactor);
            response.replymessage = str;
            if (n_param)
            {
                response.replyvalue = (float*)my_malloc(sizeof(float *)*(request->n_param));
                response.n_replyvalue = request->n_param;
                for(i=0;i<n_param;i++)
                {
                    Report(request->testname,__FILE__,__LINE__,(int)request->type,RpWarning,(int) request->n_param,0);
                    response.replyvalue[i] = request->param[i];
                }
            }
            response.time = msec_millisecondCounter;
            response.type = request->type;
            free(BtsrPrameters);
            break;
            default:
                response.replymessage = request->testname;
                if (n_param)
                {
                    response.replyvalue = (float*)my_malloc(sizeof(float *)*(request->n_param));
                    response.n_replyvalue = request->n_param;
                    for(i=0;i<n_param;i++)
                    {
                        Report(request->testname,__FILE__,__LINE__,(int)request->type,RpWarning,(int) request->n_param,0);
                        response.replyvalue[i] = request->param[i];

                    }
                }
                response.time = msec_millisecondCounter;
                response.type = request->type;
                break;
        }
    }

    responseContainer = createContainer(MESSAGE_TYPE__ProcedureResponse, requestContainer->token, true, &response, &procedure_response__pack, &procedure_response__get_packed_size);
    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    my_free(responseContainer.data.data);
    if (response.replyvalue)
        my_free(response.replyvalue);
    if (request)
        procedure_request__free_unpacked(request,NULL);
    //writeLine("Procedure Completed!");
    SendChars((char*)container_buffer, container_size);
    //free(container_buffer);
    if (ResetNeeded == true)
    {
        REPORT_MSG(255,"Update successful, Rebooting in 5 seconds");
        Task_sleep (eOneSecond*5);
        Power_Reset();
        ResetNeeded = false;
    }

    return;

}