/************************************************************************************************************************
 * PrintSTM.c
 * High managment logical unit of slow motors in the system ( 6 dispensers and the screw)
 * profile run up begins from screw homing to begin position and only then from fast motors activation.
 * SlowMotor module is responsible for :
 	 * operating diffrent winding algorithms with predefined parameters from the UI
 	 * operating the dispensers according to predefined dispensing rate from the UI
 **************************************************************************************************************************/

#ifndef STATEMACHINES_PRINTSTM_H_
#define STATEMACHINES_PRINTSTM_H_

//#include "include.h"
#include "PMR/common/MessageContainer.pb-c.h"
#include "PMR/Hardware/HardwareDispenser.pb-c.h"
#include "PMR/Printing/JobSegment.pb-c.h"
#include "PMR/Printing/JobRequest.pb-c.h"
#include "PMR/Printing/JobTicket.pb-c.h"
#include "PMR/Printing/JobResponse.pb-c.h"
#include "PMR/Printing/JobDescriptionFileBrushStop.pb-c.h"
#include "PMR/Printing/JobDescriptionFileSegment.pb-c.h"
#include "drivers/Flash_Memory/fatfs/ff.h"

#define MAX_MSG_LEN    100
typedef enum
{
    Entry= 0,
    Prepare,
    PreSegment,
    PrintSegment,
    End,
    ExitPrint
} PrintingState_t;
#define EXIT_STATE          ExitPrint
typedef enum
{
    PrintRequest,
    PreSegmentResultsOk,
    PreSegmentResultsFail,
    SegmentResultsOk,
    SegmentResultsFail,
    FinishResultsOk,
    FinishResultsFail,
    PrintSystemFailure
}PrintSTMEventsEnum;

typedef enum
{
    JobRequestMsg,
    ValidationResultsOk,
    ValidationResultsFail,
    PreparationResultsOk,
    PreparationResultsFail,
    PrintMessage,
    PrintingResultsOk,
    PrintingResultsFail,
    CleaningResultsOk,
    CleaningResultsFail,
    SystemFailure,
    Abort
}JobSTMEventsEnum;
typedef enum
{
    Module_Thread,
    Module_Winder,
    Module_IDS,
    Module_Heaters,
    Module_Waste,
    MAX_SYSTEM_MODULES
}SYSTEM_MODULE_ID_ENUM;
typedef enum
{
    JobSuccess = 0,
    JobFail,
    JobStop
} ReturnCode;
typedef enum
{
    ModuleIdle = 0,
    ModuleWaiting,
    ModuleDone,
    ModuleFail
} ModuleStateEnum;
typedef enum
{
    JOB_OK,
    JOB_UNSPECIFIED_ERROR,
    JOB_THREAD_BREAK,
    JOB_WINDER_DANCER_FAIL,
    JOB_POOLER_DANCER_FAIL,
    JOB_FEEDER_DANCER_FAIL,
    JOB_OUT_OF_DYE,
    JOB_OTHER_ALARM,
    JOB_TEMPERATURE_ALARM,
    JOB_LS_ALARM,
    JOB_PRESSURE_ALARM,
    JOB_CURRENT_ALARM,
    JOB_MOTOR_ALARM,
    JOB_TAMPER_ALARM,
    JOB_LIDS_OPEN,
    JOB_ABORTED_BY_USER,
    JOB_SAFETY_CRITICAL_ALARM,
    JOB_NO_ALARM_FILE,
    JOB_FILE_PROBLEM,
    JOB_WASTE_HANDLING_PROBLEM,
    JOB_ERRORS_MAX
}JobEndReasonEnum;
extern JobEndReasonEnum JobEndReason;
ErrorCode getJobError_to_ErrorCode(JobEndReasonEnum JobError);

#define MAX_JOB_NAME_LEN  40
#define MAX_SEGMENT_NUM  30
#define MAX_GRADIENT_STAGES_PER_SEGMENT_NUM  50
#define MAX_DISPENSER_NUM  8

typedef struct
{
    int32_t prevstepmiliseconds;
    double nlflow;
}GradientFlowStruc;

typedef struct
{
  int32_t id;
  double startflow;
}DispenserStruc;

typedef struct
{
  char Segmentname[MAX_JOB_NAME_LEN];
  int32_t length;
  //RGB *color;
  size_t n_dispensers;
  DispenserStruc dispenser[MAX_DISPENSER_NUM];
}SegmentStruc;



typedef struct JobMessage{
    uint16_t messageId;
    uint16_t msglen;
    uint8_t messageData[MAX_MSG_LEN];
}JobMessageStruc;
typedef struct PrintMessage{
    uint16_t messageId;
    uint16_t msglen;
    uint8_t messageData[MAX_MSG_LEN];
}PrintMessageStruc;

extern bool Configured[MAX_SYSTEM_MODULES];
extern bool JobConfigured[MAX_SYSTEM_MODULES];

extern ModuleStateEnum PrepareWaiting[MAX_SYSTEM_MODULES];
extern JobTicket *CurrentJob;
//extern JobTicket *PreviousJob;
extern Mailbox_Handle JobmsgQ;
extern bool JobAbortedByUser;

extern double job_length;

void PrintSTMMsgHandler(void * msg);
//void JobInit(void);
//void PrintingsInit(void);
void JobStopReporting(void);

void JobRequestFunc(MessageContainer* requestContainer);
void JobAbortFunc(MessageContainer* requestContainer);
void AbortJob(char *Msg);

void Stub_JobRequest(MessageContainer* requestContainer);
void Stub_AbortJobRequest(MessageContainer* requestContainer);

void ThreadJoggingRequestFunc(MessageContainer* requestContainer);
void ThreadAbortJoggingRequestFunc(MessageContainer* requestContainer);

void ThreadAbortJoggingFunc(void);
uint32_t ThreadJoggingFunc(int speed);

uint32_t ThreadCleaningJobFunc(MessageContainer* requestContainer);
uint32_t ThreadCleaningAbortJobFunc(MessageContainer* requestContainer);
uint32_t ThreadCleaningJob(int speed);
void FreeCleaningJobData(void *JobDetails);

uint32_t    CurrentJobRequestFunc(MessageContainer* requestContainer);
uint32_t    ResumeCurrentJobRequestFunc(MessageContainer* requestContainer);

bool JobIsActive(void);

extern bool SuspendLargeMessages;

extern int JogSpeed;

extern bool CopyConfigured[MAX_SYSTEM_MODULES];
extern bool CleaningJobActive;
extern bool JoggingJobActive;

extern uint16_t n_segments;
extern uint16_t n_units;
extern uint16_t n_unit_segments;
void SendJobProgress(double ProcessedLength,int SegmentId, bool done, char *Message);

uint32_t PrepareReady(int ModuleId, ModuleStateEnum result);
uint32_t PreSegmentReady(int ModuleId, ModuleStateEnum result);
uint32_t SegmentReady(int ModuleId, ModuleStateEnum result);
uint32_t DistanceToSpoolReady(int ModuleId, ModuleStateEnum result);
uint32_t PrintingHWConfiguration(void *Configuration);
uint32_t EndState(void *JobDetails, char *Message);

bool GetHeatersPrepareWaiting(void);

extern JobUploadStrategy uploadstrategy;
FRESULT OpenJobFile();
FRESULT CloseJobFile();
JobDescriptionFileSegment *GetNextSegmentFromJobFile();
void FreeSegmentFileData(JobDescriptionFileSegment *Segment);
JobDescriptionFileBrushStop *GetNextBrushStopFromJobFile();
void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);

#endif /* STATEMACHINES_PRINTSTM_H_ */