#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
#include <sys/types.h>
#include "stencil.h"

double *cur_step;
double *next_step;

int next_thread_id = 0;
pthread_mutex_t thread_id_mutex;

/* A COMPLETER: variables globales */
sem_t upper_border[NB_THREADS];
sem_t lower_border[NB_THREADS];


/* initialize matrixes */
void init() {
  int i, j;

  cur_step = malloc(sizeof(double) * N * N);
  next_step = malloc(sizeof(double) * N * N);

  srand(time(NULL));
  for(i=0; i<N; i++) {
    for(j=0; j<N; j++) {
      GET(cur_step, i, j) = 0;
      GET(next_step, i, j) = 0;
    }
  }

#if 0
  int posx = (N/4)+ (rand()%(N/2));
  int posy = (N/4)+ (rand()%(N/2));
#else
  int posx = (N/2);
  int posy = (N/2);
#endif
  GET(cur_step, posx, posy) = N*10000;

  pthread_mutex_init(&thread_id_mutex, NULL);

  /* A COMPLETER : initilisation */
  for(i=0;i<NB_THREADS; i++) {
    sem_init(&upper_border[i], 0, 1);
    sem_init(&lower_border[i], 0, 1);
  }
}

void finalize() {
  /* A COMPLETER */
}

void compute(int i_min, int i_max, int j_min, int j_max, double *src, double *dest)
{
  int i, j;

  for(i=i_min; i< i_max; i++) {
    for(j=j_min; j< j_max; j++) {
      GET(dest, i, j) = (GET(src, i-1, j) + GET(src, i+1, j) +
		    GET(src, i, j-1) + GET(src, i, j+1) +
			 GET(src, i, j)) / 5;
    }
  }
}


void* thread_func(void* arg) {
  int i;

  pthread_mutex_lock(&thread_id_mutex);
  int my_id = next_thread_id;
  next_thread_id ++;
  pthread_mutex_unlock(&thread_id_mutex);

  double *m1, *m2;
  m1 = cur_step;
  m2 = next_step;

  int i_min, i_max, j_min, j_max;
  compute_boundaries(&i_min, &i_max, &j_min, &j_max, NB_THREADS, my_id);

  printf("Thread %d starts (%d, %d)\n", my_id, i_min, i_max);
  for(i=0; i< NB_STEPS; i++) {

    /* A COMPLETER : synchronisation entre threads */

    if(my_id > 0)
      sem_wait(&upper_border[my_id]);
    if(my_id < NB_THREADS-1)
      sem_wait(&lower_border[my_id]);

    if(my_id == 0)
      printf("STEP %d...\n", i);

    compute(i_min, i_max, j_min, j_max, m1, m2);

    double *tmp = m1;
    m1 = m2;
    m2 = tmp;

    if(my_id < NB_THREADS-1)
      sem_post(&upper_border[my_id+1]);
    if(my_id > 0)
      sem_post(&lower_border[my_id-1]);
  }

  printf("Thread %d ends\n", my_id);

  return NULL;
}

int main(int argc, char**argv) {

  struct timeval t1, t2;
  unsigned int i;

  printf("Initialization (problem size: %d)\n", N);
  init();

  printf("Start computing (%d steps)\n", NB_STEPS);

  GET_TIME(t1);
  pthread_t tids[NB_THREADS];
  for(i=0;i<NB_THREADS; i++) {
    pthread_create(&tids[i], NULL, thread_func, NULL);
  }

  for(i=0;i<NB_THREADS; i++)
    pthread_join(tids[i], NULL);

  GET_TIME(t2);

  double total_time = TIME_DIFF(t1, t2);
  printf("%d steps in %lf sec (%lf sec/step)\n",
	 NB_STEPS, total_time, total_time/NB_STEPS);

  print_matrix(cur_step);

  finalize();
  return 0;
}