/************************************************************************************************************************
 * control.c
 * Control module
 *
************************************************************************************************************************/
#include <Container.h>
#include <DataDef.h>
#include "include.h"
#include "GeneralHardware.h"
#include "thread/thread.h"
#include "ids/ids.h"
#include "control/control.h"
#include "AlarmHandling/AlarmHandling.h"
#include "heaters/heaters_ex.h"
#include "StateMachines/Printing/PrintingSTM.h"

#include "heaters/heaters_ex.h"

#include "PMR/common/MessageContainer.pb-c.h"
#include "PMR/Hardware/UploadHardWareConfigurationRequest.pb-c.h"
#include "PMR/Hardware/UploadHardWareConfigurationResponse.pb-c.h"
#include "PMR/Hardware/SystemResetRequest.pb-c.h"
#include "PMR/Hardware/SystemResetResponse.pb-c.h"

#include "drivers/I2C_Communication/DAC/Blower.h"

uint32_t HWConfigurationFunc(MessageContainer* requestContainer)
{
    uint32_t status  = 0;
    int Motor_i, Dancer_i, Dispenser_i,PID_i;
    MessageContainer responseContainer;
    UploadHardwareConfigurationResponse response = UPLOAD_HARDWARE_CONFIGURATION_RESPONSE__INIT;

    UploadHardwareConfigurationRequest* UploadRequest = upload_hardware_configuration_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    if (UploadRequest == NULL)
    {
        LOG_ERROR (0, "Wrong Data Allocation");
        return ERROR;
    }
    HardwareConfiguration *request =    UploadRequest->hardwareconfiguration;

    PrintingHWConfiguration(request);
    if (request->n_winders == 1)
        status += InternalWinderConfigMessage(request->winders);
    status += MotorsInit();

    if (request->n_motors < NUM_OF_MOTORS)
    {
        for (Motor_i = 0; Motor_i < request->n_motors ; Motor_i++)
        status += MotorsConfigMessage(request->motors[Motor_i]);
    }
    else
    {
        LOG_ERROR (request->n_motors, "Wrong Data");
        upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
        return ERROR;
    }
    if (request->n_dancers <= NUM_OF_DANCERS)
    {
        for (Dancer_i = 0; Dancer_i < request->n_dancers ; Dancer_i++)
            status += DancerConfigMessage(request->dancers[Dancer_i]);
    }
    else
    {
        LOG_ERROR (request->n_dancers, "Wrong Data");
        upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
        return ERROR;
    }
    if (request->n_pidcontrols <= HARDWARE_PID_CONTROL_TYPE__Dispenser8)
    {
        for (PID_i = 0; PID_i < request->n_pidcontrols ; PID_i++)
        {
            if (request->pidcontrols[PID_i]->hardwarepidcontroltype <= HARDWARE_PID_CONTROL_TYPE__MixerHeater)
                status += HeaterConfigRequestMessage(request->pidcontrols[PID_i]);
            else if ((request->pidcontrols[PID_i]->hardwarepidcontroltype >= HARDWARE_PID_CONTROL_TYPE__MotorDryer)&&
                    (request->pidcontrols[PID_i]->hardwarepidcontroltype < HARDWARE_PID_CONTROL_TYPE__Dispenser1))
                status += MotorPidRequestMessage(request->pidcontrols[PID_i]);
            else if (request->pidcontrols[PID_i]->hardwarepidcontroltype >= HARDWARE_PID_CONTROL_TYPE__Dispenser1)
                status += IDS_DispenserPidRequestMessage(request->pidcontrols[PID_i]);
        }
    }
    else
    {
        LOG_ERROR (request->n_pidcontrols, "Wrong Data");
        upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
        return ERROR;
    }
    if (request->n_dispensers <= MAX_SYSTEM_DISPENSERS)
    {
        for (Dispenser_i = 0; Dispenser_i < request->n_dispensers ; Dispenser_i++)
            status += DispenserConfigMessage(request->dispensers[Dispenser_i]);
    }
    else
    {
        LOG_ERROR (request->n_dispensers, "Wrong Data");
        upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
        return ERROR;
    }
    ThreadConfigBreakSensor(request->breaksensors);

    if(request->blowers[0]->enabled)
    {
        Turn_the_Blower_On();//Turn on with the Default_Voltage
        if (request->blowers[0]->voltage)
            Control_Voltage_To_Blower(request->blowers[0]->voltage);
    }

    ControlStart();
    AlarmHandlingStart();
    //ThreadInitialTestStub(request);


    responseContainer = createContainer(MESSAGE_TYPE__UploadHardwareConfigurationResponse, requestContainer->token, true, &response, &upload_hardware_configuration_response__pack, &upload_hardware_configuration_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);
    free(responseContainer.data.data);
    upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
    SendChars(container_buffer, container_size);
    //free(container_buffer);
    //free(requestContainer);

    return OK;



}

void HWSystemResetRequest(MessageContainer* requestContainer)
{
    uint32_t status = FAILED;

    MessageContainer responseContainer;
    SystemResetRequest* request = system_reset_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    status = 0;

    SystemResetResponse response =   SYSTEM_RESET_RESPONSE__INIT;


    responseContainer = createContainer(MESSAGE_TYPE__SystemResetResponse, requestContainer->token, true, &response, &system_reset_response__pack, &system_reset_response__get_packed_size);

    //free(request);
    system_reset_request__free_unpacked(request,NULL);
    //-------------------------------------------------------------------------------------------
    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    SendChars((char*)container_buffer, container_size);
    //free(container_buffer);
    //free(requestContainer);

    ROM_SysCtlDelay(SYS_CLK_FREQ);

    SysCtlReset();

    HWREG(NVIC_APINT) = NVIC_APINT_VECTKEY |  NVIC_APINT_SYSRESETREQ;

}