/*Trabalho Pratico 1
Nome: Acacia dos Campos da Terra
Disciplina: Topicos em redes e sistemas distribuidos*/
#include <stdio.h>
#include <stdlib.h>
#include "smpl.h"

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

/*estrutura do nodo*/
typedef struct{
	int id;
	int *STATE;
	int qtt_tests;
}tnodo;

tnodo *nodo;
int main(int argc, char const *argv[]) {
	static int N, token, event, r, i, testado, nf = 0, nsf = 0, rodada = 0;;
	static char fa_name[5];
	/*facility representa o objeto simulado*/

	if(argc != 2){
		puts("Uso correto: tempo <num-nodos>");
		exit(1);
	}

	printf("=============================================================================\n"); 
 	printf("Inicio da execucao: programa que implementa o Adaptive DSD.\n");
  	printf("Aluna Acacia dos Campos da Terra - Disciplina Redes e Sistemas Distribuidos\n");
  	printf("Modificado em 29/03/2018\n");
  	printf("=============================================================================\n\n"); 

	N = atoi(argv[1]);
	smpl(0, "programa tempo");
	reset();
	stream(1);
	nodo = (tnodo*) malloc(sizeof(tnodo)*N);
	for (i = 0; i < N; i++) {
	 	memset(fa_name, '\0', 5);
	 	printf(fa_name, "%d", i);
	 	nodo[i].id = facility(fa_name, 1);
		nodo[i].STATE = (int*) malloc(sizeof(int)*N);
		for(int j = 0; j < N; j++){ //for para inicializar o STATE de todos os nodos como UNKNOWN (-1)
			nodo[i].STATE[j] = -1;
		}
		nodo[i].qtt_tests = 0;//inicializa a quantidade de testes dos nodos com 0
	 }

	 /*schedule inicial*/
	 for (i = 0; i < N; i++)
	 	schedule(test, 30.0, i);
	 //Aqui estão os eventos que ocorrerão durante a simulação

	 schedule(fault, 31.0, 0);
	 schedule(fault, 90.0, 2);
	 schedule(fault, 110.0, 3);
	 schedule(fault, 150.0, 4);
	 schedule(repair, 275.0, 0);
	 schedule(repair, 275.0, 2);
	 schedule(repair, 275.0, 3);
	 schedule(repair, 275.0, 4);

	 while(time() < 300.0) {
	 	cause(&event, &token);
	 	switch(event) {
	 		case test:
	 		testado = (token+1)%N; //Próximo nodo no anel
			
	 		if(status(nodo[token].id) != 0) break; // se falho, quebra

			printf("Vetor STATE do nodo %d antes de efetuar o teste\n>> ", token);
			for(int j = 0; j < N; j++)
				//printa o vetor state do nodo atual (token) antes de efetuar os testes e atualizar os valores
				printf("%d ", nodo[token].STATE[j]);
			printf("\n");
			for(i = 0; i < N; i++){
				nodo[token].qtt_tests++;//incrementa quantidade de testes do nodo
				if(status(nodo[testado].id) != 0) {
					//se falho, atualiza STATE e printa na tela
					//após, ele avança a variável testado, até encontrar um que esteja sem-falha 
					nodo[token].STATE[testado] = 1;
					nf++;
					printf("O nodo %d encontrou o nodo %d FALHO no tempo %5.1f e continuou a procurar por um nodo sem-falha\n", token, testado, time());
					printf("O valor de STATE do nodo %d eh agora atualizado para 1\n", testado);
                    printf("-------------\n");
					testado++;
				} else if(testado != token){
					//se sem-falha e não é ele próprio, então atualiza STATE, printa na tela
					// e recebe informações de diagnóstico de testado
					nodo[token].STATE[testado] = 0; 
					nsf++;                   
					printf("O nodo %d encontrou o nodo %d SEM-FALHA no tempo %5.1f\n", token, testado, time());
					printf("O valor de STATE do nodo %d eh agora atualizado para 0\n", testado);
                    printf("-------------\n");
					for(int j = 0; j < N; j++) {
						if(nodo[token].STATE[j] == -1) {
							nodo[token].STATE[j] = nodo[testado].STATE[j];
						}
					}
					break;
				}
			}
			if(nsf + nf == N) {
				// se o número de nodos com falha + nodos sem falha for igual a N, então completou uma rodada
			 	rodada++;
		 		nsf = nf = 0;
		 		printf("\n....Fim da rodada %d....\n\n", rodada);
			}
	 		schedule(test, 30.0, token);
	 		break;
	 		case fault:
	 		r = request(nodo[token].id, token, 0);
	 		if(r != 0) {
	 			puts("Impossivel falhar nodo");
	 			exit(1);
	 		}
	 		printf("O nodo %d falhou no tempo %5.1f\n", token, time());
	 		break;
	 		case repair:
	 		release(nodo[token].id, token);
	 		printf("O nodo %d recuperou no tempo %5.1f\n", token, time());
	 		schedule(test, 30.0, token);
	 	}
	 }

	 printf("\n\n ----------- Fim do tempo do programa! Resultados: -----------\n\n");
	 if(status(nodo[token].id) == 0)//quando o nodo é sem-falha, printa o número de testes já executados por ele
			for(int j = 0; j < N; j++)
				printf("Numero de testes executados pelo nodo %d: %d\n", j, nodo[j].qtt_tests);
			printf("\n");
	 printf("\nNumero de rodadas completas de testes durante a simulacao: %d\n\n", rodada);
	return 0;
}