#define CONFIGURE_INIT
#include "system.h"
#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 "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;
	struct timespec measure_ts_start;
	
	
	measure_start(&measure_ts_start);
	pthread_monano_signal_departure_time(&my_monano, my_monano_id[ego]);
        
	pthread_monano_thread_execution(&my_monano, my_monano_id[ego]);

	pthread_monano_signal_end_time(&my_monano, my_monano_id[ego]);
	measure_end(measure_ts_start, "end_time_periodic_activation");

	return 0;
}

void* POSIX_Init(void *argument)
{

  int status, i;
  int thread_number;
  int* ego;

  struct timespec stop = {20,0};
  struct pthread_monano_attr_t* task_param;
  //struct timespec period={10,0};
  struct timespec precision;  
  
  
    status=clock_getres(CLOCK_REALTIME, &precision);
  if(status<0)
    returncode("clock_getres",status);
  
  
 printf("precision %d:%lld \n",  (int)precision.tv_sec, (long long)precision.tv_nsec );
 
  /* 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]);
  
  pthread_monano_register_anomaly_callback(&my_monano, my_callback);

  thread_number=NTHREAD;
  
  task_param=pthread_monano_task_parameters(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;
    status=pthread_monano_periodic_thread_create (&my_monano, tparam[i], periodic_activation, &my_monano_id[i], ego);
    if(status<0){
      returncode("pthread_monano_pthread_create",status);
    }
    task_param++;

  }

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

  exit(0);
  return NULL;  
}