/* 
  ZMIANY w wersji 'balanced'
  - robimy dluga tablice kolumn
    - K -> N w alokacji
  - kazdy proces ma bezwzgledny numer wiersza
    - 0 -> rStart -1
    - 1 -> rStart 
    - K jako numer -> rEnd
    - K jako ilosc wierszy -> rEnd- rStart
*/


#include "mpi.h"
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
  int K,N;
  int **tab, **tab2, **tmpwsk;
  int a, i, j, jed=0, flaga;
  int nb_count;  //ilosc sasiadow
  int pokolenie, il_pok, next, prev, myid, psize;
  int completed; //numer requestu ktory sie skonczyl
  double pp; //prawdopodobienstwo jedynki
  double ttime=0, stime, etime;
  MPI_Status s[2];
  MPI_Request rs[2];
  MPI_Request rr[2];

  int myTLast;
  int otherTLast;
  int myK;
  int otherK;
  double alfa = 2.0f;

  int rStart, rEnd;

  //odczytanie parametrow wywolania programu

  MPI_Init(&argc, &argv);
  MPI_Comm_rank(MPI_COMM_WORLD, &myid);
  MPI_Comm_size(MPI_COMM_WORLD, &psize);
  
  if (argc != 4) {
    fprintf(stderr,
	    "Blad! Zle wywolanie. \n uzycie: %s <rozmiar: 1..n> <prawdopodobienstwo: 0..1> <pokolen:1..n>\n", argv[0]);
    exit(1);
    
  }
  else {
    N = atoi(argv[1]);
    printf("nsize: %d ", N);
    pp = atof(argv[2]);
    printf("prawdop: %.2f\n", pp);
    il_pok=atoi(argv[3]);
    if ( pp > 1 || pp < 0) {
      fprintf(stderr, "Blad! Prawdopodobienstwo poza zakresem!!\n");
      exit(1);
    }
  }
  //okreslenie po ile alokuja procesy
  K = N / psize;
  if (myid < (N % psize)) K++;

  rStart = myid*K+1;
  if (myid < (N % psize)) 
     rStart += myid; 
  else
    rStart +=N% psize;
       
  rEnd = rStart + K-1;

  fprintf(stderr, "proc %d alokuje %d od %d do %d\n", myid, K, rStart, rEnd);

  //alokacja pamieci na tablice i wyzerowanie pamieci
  tab = (int **) calloc(N+2, sizeof(int *));
  tab2 = (int **) calloc(N+2, sizeof(int *));
  for (i = rStart-1; i <= rEnd+1; i++) {
    tab[i] = (int *) calloc(N+2, sizeof(int));
    tab2[i] = (int *) calloc(N+2, sizeof(int));
  }

  //wypelnianie pola poczatkowymi wartosciami
  srandom(myid+time(NULL));
  for (i=rStart; i<=rEnd; i++)
    for (j=0; j<N; j++)
      tab[i][j] = (random()%100 < pp*100) ? 1 : 0;

  for (pokolenie=1; pokolenie<=il_pok; pokolenie++,jed=0,ttime=0.0) {

    next = (myid+1)%psize; 
    prev = (myid-1+psize)%psize;
    MPI_Isend(tab[rStart], N+2, MPI_INT, prev, 12, MPI_COMM_WORLD, &rs[0]);
    MPI_Irecv(tab[rEnd+1], N+2, MPI_INT, next, 12, MPI_COMM_WORLD, &rr[0]);
    MPI_Isend(tab[rEnd], N+2, MPI_INT, next, 11,MPI_COMM_WORLD, &rs[1]);
    MPI_Irecv(tab[rStart-1], N+2, MPI_INT, prev, 11, MPI_COMM_WORLD, &rr[1]);
    //obliczenie nastepnego pokolenia!
    //kopiowanie tablicy
    tmpwsk=tab2; tab2 = tab; tab=tmpwsk;
    // obliczenie srodkowego pola 
    stime=MPI_Wtime();
    for (i=rStart+1; i<=rEnd-1; i++) {
      for (j=0; j<N; j++) {
        //ilosc sasiadow
        nb_count =
          tab2[i-1][(j-1+N)%N]+tab2[i-1][j]+tab2[i-1][(j+1)%N]
          +tab2[i][(j-1+N)%N]+           tab2[i][(j+1)%N]
          +tab2[i+1][(j-1+N)%N]+tab2[i+1][j]+tab2[i+1][(j+1)%N];

        if (nb_count==3) {
          tab[i][j]=1;
        }
        else {
          if (nb_count==2)
            tab[i][j]=tab2[i][j];
          else
            tab[i][j]=0;
        }
	jed+=tab[i][j]; //DEBUG if (tab[i][j]) {printf("tab[%d][%d]=1\n",i,j);};
      }
    }
    etime=MPI_Wtime();
    ttime=etime-stime;

    tab[rStart][N]=tab[rEnd][N]=(int)(ttime*100000);
    tab[rStart][N+1]=tab[rEnd][N+1]=rEnd-rStart;

    //sprawdzenie komunikacji i doliczenie brakujacych wierszy
    for (a=0; a<2; a++) {
      MPI_Waitany(2, rr, &completed, &s[0]);
      //fprintf(stderr,"in proc %d completed %d\n", myid, completed);
      // jesli odebralismy req0 to znaczy ze przyszedl wiersz K
      i = (completed == 0) ? rEnd : rStart;
      for (j=0; j<N; j++) {
	//ilosc sasiadow
	nb_count =
	  tab2[i-1][(j-1+N)%N]+tab2[i-1][j]+tab2[i-1][(j+1)%N]
	  +tab2[i][(j-1+N)%N]+           tab2[i][(j+1)%N]
	  +tab2[i+1][(j-1+N)%N]+tab2[i+1][j]+tab2[i+1][(j+1)%N];
	
	if (nb_count==3) {
	  tab[i][j]=1;
	}
	else {
	  if (nb_count==2)
	    tab[i][j]=tab2[i][j];
	  else
	    tab[i][j]=0;
	}
	jed+=tab[i][j];
      }
    }
    //Wait for Sends
    MPI_Waitall(2, rs, &s[0]);

    fprintf(stderr, "P:%d Pok:%d Jed:%d MyTCur:%d MyTLast:%d PTLast: %d NTLast: %d [ms] MyK:%d, PK:%d, NK=%d \n", 
	    myid, pokolenie, jed, (int)(ttime*100000), tab2[rStart][N], tab2[rStart-1][N],tab2[rEnd+1][N],
	    tab2[rStart][N+1], tab2[rStart-1][N+1],tab2[rEnd+1][N+1] );
    
    // rules to switch 
    // oddaje jesli:
    // jego-moj > alfa*(moj/ilosc_moichwierszy)
    // przyjmuje jesli
    // moj-jego > alfa*(jego/ilosc_jegowierszy)
    //    if ( tab2[0][N]-tab2[1][N] > alfa* (double)tab2/  ) 
    
    if (pokolenie >2) {
      
      //przesuniecie z poprzednim
      
      myTLast=tab2[rStart][N];
      otherTLast=tab2[rStart-1][N];
      myK = tab2[rStart][N+1];
      otherK = tab2[rStart-1][N+1];
      
      if (myid>0) {
	//odddaje do poprzedniego
	if ( myTLast - otherTLast > alfa * myTLast/myK) {
	  fprintf(stderr,"P:%d Pok:%d ODDAJE wiersz do poprzedniego\n",myid, pokolenie);

	  //TODO!

	}
	//przyjmuje od poprzedniego
	if ( otherTLast - myTLast > alfa * otherTLast/otherK) {
	  fprintf(stderr,"P:%d Pok:%d  PRZYJMUJE wiersz od poprzedniego\n",myid, pokolenie);

	  //TODO!

	}
	
      }      
      
      //przesuniecia z nastepnym 
      
      myTLast=tab2[rEnd][N];
      otherTLast=tab2[rEnd+1][N];
      myK = tab2[rEnd][N+1];
      otherK = tab2[rEnd+1][N+1];
      
      if (myid< psize-1) {
	//odddaje do nastepnego
      if (myTLast - otherTLast  > alfa * myTLast/myK) {
	fprintf(stderr,"P:%d Pok:%d ODDAJE wiersz do nastepnego\n",myid, pokolenie);
	
	//TODO!

      }
      //przyjmuje od nastepnego
      if (otherTLast  - myTLast > alfa * otherTLast/otherK) {
	fprintf(stderr,"P:%d Pok:%d PRZYJMUJE wiersz od nastepnego\n",myid, pokolenie);

	//TODO!

      }

    }

    }

    //wypisywanie pola po komunikacji
    //uwaga, zakladki z poptrzedniego pokolenia!
    /*  for (i=0; i<=K+1; i++) {
	if (i==0 || i==K+1) printf("!");
	printf("P%dW%02d: ",myid,i);
	for (j=0; j<N; j++) {
	printf("%d",tab[i][j]); 
	}
	printf("\n");
	}*/
  }

  // zwolnienie pamieci
  for (i = rStart-1; i < rEnd+1; i++) {
    free(tab[i]); free(tab2[i]);
  }
  free(tab);
  free(tab2);
  MPI_Finalize();
  return 0;
}