/* Programa: um exemplo para aprender simulação SMPL
    no programa tempo.c os processos simplesmente contam o tempo.
    Autor: Prof. Elias e Eduardo Trevisan
    Data da última modificação: 15/11/2021
*/

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

/*----Eventos----*/
#define test 1
#define fault 2
#define repair 3

/*----Descritor do nodo SMPL----*/
typedef struct {
    int id; /* identificador da facility SMPL */
    int *state; /* vetor de estados dos nodos */
} tnodo;

tnodo *nodo;

int main (int argc, char* argv[]) {
    static int	N, /* número total de processos, entrado na linha de comando */
                token, /* o processo que "está executando" em um instante de tempo */
                event,
                r,
                i,j;
    static char fa_name[5]; /* nome da facility */
    static float testInterval = 30.0;

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

    N = atoi(argv[1]);
    smpl(0, "Um exemplo de simulação");
    reset();
    stream(1);

    /* inicialização de variáveis */
    nodo = (tnodo *) malloc(sizeof(tnodo)*N);
    for (i=0; i<N; i++) /* escreve nome do nodo */
    { 
        memset(fa_name, '\0', 5);
        sprintf(fa_name, "%d", i);
        nodo[i].id = facility(fa_name, 1);

	/* inicializando vetor de estados */
	nodo[i].state = (int *) malloc(sizeof(int)*N);
	for (j=0; j<N; j++) {
	  nodo[i].state[j] = -1;
	}
	nodo[i].state[i] = 0;
    }

    /*---- escalonar os eventos ----*/
    for (i=0; i<N; i++) {
        schedule(test,testInterval,i); /* estamos escalonando testes para todos os nodos executarem em t=30 */
    }
    schedule(fault, 31.0, 1); /* o processo 1 falha no tempo 31.0 */
    schedule(repair, 61.0, 1); /* o processo 1 recupera no tempo 61 */
    
    /*---- início da simulação ----*/
    while (time() < 100.0) 
    {
        cause(&event, &token);
        switch(event) 
	{
            case test:
                if (status(nodo[token].id)!=0) break; /* se o testador está falho: ele não testa */
		
		printf("nodo %d testando no tempo %3.1f:\n", token, time());
		/* iterando sobre os nodos até achar um nodo correto */
		for (i = (token+1)%N; i != token; i = (i+1)%N)
		{
		  if (status(nodo[i].id)!=0) /* nodo testado é falho */
		  { 
		    printf("  nodo %d falho\n",i,time());
		    nodo[token].state[i] = -2; /* atualizando nodo i no vetor de estados para falho */
		  } 
		  else /* nodo testado não é falho */
		  {
		    printf("  nodo %d correto\n",i,time());
		    nodo[token].state[i] = 1; /* atualizando nodo i no vetor de estados para correto */
		    break;
		  }
		}

		/* imprimindo vetor de estados */
		printf("  State[%d]: | ", token);
		for (i=0; i<N; i++)
		{
		  switch (nodo[token].state[i])
		  {
		    case 0:
		      break;
		    case 1:
		      printf("%d: correto | ", i);
		      break;
		    case -1:
		      printf("%d: unknown | ", i);
		      break;
		    case -2:
		      printf("%d: falho   | ", i);
		      break;
		  }
		}
		puts("");

                schedule(test, testInterval, token);
                break;

            case fault:
                r = request(nodo[token].id,token, 0);
                if (r!=0) 
		{
                    puts("Não foi possível falhar o nodo...");
                    break;
                }
                printf("nodo %d falhou no tempo %3.1f\n", token, time());
                break;
		
            case repair:
                release(nodo[token].id, token);
                printf("nodo %d recuperou no tempo %3.1f\n", token, time());
                schedule(test, testInterval, token);
                break;
        } /*switch*/
    } /*while*/
    exit(0);
} /*main*/