/*
 * 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/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/ids/ids_ex.h"

MachineState StoredMachineStatus = MACHINE_STATE__Ready;

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};

int MachineUpdateResponseFunc(void)
{
    int i;

    MessageContainer responseContainer;
    if (MachineUpdateToken[0] == 0)
        return OK;

    StartMachineStatusUpdateResponse response = START_MACHINE_STATUS_UPDATE_RESPONSE__INIT;
    MachineStatus MachineStatus;
    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);
    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++;
            MachineStatus.overalltemperature = max(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1),MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2));
        }
    }
    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.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.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;
}