/*******************************************************************************
Arquivo: main.c
Autor: Gustavo Aschwanden Soviersovski
Função: Contém a função main e auxiliares de inicialização
Última Edição em: 31/05/2019
*******************************************************************************/

#include <stdlib.h>
#include <stdio.h>
#include "smpl.h"
#include "scheduler.h"
#include "handlers.h"
#include "nodo.h"
#include "loggers.h"
#include "constants.h"

tnodo *nodo;
//Vetor STATE global
int *globalState;

//Inicializa cada nodo e seu vetor state
void initNodos(int n){
    static int i, j;
    static char fa_name[5];
    nodo = (tnodo *) malloc (sizeof(tnodo)*n);
    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);
        for (j = 0; j < n; j++)
            nodo[i].state[j] = UNKNOWN;
        nodo[i].state[i] = OK;
    }
}

//Valida o n fornecido na entrada do programa (deve ser potência de 2)
int ehPotencia(int n) {
    int pot = 2;
    while (pot < n)
        pot *= 2;
    return n == pot;
}

int main (int argc, char *argv[]){
    double lastTime;
    int *failedThisEvent, *repairedThisEvent;
    static int n, token, event, schedule_id;
    double limit;
    if (argc != 3) {
        puts("Uso correto: tempo <num_nodos> <schedule_id>");
        exit(1);
    }
    n = atoi(argv[1]);
    if (!ehPotencia(n)) {
        puts("O numero de nodos especificado precisa ser uma potencia de 2");
        exit(1);
    }
    //Inicializa variaveis de controle
    schedule_id = atoi(argv[2]);
    failedThisEvent = (int *)calloc(n, sizeof(int));
    repairedThisEvent = (int *)calloc(n, sizeof(int));
    globalState = (int *)calloc(n, sizeof(int));
    smpl(0,"VCube");
    reset();
    stream(1);
    initNodos(n);
    //Agenda todos os eventos
    limit = scheduler(schedule_id, n);
    lastTime = time();
    //Enquanto ainda há eventos ou diagnosticos a serem realizados
    while (time() < limit) {
        cause(&event, &token);
        if (time() >= limit)
            break;
        switch(event) {
            case (TEST):
                logLastEvent(failedThisEvent, repairedThisEvent, n, lastTime);
                testHandler(token, n);
                lastTime = time();
                break;
            case (FAULT):
                faultHandler(token, n);
                if (time() != lastTime)
                    logLastEvent(failedThisEvent, repairedThisEvent, n, lastTime);
                failedThisEvent[token] = time();
                lastTime = time();
                break;
            case (REPAIR):
                repairHandler(token, n);
                if (time() != lastTime)
                    logLastEvent(failedThisEvent, repairedThisEvent, n, lastTime);
                repairedThisEvent[token] = 1;
                lastTime = time();
                break;
            case (BROADCAST):
                logBroadcast(token);
                broadcastHandler(token, lg(n));
                break;
        }
    }
}