#include "pro.h"

//Señal de cierre
static void sig_usr(int signo){
	if (signo == SIGINT||SIGSEGV){
		system("pkill octave-cli");
		exit(1);
	}
	return;
}


//Funcion Principal
int main(int argc, char *argv[]){
		atexit(salir);
		//Señales de interrupcion
		if (signal(SIGINT, sig_usr) == SIG_ERR)
			err_sys("can't catch the signal");
		if (signal(SIGSEGV, sig_usr) == SIG_ERR)
			err_sys("can't catch the signal");
		system("clear");
		if (argc==1){
			experimentos=1;
		}
		else if (!strcmp(argv[1],"t")){
			
			i=0;
			do{
				if(!i){
					i++;
					printf("Determine la cantidad de experimentos a realizar:");
				}
				scanf("%s",&exper);
				c=getchar();
				experimentos=atoi(&exper);
				if(i&!experimentos) printf("Debe ingresar un numero:");
			}while (!experimentos);
			printf("\n");
		}
		else{
			printf("Debe ingresar t como parametro opcional\n");
			exit(1);
		}
		//Ingreso de datos por pantalla
		ingreso_datos();
		//Variables para almacenamiento de datos.
        float inst[cantidad]; //Instante de llegada de cada paquete 
        float inst2[cantidad]; //Instante de llegada de cada paquete 
        float time[cantidad]; //Tiempos de atencion 
        float inst_cola[cantidad]; 
        float entre_reduce[cantidad]; 
        float wait_time[cantidad]; 
        float system_time[cantidad];
        //Llamada a Octave
        forkOctave();
		
		//Manejo de hebras
		pthread_attr_init(&attr);
		pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
		
		//Para datos acumulados para k experimentos
		float largo_cola_acum=0;
		float tiempo_espera_acum=0;
		float tiempo_sistema_acum=0;
		float tasa_de_ocupacion_acum=0;
		      
        //Loop para hacer "d" cantidad de experimentos
        for(d=0;d<experimentos;d++){
			//Se generan los datos
			//Se obtienen los tiempos entre llegadas, el instante de llegada
			//de cada paquete, y el tiempo ocupado en cada atencion
			//Llegadas de paquetes
			instante_llegada=instante_llegadas_paquetes(inst);
			tiempo_entre_llegadas=entre_llegadas(instante_llegada,inst2);
			//Comportamiento del servidor
			tiempo_ocupado=time_busy(time);
			instante_reduce_cola=tiempo_reduce_cola(inst_cola,instante_llegada,tiempo_ocupado);
			tiempo_entre_reduce=entre_reduce_cola(entre_reduce,instante_reduce_cola);
			//Datos para comprobacion de Leyes de Little
			tiempo_espera=average_wait_time(wait_time,instante_reduce_cola,instante_llegada,tiempo_ocupado);
			tiempo_sistema=average_system_time(system_time,instante_reduce_cola,instante_llegada);
			tasa_de_ocupacion=tasa_ocupacion(tiempo_ocupado,instante_reduce_cola);
			//Simulacion de comportamiento del servidor y llegada de paquetes
			manejo_cola();
			//Resultados acumulados
			largo_cola_acum+=largo_cola/datos;
			tiempo_espera_acum+=tiempo_espera;
			tiempo_sistema_acum+=promedio(tiempo_sistema);
			tasa_de_ocupacion_acum+=tasa_de_ocupacion;
		}
		//Atenciones y llegadas en Octave
		pid=fork();
		if(pid==0){
			llegadas_octave(instante_llegada,sd);
			if(PAQUETES_ATENDIDOS)
				atencion_octave(instante_reduce_cola,sd);
			else
			atencion_octave(tiempo_ocupado,sd);
		}
		else{
			if(1/lambdapoisson<=lambdaexponencial){	
				printf("Sistema colapsado, tasa de ocupacion de %.3f\n",ocup_little());
			}
			printf("El largo promedio de la cola es %f\n",largo_cola_acum/experimentos);
			printf("Segun la Ley de Little es %f\n",cola_little());
			printf("El tiempo medio de espera es %f\n",tiempo_espera_acum/experimentos);
			printf("Segun la Ley de Little es %f\n",tiempo_espera_little());
			printf("El tiempo medio en sistema es %f\n",tiempo_sistema_acum/experimentos);
			printf("Segun la Ley de Little es %f\n",tiempo_sistema_little());
			printf("La tasa de ocupacion del servicio es: %f\n",tasa_de_ocupacion_acum/experimentos);
			printf("Segun la Ley de Litle es: %.3f\n",ocup_little());
			//Cerrar programa
			//Enviar exit a Octave
			fflush(sd);
			printf("Aprete enter para cerrar\n");
			getchar();// Para salir al apretar una tecla
			//~ getchar();
			//~ getchar();
			fprintf(sd, "\n exit\n"); 
			fflush(sd);
		}
		
		//Manejo de hebras
		pthread_attr_destroy(&attr);
		pthread_exit(NULL);
		
		//Manejo de procesos
		waitpid(pid,&status,0);
		fclose(sd);
        return 0;
}