#include "pmacros.h"
#include "system.h"

#include <stdio.h>
#include <sched.h>
#include <stdlib.h>
#include <string.h>
#include <semaphore.h>
#include <errno.h>
#include <signal.h>
#include <time.h>
#include <pthread.h>

#include "returncode.h"


#include "benchmark.h"

#include "monano.h"
#include "monano_data.h"
#include "measure.h"
#include "time_conversion.h"
#include "task_parameter.h"

#include "nthread.h"

struct pthread_monano_t my_monano;
pthread_monano_id_t my_monano_id[NTHREAD];
struct pthread_monano_attr_t tparam[CONFIGURE_MAXIMUM_MONANO_THREAD_NUMBER];

struct periodic_activation_parameters* param_active;

void* POSIX_Init(void *argument){
	
	int status, i;
	int thread_number;
       	struct timespec measure_ts_start;
      	struct sched_param param;
      
	struct periodic_activation_parameters* param_active;
      	struct pthread_monano_attr_t* task_param;
  
      	/* Monano init and register */
    	for(i=0; i<CONFIGURE_MAXIMUM_MONANO_THREAD_NUMBER; i++)
    		pthread_monano_attr_init(&tparam[i]);
  
    	pthread_monano_init(&my_monano);
	benchmark_init();

  	pthread_monano_register_anomaly_callback(&my_monano, benchmark_my_callback);
 	// measure_end(measure_ts_start, "end_time_register_anomaly_callback");
	
	/*upgrade main thread priority */
      	param.sched_priority=5;
      	status=pthread_setschedparam(pthread_self(), SCHED_FIFO, &param);
      	if (status<0)
      		returncode("pthread_attr_setschedparam", status);
      
	thread_number=NTHREAD;
      	printf("NTHREAD = %d \n", thread_number);
      	struct timespec stop = {thread_number*20,0};
      	printf("stop_time %d sec \n", (int)stop.tv_sec);
      
	task_param=pthread_monano_task_parameters(&my_monano, thread_number);
      
	for(i=0; i<thread_number; i++) {
	    	/* Set threads constant with arbitrary values */
	    	tparam[i].priority=task_param->priority;
	    	tparam[i].period=task_param->period;
	    	tparam[i].wcet=task_param->wcet;
	    	tparam[i].deadline=task_param->deadline;
	    	tparam[i].delay=task_param->delay;
	    
		/* create a monano periodic thread */
		param_active = (struct periodic_activation_parameters*)malloc(sizeof(struct periodic_activation_parameters));
		if(param_active==NULL){
			printf("ERREUR MALLOC init.c \n");
			exit(0);
		}
		
		param_active->ego=i;
		if (my_monano.nb_precedencies!=0){
	    		for(int j=0;j< my_monano.nb_precedencies; j++)
				if (param_active->ego == my_monano.pthread_precedencies[j].destination)
					param_active->precedency_blocking=1;
		} 
		
		status=pthread_monano_periodic_thread_create (&my_monano, tparam[i], benchmark_periodic_activation, &my_monano_id[i], param_active);
	    
		if(status<0){
		  	returncode("pthread_monano_pthread_periodic_create",status);
	    	}
	    
		task_param++;
      	}
      
	nanosleep(&stop,NULL);
      	pthread_monano_stop(&my_monano);
      
	exit(0);
       
	return NULL;  
}