#define CONFIGURE_INIT

#include <signal.h>
#include <errno.h>
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include <time.h>
#include <sched.h>
#include <pthread.h>
#include "system.h"

#include "returncode.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];



void* my_callback(int anomaly_number, pthread_monano_id_t id)
{
 	printf("Type anomaly : %d Anomaly is detected of thread number %d\n", anomaly_number, id);
	return 0;
}



void* periodic_activation(void* arg){
  
	int ego = *(int*)arg;
	int i;
	struct timespec measure_ts_start;
	
	measure_start(&measure_ts_start);	
	for (i=0; i<1000;i++)
	  pthread_monano_signal_departure_time(&my_monano, my_monano_id[ego]);
	
	measure_end(measure_ts_start, "end_time_signal_departure_time");
        
	pthread_monano_thread_execution(&my_monano, my_monano_id[ego]);
	
	measure_start(&measure_ts_start);
	for (i=0; i<1000;i++)
	  pthread_monano_signal_end_time(&my_monano, my_monano_id[ego]);
	measure_end(measure_ts_start, "end_time_signal_end_time");

	return 0;
}

void* POSIX_Init(void *argument)
{

  int status, i;
  int thread_number;
  int* ego;
  struct timespec measure_ts_start;
  
  struct pthread_monano_attr_t* task_param;
  //struct timespec period={10,0};
  //struct timespec wcet={2,0};
 
  /* Monano init and register */
  pthread_monano_init(&my_monano);

  for(i=0; i<CONFIGURE_MAXIMUM_MONANO_THREAD_NUMBER; i++)
  	pthread_monano_attr_init(&tparam[i]);
  
  measure_start(&measure_ts_start);
  for (i=0; i<1000;i++)
    pthread_monano_register_anomaly_callback(&my_monano, my_callback);
  measure_end(measure_ts_start, "end_time_register_anomaly_callback");

  thread_number=NTHREAD;
  struct timespec stop = {thread_number*5,0};
  
  task_param=pthread_monano_task_parameters(&my_monano, thread_number);
  
  //int prio=101;

  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;
    
    /* create a monano periodic thread */
    ego=(int*)malloc(sizeof(int));
    *ego=i;

    measure_start(&measure_ts_start);
    status=pthread_monano_periodic_thread_create (&my_monano, tparam[i], periodic_activation, &my_monano_id[i], ego);
   measure_end(measure_ts_start, "end_time_periodic_thread_create");

    if(status<0){
      returncode("pthread_monano_pthread_create",status);
    }
    task_param++;

  }

  nanosleep(&stop,NULL);
  pthread_monano_stop(&my_monano);

  exit(0);
  return NULL;  
}