/*
 * MachineStatus.c
 *
 *  Created on: Aug 15, 2019
 *      Author: shlomo
 */
#include <Container.h>
#include <DataDef.h>
#include <stdio.h>      /* puts(), etc. */
#include "Common/report/report.h"
#include "include.h"

#include "PMR/common/MessageContainer.pb-c.h"
#include "PMR/MachineStatus/StartMachineStatusUpdateRequest.pb-c.h"
#include "PMR/MachineStatus/StopMachineStatusUpdateRequest.pb-c.h"
#include "PMR/MachineStatus/StartMachineStatusUpdateResponse.pb-c.h"
#include "PMR/MachineStatus/StopMachineStatusUpdateResponse.pb-c.h"
#include "PMR/Diagnostics/EventType.pb-c.h"
#include "PMR/MachineStatus/MachineStatus.pb-c.h"
#include "PMR/MachineStatus/MachineState.pb-c.h"
#include "PMR/MachineStatus/IDSPackLevel.pb-c.h"

#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
#include "Drivers/Heater/TemperatureSensor.h"
#include "drivers/Motors/Motor.h"

#include "Modules/General/MachineStatus.h"
#include "Modules/Control/MillisecTask.h"
#include "modules/ids/ids_ex.h"

MachineState StoredMachineStatus = MACHINE_STATE__PowerUp;

void SetMachineStatus (MachineState State)
{
    ReportWithPackageFilter(GeneralFilter,"SetMachineStatus",__FILE__,__LINE__,State,RpWarning,StoredMachineStatus, 0);

    StoredMachineStatus = State;
}
char MachineUpdateToken[36+1] = {0};
IDSPackLevel IDS_Level[MAX_SYSTEM_DISPENSERS];
TimerMotors_t msDispenserIdToMotorId[MAX_SYSTEM_DISPENSERS] = {HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8};

bool temp_measure_alarm = false;
int MachineUpdateResponseFunc(void)
{
    int i;
    int internaltemp1,internaltemp2,usetemp;
    bool int1valid = true,int2valid = true;
    MessageContainer responseContainer;
    if (MachineUpdateToken[0] == 0)
        return OK;

    StartMachineStatusUpdateResponse response = START_MACHINE_STATUS_UPDATE_RESPONSE__INIT;
    MachineStatus MachineStatus = MACHINE_STATUS__INIT;
    response.status = &MachineStatus;

    //machine_status__init(&MachineStatus);
    MachineStatus.has_state = true;
    MachineStatus.state = StoredMachineStatus;
    MachineStatus.n_idspackslevels = 0;
    MachineStatus.idspackslevels = (IDSPackLevel**)my_malloc(sizeof(IDSPackLevel *)*8);
    MachineStatus.has_spoolstate = true;

    internaltemp1 = MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1);
    internaltemp2 = MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2);

    if((internaltemp1<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=internaltemp1))
        int1valid = false;
    if((internaltemp2<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=internaltemp2))
        int2valid = false;
    if ((int2valid == true)&&(int1valid == true))
    {
            usetemp = (max(internaltemp1,internaltemp2))/100;
            if (temp_measure_alarm == true)
            {
                AlarmHandlingSetAlarm(EVENT_TYPE__TEMPERATURE_MEASUREMENT_ERROR, false);
                temp_measure_alarm = false;
            }
    }
    else
    {
        AlarmHandlingSetAlarm(EVENT_TYPE__TEMPERATURE_MEASUREMENT_ERROR, true);
        temp_measure_alarm = true;
        if ((int2valid == false)&&(int1valid == true))
            usetemp = internaltemp1/100;
        else if ((int2valid == false)&&(int1valid == false))
            usetemp = 0;
        else  if ((int1valid == false)&&(int2valid == true))
            usetemp = internaltemp2/100;
    }

    MachineStatus.has_overalltemperature = true;


    if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
    {
      MachineStatus.spoolstate = SPOOL_STATE__Absent;
    }
    else
    {
        MachineStatus.spoolstate = SPOOL_STATE__Present;

    }
    if (MachineStatus.idspackslevels)
    {
        for (i = 0; i<MAX_SYSTEM_DISPENSERS;i++)
        {
            if (MotorsCfg[msDispenserIdToMotorId[i]].hardwaremotortype
                        != msDispenserIdToMotorId[i]) // dispenser not configured
                    continue;

            idspack_level__init(&IDS_Level[i]);
            IDS_Level[i].has_index = true;
            IDS_Level[i].index = i;
            IDS_Level[i].has_dispenserlevel = true;
            double dispcapacity = (1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000))*130*1000*1000;
            IDS_Level[i].dispenserlevel = (int32_t)dispcapacity;
            IDS_Level[i].has_midtanklevel = true;
            IDS_Level[i].midtanklevel = Get_MidTank_Pressure_Sensor(i);
            MachineStatus.idspackslevels[MachineStatus.n_idspackslevels] = &IDS_Level[i];
            MachineStatus.n_idspackslevels++;
        }
    }
    else
        return ERROR;



    responseContainer = /*MachineUpdate*/createContainer(MESSAGE_TYPE__StartMachineStatusUpdateResponse, MachineUpdateToken, false, &response, &start_machine_status_update_response__pack, &start_machine_status_update_response__get_packed_size);
    responseContainer.has_continuous = true;
    responseContainer.continuous = true;
    //if (responseContainer.data.data)
    {
        uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
        if (container_buffer)
        {
            size_t container_size = message_container__pack(&responseContainer, container_buffer);
            //        if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full
            if (SendCharsWithType(container_buffer, container_size,MESSAGE_TYPE__StartMachineStatusUpdateResponse) == false) //comm tx mailbox full
            {
                //CommunicationMailboxFlush();
                MachineUpdateToken[0] = 0;
                my_free(container_buffer);
            }
        }
        my_free(responseContainer.data.data);
    }

    my_free(MachineStatus.idspackslevels);
        //Task_sleep(5);
    return OK;

}


uint32_t MachineUpdateInitFunc(MessageContainer* requestContainer)
{
    uint32_t status = NOT_SUPPORTED;
    //MessageContainer responseContainer;

//    MachineUpdateInitParams InitParams;

    StartMachineStatusUpdateRequest* request = start_machine_status_update_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
    ustrncpy (MachineUpdateToken, requestContainer->token,36);

    start_machine_status_update_request__free_unpacked(request,NULL);
    MachineUpdateResponseFunc();
    return status;
}
void MachineUpdateStopReporting(void)
{
    MachineUpdateToken[0] = 0;
}
uint32_t StopMachineUpdateFunc(MessageContainer* requestContainer)
{

    MessageContainer responseContainer;

    StopMachineStatusUpdateRequest* request = stop_machine_status_update_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    StopMachineStatusUpdateResponse response = STOP_MACHINE_STATUS_UPDATE_RESPONSE__INIT;

//TODO Handle the request!!!!
    MachineUpdateStopReporting();
    responseContainer = createContainer(MESSAGE_TYPE__StopMachineStatusUpdateResponse, MachineUpdateToken, false, &response, &stop_machine_status_update_response__pack, &stop_machine_status_update_response__get_packed_size);
    responseContainer.has_continuous = true;
    responseContainer.continuous = true;
    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    my_free(responseContainer.data.data);
    //USBCDCD_sendData(container_buffer, container_size,10);
    SendChars(container_buffer, container_size);
    //free (container_buffer);

return OK;
}