using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace Tango.BL
{
    public abstract class ObservableEntityDTO<DTO, T> : IObservableEntityDTO, IEquatable<T> where T : IObservableEntity where DTO : ObservableEntityDTO<DTO, T>
    {
        public int ID { get; set; }

        public String Guid { get; set; }

        public DateTime LastUpdated { get; set; }

        public static DTO FromObservable(T observable)
        {
            if (observable == null) return null;

            var dto = Activator.CreateInstance<DTO>();

            foreach (var prop in typeof(DTO).GetProperties())
            {
                var observableProp = typeof(T).GetProperty(prop.Name);
                if (observableProp != null)
                {
                    if (prop.PropertyType.IsPrimitive || prop.PropertyType.IsValueType || prop.PropertyType == typeof(String))
                    {
                        prop.SetValue(dto, observableProp.GetValue(observable));
                
/*
 * AlarmHandling.c

 *
 *  Created on: 24 may 2018
 *      Author: shlomo
 */

#include "include.h"
#include "Modules/General/GeneralHardware.h"

#include "AlarmHandling.h"
#include <driverlib/timer.h>
#include <Drivers/SSI_Comm/SSI_Comm.h>
#include <inc/hw_ints.h>

#include "drivers/adc_sampling/adc.h"
#include "Control/control.h"
#include "Control/MillisecTask.h"

#include "drivers/Motors/Motor.h"
#include "drivers/Heater/TemperatureSensor.h"
#include "drivers/FPGA/FPGA_SPI_Comm.h"
#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
#include "drivers/FPGA/FPGA.h"
#include "PMR/Hardware/HardwareDancerType.pb-c.h"

#include "modules/thread/thread_ex.h"
#include "modules/ids/ids_ex.h"
#include  <PMR/Diagnostics/Event.pb-c.h>
#include  <PMR/Diagnostics/EventType.pb-c.h>
#include  <PMR/Diagnostics/StartEventsNotificationRequest.pb-c.h>
#include  <PMR/Diagnostics/StartEventsNotificationResponse.pb-c.h>
#include  <PMR/Diagnostics/StopEventsNotificationRequest.pb-c.h>
#include  <PMR/Diagnostics/StopEventsNotificationResponse.pb-c.h>
#include "PMR/debugging/DebugLogCategory.pb-c.h"

#include "StateMachines/Printing/PrintingSTM.h"

#include "drivers/FPGA/Moters_Driver/L6470.h"
#include "drivers/Motors/Motor.h"
#include "drivers/Heater/TemperatureSensor.h"


Task_Handle AlarmHandling_Task_Handle;
Mailbox_Handle          AlarmHandlingMsgQ = NULL;

char AlarmHandlingToken[36+1] = {0};
bool AlarmHandlingActive = false;
uint32_t AlarmHandlingControlId = 0xFF;
uint32_t AlarmHandlingTick = 0;

/******************** Functions  ********************************************/
void SendEventNotifications(void);

//uint32_t Control_Delta_Position_Pass(uint32_t Current_Read,uint32_t Previous_Read);
//**********************************************************************
typedef enum
{
    AlarmHandlingTrigger,
    //AlarmHandlingCalculateTemperature,
}AlarmHandlingMessages;

typedef struct AlarmHandlingMessage{
    uint16_t messageId;
    uint16_t msglen;
    uint32_t tick;
  //  uint32_t SensorId;
  //  uint32_t Data;
}AlarmHandlingMessageStruc;

#define MAX_SYSTEM_ALARMS EVENT_TYPE__MotorDispenser7UnderVoltage+1
typedef enum
{
    TemperatureAlarm,
    LimitSwitchAlarm,
    PressureAlarm,
    CurrentAlarm,
    MotorAlarm
}AlarmSource;
#define OVER_VALUE true;
#define UNDER_VALUE false;
typedef struct
{
    uint16_t Frequency;  //1/10/100/1000
    AlarmSource AlarmSource;
    uint16_t DeviceId;
    uint32_t AlarmValue;
    bool AlarmDirection;
    DebugLogCategory Severity;
    uint16_t Predecessor;
    uint8_t DebounceValue;
    int8_t DebounceCounter;
    bool Status;
    EventType EventType;
    Event *EventPtr;
}AlarmHandlingItem;
AlarmHandlingItem  AlarmItem[MAX_SYSTEM_ALARMS]={
{100,LimitSwitchAlarm,GPI_LS_DISPENSER_UP_1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser1Empty,NULL},
{100,LimitSwitchAlarm,GPI_LS_DISPENSER_UP_2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser2Empty,NULL},
{100,LimitSwitchAlarm,GPI_LS_DISPENSER_UP_3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser3Empty,NULL},
{100,LimitSwitchAlarm,GPI_LS_DISPENSER_UP_4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser4Empty,NULL},
{100,LimitSwitchAlarm,GPI_LS_DISPENSER_UP_5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser5Empty,NULL},
{100,LimitSwitchAlarm,GPI_LS_DISPENSER_UP_6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser6Empty,NULL},
{100,LimitSwitchAlarm,GPI_LS_DISPENSER_UP_7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser7Empty,NULL},
{100,LimitSwitchAlarm,GPI_LS_DISPENSER_UP_8,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser8Empty,NULL},
{100,LimitSwitchAlarm,GPI_LS_DISPENSER_25_1,false,true,DEBUG_LOG_CATEGORY__Warning,0,0,0,false,EVENT_TYPE__Dispenser1LowLevel,NULL},
{100,LimitSwitchAlarm,GPI_LS_DISPENSER_25_2,false,true,DEBUG_LOG_CATEGORY__Warning,1,0,0,false,EVENT_TYPE__Dispenser2LowLevel,NULL},
{100,LimitSwitchAlarm,GPI_LS_DISPENSER_25_3,false,true,DEBUG_LOG_CATEGORY__Warning,2,0,0,false,EVENT_TYPE__Dispenser3LowLevel,NULL},
{100,LimitSwitchAlarm,GPI_LS_DISPENSER_25_4,false,true,DEBUG_LOG_CATEGORY__Warning,3,0,0,false,EVENT_TYPE__Dispenser4LowLevel,NULL},
{100,LimitSwitchAlarm,GPI_LS_DISPENSER_25_5,false,true,DEBUG_LOG_CATEGORY__Warning,4,0,0,false,EVENT_TYPE__Dispenser5LowLevel,NULL},
{100,LimitSwitchAlarm,GPI_LS_DISPENSER_25_6,false,true,DEBUG_LOG_CATEGORY__Warning,5,0,0,false,EVENT_TYPE__Dispenser6LowLevel,NULL},
{100,LimitSwitchAlarm,GPI_LS_DISPENSER_25_7,false,true,DEBUG_LOG_CATEGORY__Warning,6,0,0,false,EVENT_TYPE__Dispenser7LowLevel,NULL},
{100,LimitSwitchAlarm,GPI_LS_DISPENSER_25_8,false,true,DEBUG_LOG_CATEGORY__Warning,7,0,0,false,EVENT_TYPE__Dispenser8LowLevel,NULL},
{100,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalOverTemperature,NULL},
{100,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalOverTemperature,NULL},
{100,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,80,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalOverTemperature,NULL},
{100,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3,300,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DyeingHead6OverTemperature,NULL},
{100,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,300,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DyeingHead1OverTemperature,NULL},
{100,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,300,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DyeingHead2OverTemperature,NULL},
{100,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,300,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DyeingHead3OverTemperature,NULL},
{100,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,300,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DyeingHead4OverTemperature,NULL},
{100,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,300,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DyeingHead5OverTemperature,NULL},
{100,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,300,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DryerOverTemperature,NULL},
{100,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,300,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DryerOverTemperature,NULL},
{100,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,300,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DryerOverTemperature,NULL},
{100,PressureAlarm,1,7,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser1Pressure,NULL},
{100,PressureAlarm,2,7,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser2Pressure,NULL},
{100,PressureAlarm,3,7,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser3Pressure,NULL},
{100,PressureAlarm,4,7,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser4Pressure,NULL},
{100,PressureAlarm,5,7,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser5Pressure,NULL},
{100,PressureAlarm,6,7,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser6Pressure,NULL},
{100,PressureAlarm,7,7,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser7Pressure,NULL},
{100,PressureAlarm,8,7,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser8Pressure,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDryerOverCurrent,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorFeederOverCurrent,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorScrewOverCurrent,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorWinderOverCurrent,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorPoolerOverCurrent,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser1OverCurrent,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser2OverCurrent,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser3OverCurrent,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser4OverCurrent,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser5OverCurrent,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser6OverCurrent,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser7OverCurrent,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser8OverCurrent,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDryerOverTemperature,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorFeederOverTemperature,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorScrewOverTemperature,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorWinderOverTemperature,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorPoolerOverTemperature,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser1OverTemperature,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser2OverTemperature,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser3OverTemperature,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser4OverTemperature,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser5OverTemperature,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser6OverTemperature,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser7OverTemperature,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser8OverTemperature,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_UVLO,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDryerUnderVoltage,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_UVLO,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorFeederUnderVoltage,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_UVLO,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorScrewUnderVoltage,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_UVLO,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorWinderUnderVoltage,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_UVLO,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorPoolerUnderVoltage,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_UVLO,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser1UnderVoltage,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_UVLO,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser2UnderVoltage,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_UVLO,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser3UnderVoltage,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_UVLO,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser4UnderVoltage,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_UVLO,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser5UnderVoltage,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_UVLO,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser6UnderVoltage,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_UVLO,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser7UnderVoltage,NULL},
//{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_UVLO,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorDispenser8UnderVoltage,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_STEP_LOSS_A,true,DEBUG_LOG_CATEGORY__Error,0xFF,8,0,false,EVENT_TYPE__MotorDryerStall,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_STEP_LOSS_A,true,DEBUG_LOG_CATEGORY__Error,0xFF,8,0,false,EVENT_TYPE__MotorFeederStall,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_STEP_LOSS_A,true,DEBUG_LOG_CATEGORY__Error,0xFF,8,0,false,EVENT_TYPE__MotorScrewStall,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_STEP_LOSS_A,true,DEBUG_LOG_CATEGORY__Error,0xFF,8,0,false,EVENT_TYPE__MotorWinderStall,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_STEP_LOSS_A,true,DEBUG_LOG_CATEGORY__Error,0xFF,8,0,false,EVENT_TYPE__MotorPoolerStall,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_STEP_LOSS_A,true,DEBUG_LOG_CATEGORY__Error,0xFF,8,0,false,EVENT_TYPE__MotorDispenser1Stall,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_STEP_LOSS_A,true,DEBUG_LOG_CATEGORY__Error,0xFF,8,0,false,EVENT_TYPE__MotorDispenser2Stall,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_STEP_LOSS_A,true,DEBUG_LOG_CATEGORY__Error,0xFF,8,0,false,EVENT_TYPE__MotorDispenser3Stall,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_STEP_LOSS_A,true,DEBUG_LOG_CATEGORY__Error,0xFF,8,0,false,EVENT_TYPE__MotorDispenser4Stall,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_STEP_LOSS_A,true,DEBUG_LOG_CATEGORY__Error,0xFF,8,0,false,EVENT_TYPE__MotorDispenser5Stall,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_STEP_LOSS_A,true,DEBUG_LOG_CATEGORY__Error,0xFF,8,0,false,EVENT_TYPE__MotorDispenser6Stall,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_STEP_LOSS_A,true,DEBUG_LOG_CATEGORY__Error,0xFF,8,0,false,EVENT_TYPE__MotorDispenser7Stall,NULL},
{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_STEP_LOSS_A,true,DEBUG_LOG_CATEGORY__Error,0xFF,8,0,false,EVENT_TYPE__MotorDispenser8Stall,NULL},
};
char TestMessage[5]="Test";

bool EventsNotificationRequestAccepted = false;
//read dispensers limit switches. 25 - send warning. up - stop job and send alarm
//Cone missing
//Dyeing head over temperature
//mixer over temperature
//dryer over temperature
//heaters failure
//dispenser pressure
//valve OCD
//Motor Status
//machine cover open
void AlarmHandlingInit(void)
{
    Error_Block eb;

    Error_init(&eb);

    AlarmHandlingMsgQ = Mailbox_create(sizeof(AlarmHandlingMessageStruc), 20, NULL,&eb);

    return;
}
uint32_t AlarmHandlingConsequentActions(EventType EventId, DebugLogCategory Severity)
{
    switch (Severity)
    {
    case DEBUG_LOG_CATEGORY__Warning:

        //raise flag fr next job
        break;
    case DEBUG_LOG_CATEGORY__Error:
        if (JobIsActive())
        {
            JobEndReason = JOB_OTHER_ALARM;
            //EndState(NULL,event_type__descriptor.name[EventId]);
        }
//Stop Job
        break;
    case DEBUG_LOG_CATEGORY__Critical:
        if (JobIsActive())
        {
            JobEndReason = JOB_OTHER_ALARM;
            //EndState(NULL,event_type__descriptor.name[EventId]);
        }
        watchdogCriticalAlarm = true;
        //stop job
        //turn machine off
        break;
    case DEBUG_LOG_CATEGORY__Debug:
    case DEBUG_LOG_CATEGORY__Info:
    default:
        //do nothing
        break;

    }
    return OK;
}
/*
uint32_t AlarmHandling_CalculateTemperatures(uint32_t SensorId, uint32_t Data)
{
    AlarmHandlingMessageStruc Message;

    //send message to the Millisec task
    Message.messageId = AlarmHandlingCalculateTemperature;
    Message.msglen = sizeof(AlarmHandlingMessageStruc);
    Message.SensorId = SensorId;
    Message.Data = Data;
    if (AlarmHandlingMsgQ != NULL)
        Mailbox_post(AlarmHandlingMsgQ , &Message, BIOS_NO_WAIT);


    return OK;
}
*/
uint32_t AlarmHandling_ControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
{
    AlarmHandlingMessageStruc Message;

    //send message to the Millisec task
    Message.messageId = AlarmHandlingTrigger;
    Message.msglen = sizeof(AlarmHandlingMessageStruc);
    AlarmHandlingTick +=10;
    Message.tick = AlarmHandlingTick;
    if (AlarmHandlingMsgQ != NULL)
        Mailbox_post(AlarmHandlingMsgQ , &Message, BIOS_NO_WAIT);


    return OK;
}
uint32_t AlarmHandlingEmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue)
{
    return OK;
}

uint32_t AlarmHandlingStart(void)
{

    if (EventsNotificationRequestAccepted == false)
        return ERROR;
    if ( AlarmHandlingActive == false)
    {
            AlarmHandlingActive = true;
            AlarmHandlingControlId = AddControlCallback(AlarmHandling_ControlTrigger,eTenMillisecond,AlarmHandlingEmptyCBFunction,0,0,0);
    }
    return OK;
}
uint32_t AlarmHandlingStop(void)
{
    if ( AlarmHandlingActive == true)
    {
        AlarmHandlingActive = false;
        if (AlarmHandlingControlId != 0xFF)
            RemoveControlCallback(AlarmHandlingControlId,AlarmHandling_ControlTrigger);

        AlarmHandlingControlId = 0xFF;
    }
    return OK;
}

uint32_t AlarmHandlingLoop(uint32_t tick)
{
    int Alarm_i;
    uint32_t value;
    bool Status = false;
    for (Alarm_i = 0;Alarm_i < MAX_SYSTEM_ALARMS;Alarm_i++)
    {
        Status = false;
        if (tick%AlarmItem[Alarm_i].Frequency == 0)
        {
            switch (AlarmItem[Alarm_i].AlarmSource)
            {
            case TemperatureAlarm:
                value = TemperatureSensorRead(AlarmItem[Alarm_i].DeviceId);
                if (AlarmItem[Alarm_i].AlarmDirection == true)
                {
                    if (value/100 >= AlarmItem[Alarm_i].AlarmValue)
                    {
                        Status = true;
                    }
                }
                else
                {
                    if (value/100 <= AlarmItem[Alarm_i].AlarmValue)
                    {
                        Status = true;
                    }
                }
                break;
            case LimitSwitchAlarm:
                value = FPGA_Read_limit_Switches(AlarmItem[Alarm_i].DeviceId);
                if (value == AlarmItem[Alarm_i].AlarmValue)
                {
                    Status = true;
                }
                break;
            case PressureAlarm:
                value = GetDispenserPressure(AlarmItem[Alarm_i].DeviceId);
                if (AlarmItem[Alarm_i].AlarmDirection == true)
                {
                    if (value >= AlarmItem[Alarm_i].AlarmValue)
                    {
                        Status = true;
                    }
                }
                else
                {
                    if (value <= AlarmItem[Alarm_i].AlarmValue)
                    {
                        Status = true;
                    }
                }
                break;
            case CurrentAlarm:
                break;
            case MotorAlarm:
                if (isMotorConfigured(AlarmItem[Alarm_i].DeviceId) == false)
                {
                    Status = false;
                    break;
                }
                value = MotorGetStatus(AlarmItem[Alarm_i].DeviceId);
                if (value && AlarmItem[Alarm_i].AlarmValue) //
                {
                    Status = true;
                }
                break;
            default:
                break;
            } //switch
            if (AlarmItem[Alarm_i].DebounceValue > 0) //handle debouncing
            {
                if (Status == true) //increase counter
                {
                    AlarmItem[Alarm_i].DebounceCounter++;
                    if (AlarmItem[Alarm_i].DebounceCounter < AlarmItem[Alarm_i].DebounceValue)
                    {
                        Status = false;
                    }
                    else
                    {
                        AlarmItem[Alarm_i].DebounceCounter = AlarmItem[Alarm_i].DebounceValue;
                    }
                }
                else //status  == false - decrease counter
                {
                    AlarmItem[Alarm_i].DebounceCounter--;
                    if (AlarmItem[Alarm_i].DebounceCounter > 0)
                    {
                        Status = true;
                    }
                    else
                    {
                        AlarmItem[Alarm_i].DebounceCounter = 0;
                    }
                }
            }
            if (AlarmItem[Alarm_i].Predecessor!=0xFF)
            {
                if (AlarmItem[AlarmItem[Alarm_i].Predecessor].Status == true)  //higher hierarchy alarm is on
                    Status = false;
            }
            if (Status !=  AlarmItem[Alarm_i].Status) //change in alarm Status
            {
                if (Status == true) // alarm on
                {
                    AlarmItem[Alarm_i].Status = true;
                    AlarmHandlingConsequentActions(AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity);
                    // report the alarm!
                    AlarmItem[Alarm_i].EventPtr = malloc (sizeof(Event));
                    if (AlarmItem[Alarm_i].EventPtr)
                    {
                        event__init(AlarmItem[Alarm_i].EventPtr);
                        AlarmItem[Alarm_i].EventPtr->has_type = true;
                        AlarmItem[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType;
                        AlarmItem[Alarm_i].EventPtr->message = TestMessage;
                    }
                }
                else // alarm off
                {
                    AlarmItem[Alarm_i].Status = false;
                    AlarmHandlingConsequentActions(AlarmItem[Alarm_i].EventType, DEBUG_LOG_CATEGORY__Info);
                    // report the alarm!
                    if (AlarmItem[Alarm_i].EventPtr)
                        free (AlarmItem[Alarm_i].EventPtr);
                }
            }
        }
    }
    //read dispensers limit switches. 25 - send warning. up - stop job and send alarm
    //Cone missing
    //Dyeing head over temperature
    //mixer over temperature
    //dryer over temperature
    //heaters failure
    //dispenser pressure
    //valve OCD
    //Motor Status
    //machine cover open

    if (tick%eOneSecond == 0)
        SendEventNotifications();
    return OK;
}
/******************************************************************************
 *  ======== messageTsk ========
 *  Task for this function is created statically. See the project's .cfg file.
 *  this message task is created statically in system initialization,
 ******************************************************************************/
void AlarmHandlingTask(UArg arg0, UArg arg1)
{
    AlarmHandlingMessageStruc Message;
    //char str[60];
    //uint16_t length;
    //Clock_setTimeout(HostKAClock, 1000);
    //Clock_start(HostKAClock);
    AlarmHandlingInit();
    AlarmHandling_Task_Handle = Task_self();
    while(1)
    {
        Mailbox_pend(AlarmHandlingMsgQ , &Message, BIOS_WAIT_FOREVER);
        switch (Message.messageId)
        {
            case AlarmHandlingTrigger:
                AlarmHandlingLoop(Message.tick);
                break;
            /*case AlarmHandlingCalculateTemperature:
                CalculateTemperatures(Message.SensorId,Message.Data);
                break;*/
            default:
                break;
        }
    }
}
//StartEventsNotificationResponse StartEventsNotification = START_EVENTS_NOTIFICATION_RESPONSE__INIT;
StartEventsNotificationResponse response = START_EVENTS_NOTIFICATION_RESPONSE__INIT;
void SendEventNotifications(void)
{
    MessageContainer responseContainer;
    //StartEventsNotificationResponse response = START_EVENTS_NOTIFICATION_RESPONSE__INIT;
    int i,e=0;

    if (AlarmHandlingActive == false)
        return;
    if (AlarmHandlingToken[0] == 0)
        return;
    response.n_events = 0;

    for (i = 0;i<MAX_SYSTEM_ALARMS;i++)
    {
        if (AlarmItem[i].Status == true)
        {
            response.n_events++;
        }
    }
    response.events = (Event **)malloc(sizeof(Event*)*response.n_events);
    if(response.events)
    {
        for (i = 0;i<MAX_SYSTEM_ALARMS;i++)
        {
            if (AlarmItem[i].Status == true)
            {
                response.events[e]=AlarmItem[i].EventPtr;
                e++;
            }
        }
    }
    responseContainer = createContainer(MESSAGE_TYPE__StartEventsNotificationResponse,  AlarmHandlingToken, false, &response, &start_events_notification_response__pack, &start_events_notification_response__get_packed_size);
    responseContainer.continuous = true;

    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);

    if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full
    {
        AlarmHandlingToken[0] = 0;
    }
    if (response.events)
        free (response.events);
    free(responseContainer.data.data);
}

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

//    ReportInitParams InitParams;
    //ControlStart();
    EventsNotificationRequestAccepted = true;
    //AlarmHandlingStart();

    StartEventsNotificationRequest* request = start_events_notification_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
    ustrncpy (AlarmHandlingToken, requestContainer->token,36);
    start_events_notification_request__free_unpacked(request,NULL);
    return status;
}
uint32_t StopEventsNotificationRequestFunc(MessageContainer* requestContainer)
{

    MessageContainer responseContainer;

    StopEventsNotificationRequest* request = stop_events_notification_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    StopEventsNotificationResponse response = STOP_EVENTS_NOTIFICATION_RESPONSE__INIT;

    AlarmHandlingStop();

    EventsNotificationRequestAccepted = false;

    responseContainer = createContainer(MESSAGE_TYPE__StopEventsNotificationResponse,  requestContainer->token, false, &response, &stop_events_notification_response__pack, &stop_events_notification_response__get_packed_size);
    responseContainer.continuous = false;
    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);
    //USBCDCD_sendData(container_buffer, container_size,10);
    SendChars(container_buffer, container_size);
    //free (container_buffer);

return OK;
}