//#exemplo tempo.c 
//Tarefa 4
#include <stdio.h>
#include <stdlib.h>
#include "smpl.h"

/*eventos*/
#define test 1
#define fault 2
#define repair 3
#define mostre 4

/*descritor do nodo*/
typedef struct {
	int id; /*identidificador de facility*/
	int* state; // identificador de status
	
/*variaveis sao declaradas aqui*/
}tnodo;

tnodo *nodo;

main (int argc, char *argv[]){
	static int n,
		   token,
		   event,
		   r,i,j,k,total_rodada,falhou,stop,ntestes,testes_falhos;

	static char
		fa_name[5];
	if (argc !=2){
		puts("use correto: tempo<num_nodos>");
	exit(1);
}

n = atoi (argv[1]);


smpl(0,"um exemplo de simulação");
reset();
stream(i);

/*inicialização*/
nodo= (tnodo*) malloc (sizeof (tnodo)*n);
total_rodada=0;
falhou=-1;
stop=1;
ntestes=0;
testes_falhos=0;

for (i=0; i < n; i++){
	memset(fa_name, '\0', 5);
	sprintf(fa_name, "%d", i);
	nodo[i].id=facility(fa_name,1);
	nodo[i].state = (int*) malloc (sizeof (int) *n); //aloca espaco pro vetor dinamico
	for (j=0; j < n; j++)     //laco para completar o vetor come stado indeterminado
	    if (i==j)  nodo[i].state[j] = 0;  //seu estado 
	    else nodo[i].state[j] = -1;  //estado indeterminado
}
  

/*escalonamento inicial dos eventos*/
for (i=0; i < n; i++){
			schedule(test, 30.0, i);
		      }		
		
schedule(fault, 31.0, 2);
schedule(repair, 121.0, 2);
schedule(mostre, 30.0, 0);

/*dispara o tempo de simulacao*/
while (time() < 270.0) 
{
	cause (&event,&token);
	
	switch (event)
	{
		case test:	
			if(status (nodo[token].id)!=0) ///nodo esta falho, cai fora	
			  break;
			int prox = token; // proximo recebe o token
			do {
			    prox = (prox+1)%n; //logica para anel
			    if (prox != token){ // executa somente se o proximo nao for o próprio nodo
			      if (status (nodo[prox].id)==0) 
				  {
					nodo[token].state[prox] = 0;
					k = prox;
					do  {
					      k = (k+1)%n; 
					      if (k != token) // o nodo sabe seu proprio estado
					      nodo[token].state[k] = nodo[prox].state[k];//recebe
					    } while (k != token);
				  }
				  else
				    nodo[token].state[prox] = 1; //estado falho
			         printf("o nodo %d vai testar o nodo %d no tempo %5.1f ", token, prox, time());
		
				/*IMPRIME O VETOR */
				  printf("\tvetor nodo %d =[", token);
				  for(i=0; i<n; i++)
				  {
			  	    if(nodo[token].state[i] == -1)
				      printf(" * "); /*indefinido*/
				    else if(nodo[token].state[i] == 1)
				      printf(" X "); /*falhou*/
				    else
				      printf(" %d ",nodo[token].state[i]);/*Fault-free=0*/
				  }//print do vetor
				  printf("]\n");
			    }//
			    			    
			} while (status (nodo[prox].id) !=0); 
			schedule(test,30.0, token);
			if (testes_falhos==1)
			{
			  ntestes++;
			}
			break;
		
		case fault:
			r=request(nodo[token].id,token,0);
			if (r!=0)
			{
			    puts("nao foi possivel falhar");
			    exit(1);
			}
			 
			    printf("o nodo %d falhou no tempo %5.1f\n", token, time());
			    nodo[token].state[token+1] == 1; 
			    falhou = token;//estado falho recebe o token
			    testes_falhos=1;
			    ntestes++;
			    break;
			    
		case repair:
		    printf("o nodo %d recuperou no tempo %5.1f\n", token,time());
		    release(nodo[token].id,token);
		    schedule(test,30.0,token);
		    falhou = -1; //retirando estado falho
		    break;
		    
		case mostre:
		  printf("==========================================================================================\n");
		  /*  mostre: (a) a latência, isto é tempo desde a ocorrência do evento até todos os nodos completarem seu diagnóstico; (b) o número de testes executados por todos os nodos durante o intervalo da latência. */
		    if(falhou != -1) 
		      total_rodada++;
		    	for(j=0; j<n; j++)
			 {
			if(nodo[falhou+1].state[j] == 1)
			  {	
			    ntestes++;
			    if(stop==1)// verificar isto
			    {
			      printf("###################################################################################### \n");
			      printf("#                        FALHA DIFUNDIDA EM  %d RODADAS             _o/              #  \n", total_rodada);
			      printf("#                          Testes executados durante latencia: %d                    #  \n", ntestes);
			      printf("###################################################################################### \n");
			      stop=-1;
			    }//fim if stop
			  }//fim if falho 
		        }//fim for
		      schedule(mostre,30.0,0);
		    break;
	} //fim switch
  
} //fim while
  
} //fim