//implementacao do hi-adsd
#include<stdio.h>
#include<stdlib.h>
#include "./smpl.h"
#include "./hipercube.h"
#include "./cisj.h"

#define test 1
#define fault 2
#define repair 3  /* 0 se o nodo i é sem-falha; 1 se o nodo i é falho */

typedef struct{
    int id; /* id do facility SMPL */
    int *STATE;
}tnodo;

/* Variaveis Globais */
tnodo *nodo;


void imprime_status(int token, int n){
        int j;
        /*Imprime vetor de estados do nodo*/
        printf("STATUS=[");
        for(j=0; j<n ; j++){
            if(nodo[token].STATE[j] == -1) /* -1 se o estado do nodo i é desconhecido, aplicando para todo o vetor */
                printf("* ");
            else
                printf("%d ",nodo[token].STATE[j]);
        }
        printf("]\n");

}

main(int argc, char** argv){
    static int n, /*numeros de nodos*/
            token, proxNode,
            event,
            r,
            i,j,
            s, /*cluster*/
            dim; /*dimensao do hipercube*/

    static char fa_name[5];
    
    /*C(i,s)*/
    node_set *nodes_tmp;

    int* fail_status;

    if(argc != 2){
        printf(" Uso correto: %s <dimensao> \n ",argv[0]);
        exit(1);
    }

    if(atoi(argv[1]) < 2){
        printf(" Valor de dimensão incorreto. Usar valores maiores que 1 \n ");
        exit(1);
    }

    /* Calcula quantidades de nodos de acordo com a dimensao do cubo */
    dim = atoi(argv[1]);
    n = pow(2, dim);

    smpl(0, "Exemplo de simulacao");
    reset();
    stream(1);

    printf("Nodos: %d\n",n);

    /* Inicializacao */
    nodo = (tnodo*)malloc(sizeof(tnodo)*n);

    fail_status = (int*)malloc(sizeof(int)*n);
   
    /* Vetor de estados de todos os nodos */ 
    for(i=0; i<n; i++){
        nodo[i].STATE = (int*)malloc(sizeof(int)*n); //dinamico
    }

    for (i=0; i<n; i++){
        memset(fa_name, '\0', 5);
        sprintf(fa_name, "%d",i);
        nodo[i].id = facility(fa_name,1);
        for(j=0;j<n;j++){
            nodo[i].STATE[j] = -1;  /* nodo j com estado indeterminado */
        }
        nodo[i].STATE[i] = 0;  /* nodo j com estado indeterminado */
   } 

    /*Escalonador de eventos*/
    for(i=0; i<n; i++){
       schedule(test, 10.0, i);
    }

    /*Eventos para testar o programa*/
    schedule(fault, 25.0, 2);
    schedule(repair, 95.0,2);

    /*Loop principal*/
    while(time() < 300.0){ //tempo
        cause(&event, &token);
        switch(event){
           case test:
               if(status(nodo[token].id) != 0)
                   break; /*nodo falho*/

        printf("==========================================================================\n");
               /*ALGORITMO Hi-ADSD*/
               /*Faz testes no seus vizinhos nos varios clusters*/
               for(s=1; s<dim+1; s++)
	       {
                    nodes_tmp = cis(token, s);

                    for(j=0;j<n;j++)
		    {
                        fail_status[j]=0;
                    }

                    for(i=0; i<nodes_tmp->size; i++)
		    {
                        proxNode = nodes_tmp->nodes[i];

                        /*Incializa vetor de nodos falhos detectados*/

                        printf("O nodo %d testa o nodo %d no tempo %5.1f: ", token, proxNode,time());
                        if(status(nodo[proxNode].id) == 0)
			{
                             printf(" Nodo %d está SEM-FALHA\n ",proxNode);

                             /**UPDATE Diagnose information*/
                             /*Get cluster information*/
                             printf("\t Pegando info do cluster %d a partir do nodo  %d \n",s,proxNode);
                             for(j=i+1; j<nodes_tmp->size ;j++)
			     {
                                  if((fail_status[nodes_tmp->nodes[j]]!=1))
				  {	 /*nao sobrescrever os nodos falhos detectados*/
                                     nodo[token].STATE[nodes_tmp->nodes[j]] =
                                     nodo[proxNode].STATE[nodes_tmp->nodes[j]];
                                   }//fim if
                             }//fim for

                             nodo[token].STATE[proxNode] = 0;

 
                             break;
                        }//fim if status==0
                        else 
			   {
                             printf(" Nodo %d está FALHO. Testando nodo %d\n",proxNode,nodes_tmp->nodes[i+1]);
                             nodo[token].STATE[proxNode] = 1;
                             fail_status[proxNode] = 1;
                           }//else
                    }//fim for
               }

               imprime_status(token,n);
               schedule(test, 10.0, token);
               break;
        case fault:
               r = request(nodo[token].id, token, 0);
               if(r!=0)
	       {
                   puts("Não foi possível falhar.\n");
                   exit(1);
                }//if
               // printf("\033[31m \n");
               printf("\t********************************************************************\n");
	       printf("\t********************************************************************\n");
	       printf("\t* *                                                              * *\n");
               printf("\t* *            O  nodo  %3d  FALHOU  no  tempo  %5.1f            * *\n", token,time());     
       	       printf("\t* *                                                              * *\n");
               printf("\t********************************************************************\n");
	       printf("\t********************************************************************\n");

               break;
        case repair:
               printf("\t********************************************************************\n");
               printf("\t********************************************************************\n");
       	       printf("\t* *                                                                *\n");
               printf("\t* *          O  nodo  %3d  RECUPEROU  no  tempo  %5.1f             *\n",token,time());
               printf("\t* *                                                                *\n");
               printf("\t********************************************************************\n");
	       printf("\t********************************************************************\n");
               release(nodo[token].id, token);
               schedule(test,30.0,token);
               break;
        } /* switch */
    } /* while */
} /* main */