/* Programa: Simulacao do algoritmo VCube
    Autor: Eduardo Trevisan
    Data da ultima modificacao: 15/11/2021
*/

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

#define POW_2(num) (1<<(num))

/*----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; conta numero de eventos */
    int *failState; /* vetor que guarda estados falhos */
    int s; /* indice do cluster sendo testado atualmente */
} tnodo;

int main (int argc, char* argv[]) {
    static int	N, /* numero total de processos, entrado na linha de comando */
                token, /* o processo que "esta 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 simulacao");
    reset();
    stream(1);

    /* inicializacao de variaveis */
    tnodo* 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);
	nodo[i].failState = (int *) malloc(sizeof(int)*N);
	for (j=0; j<N; j++) {
	  nodo[i].state[j] = -1;
	  nodo[i].failState[j] = -1;
	}
	nodo[i].state[i] = 0;
	nodo[i].failState[i] = 0;
	nodo[i].s = 1;
    }

    /*---- 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 */
    
    /*---- inicio da simulacao ----*/
    while (time() < 100.0) 
    {
        cause(&event, &token);
        switch(event) 
	{
            case test:
                if (status(nodo[token].id)!=0) break; /* se o testador esta falho: ele nao testa */

		printf("nodo %d testando no tempo %3.1f [s=%d]:  ", token, time(), nodo[token].s);
		printCis(token, nodo[token].s);

		node_set* testList = cis(token, nodo[token].s);

		/* iterando sobre os nodos ate achar um nodo correto */
		for (int it = 0; it < testList->size; it++)
		{
		  i = testList->nodes[it];
		  if (i >= N) break;

		  if (status(nodo[i].id)!=0) /* nodo testado eh falho */
		  { 
		    printf("  nodo %d falho\n",i,time());
		    if (nodo[token].failState[i] != 1) { /* esta falha eh um evento novo? */
		      if (nodo[token].state[i] == -1) nodo[token].state[i] = 0;
		      nodo[token].state[i] += 1;    /* atualizando contador de eventos para i */ 
		      nodo[token].failState[i] = 1; /* atualizando nodo i para falho */
		    }
		  } 
		  else /* nodo testado eh correto */
		  {
		    printf("  nodo %d correto\n",i,time());
		    if (nodo[token].failState[i] != 0) /* este estado eh um evento novo? */ 
		    {
		      if (nodo[token].state[i] == -1) nodo[token].state[i] += 1;
		      nodo[token].state[i] += 1;    /* incrementando contador de eventos para i */ 
		      nodo[token].failState[i] = 0; /* atualizando nodo i para correto */
		    }

		    /* trocando info entre nodos token e i */
		    for (j=0;j<N;j++) 
		    {
		      if (nodo[token].state[j] >= nodo[i].state[j])
		      {
			nodo[i].state[j] = nodo[token].state[j];
			nodo[i].failState[j] = nodo[token].failState[j];
		      }
		      else
		      {
			nodo[token].state[j] = nodo[i].state[j];
			nodo[token].failState[j] = nodo[i].failState[j];
		      }
		    }
		    nodo[token].state[token] = 0;
		    nodo[token].failState[token] = 0;
		    nodo[i].state[i] = 0;
		    nodo[i].failState[i] = 0;
		    if (nodo[i].state[token] == -1) nodo[i].state[token] = 0;
		    nodo[i].failState[token] = 0;

		    //printf("------------\n%d= ",token);
		    //for (j=0;j<N;j++)
		    //  printf("%d:%d|",j,nodo[token].state[j]);
		    //puts("");
		    //printf("%d= ",i);
		    //for (j=0;j<N;j++)
		    //  printf("%d:%d|",j,nodo[i].state[j]);
		    //puts("");

		    break;
		  }
		}
		set_free(testList);
		/* atualizando s */
		nodo[token].s++;
		if (nodo[token].s > (N>>1)+1) nodo[token].s = 1;

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

                schedule(test, testInterval, token);
                break;

            case fault:
                r = request(nodo[token].id,token, 0);
                if (r!=0) 
		{
                    puts("Nao foi possivel falhar o nodo...");
                    break;
                }
                printf("nodo %d falhou no tempo %3.1f\n\n", token, time());
                break;
		
            case repair:
                release(nodo[token].id, token);
                printf("nodo %d recuperou no tempo %3.1f\n\n", token, time());
                schedule(test, testInterval, token);

		/* reset vetor de estados */
		for (j=0;j<N;j++)
		{
		  nodo[token].failState[j] = -1;
		  nodo[token].state[j] = -1;
		}
		nodo[token].state[token] = 0;
		nodo[token].failState[token] = 0;

                break;
        } /*switch*/
    } /*while*/
    exit(0);
} /*main*/