#include <stdio.h>

#include <math.h>

#include <stdlib.h>



#define SERVIDORES 5

#define NUMERO_COLAS 5

#define MAX_EN_COLA 15



typedef struct{

	int elem[MAX_EN_COLA];

	int cuenta;

	int frente;

	int ultimo;

}cola_t;



void ColaInicializar(cola_t *colap){

	colap->cuenta=colap->frente=colap->ultimo=0;

}



int ColaVacia(cola_t *colap){

	return colap->cuenta==0;

}



int ColaCuenta(cola_t *colap){

	return colap->cuenta;

}



int ColaMeter(cola_t *colap,int dato){

	if(colap->cuenta==MAX_EN_COLA)

		return 0;

	colap->cuenta++;

	colap->elem[colap->ultimo]=dato;

	colap->ultimo=(colap->ultimo+1)%MAX_EN_COLA;

	return 1;

}



int ColaSacar(cola_t *colap,int *dato){

	if(colap->cuenta==0)

		return 0;

	colap->cuenta--;

	*dato=colap->elem[colap->frente];

	colap->frente=(colap->frente+1)%MAX_EN_COLA;

	return 1;

}



// Estructuras para colas y servidores



cola_t colas[NUMERO_COLAS];



struct {

	int minimo;

	int maximo;

	int acumulado;

	int cantidad;

	int max_longitud;

} estadisticas_colas[NUMERO_COLAS];



struct {

	int media_atencion;

	int ocupado;

	int ocupado_hasta;

	int cola_que_atiende;

	int numeros_atendidos;

	int tiempo_acumulado;

} servidores[SERVIDORES];



int t_simulacion = 32400, t_cierre = 28800; // Tiempos simulacion



// Inicia colas



void inicia_colas(void){

	int i;



	for(i=0;i<NUMERO_COLAS;i++){

		ColaInicializar(&colas[i]);

		estadisticas_colas[i].minimo = 28800;

		estadisticas_colas[i].maximo = 0;

		estadisticas_colas[i].acumulado = 0;

		estadisticas_colas[i].cantidad = 0;

		estadisticas_colas[i].max_longitud = 0;

	}

}



// Inicia los servidores



void inicia_servidores(void){

	int i;



	for(i=0;i<SERVIDORES;i++){

		servidores[i].cola_que_atiende = i;

		servidores[i].ocupado = 1;

		servidores[i].ocupado_hasta =  150-i*10;	// tiempo inicio de atencion

		servidores[i].media_atencion = 300+i*5;

		servidores[i].numeros_atendidos = 0;

		servidores[i].tiempo_acumulado = 0;

	}

}



int cola_mas_corta(){

	int min, i, j;



	j=0;

	min=ColaCuenta(&colas[0]);

	for(i=1; i<NUMERO_COLAS; i++)

		if(min > ColaCuenta(&colas[i])){

			min = ColaCuenta(&colas[i]);

			j = i;

		}

	return j;

}



void actualiza_estadisticas_colas(int cola,int intervalo){

	if(estadisticas_colas[cola].minimo > intervalo)

		estadisticas_colas[cola].minimo = intervalo;

	if(estadisticas_colas[cola].maximo < intervalo)

		estadisticas_colas[cola].maximo = intervalo;

	estadisticas_colas[cola].acumulado += intervalo;

	estadisticas_colas[cola].cantidad ++;

	if(estadisticas_colas[cola].max_longitud < ColaCuenta(&colas[cola]))

		estadisticas_colas[cola].max_longitud = ColaCuenta(&colas[cola]);

}



void resumen_colas(void){

	int i, acumulado=0, cantidad=0;



	printf("\nEstadisticas Colas\n\n");

	printf("\tCola Clientes Minimo Maximo Promedio Max_Cant\n");

	printf("\t=============================================\n");

	for(i=0;i<NUMERO_COLAS;i++){

		printf("\t%4d %8d %6d %6d %8.2f %8d\n",i,estadisticas_colas[i].cantidad,

			estadisticas_colas[i].minimo,estadisticas_colas[i].maximo,

			(float)estadisticas_colas[i].acumulado/estadisticas_colas[i].cantidad,

			estadisticas_colas[i].max_longitud);

			acumulado += estadisticas_colas[i].acumulado;

			cantidad += estadisticas_colas[i].cantidad;

	}

	printf("\n\t Cantidad Atendida: %d Promedio: %.2f\n",

			cantidad,(float)acumulado/cantidad);

	printf("\n\t Intervalo de llegada medio: %.2f\n",(float)t_cierre/cantidad);

}



void resumen_servidores(void){

	int i, acumulado=0, cantidad=0;



	printf("\nEstadisticas Servidores\n\n");

	printf("\tServidor Clientes Promedio T_Ocupado T_Desocupado\n");

	printf("\t=================================================\n");

	for(i=0;i<SERVIDORES;i++){

		printf("\t%8d %8d %8.2f %9d %12d\n",i,servidores[i].numeros_atendidos,

			(float)servidores[i].tiempo_acumulado/servidores[i].numeros_atendidos,

			servidores[i].tiempo_acumulado, t_simulacion-servidores[i].tiempo_acumulado);

			acumulado += servidores[i].tiempo_acumulado;

			cantidad += servidores[i].numeros_atendidos;

	}

	printf("\n\t Cantidad Atendida: %d Promedio: %.2f\n",

			cantidad,(float)acumulado/cantidad);

}



// Calcula el intervarlo entre llegadas segun una distribucion exponencial



int intervalo(float lambda){

	float u,x;



	u = (float)rand() / RAND_MAX;

	x = -1.0*(float)log((double)(1.0-u)) * lambda;

	return (int)x;

}



int main(void) {

	int t_actual = 0, t_proximo;

	int t, c, i;

	int lambda_cliente = 60;



	inicia_servidores();

	inicia_colas();

	t_proximo = intervalo(lambda_cliente);

	while(t_actual <= t_simulacion){

		while(t_actual <= t_cierre && t_actual == t_proximo){

			c = cola_mas_corta();

			ColaMeter(&colas[c],t_actual);

			t_proximo = t_actual + intervalo(lambda_cliente);

		}

		for(i=0;i<SERVIDORES;i++){

			if(servidores[i].ocupado && servidores[i].ocupado_hasta == t_actual)

				servidores[i].ocupado = 0;

			if(!servidores[i].ocupado){

				c = servidores[i].cola_que_atiende;

				if(ColaSacar(&colas[c],&t)){

					actualiza_estadisticas_colas(c,t_actual-t);

					t = intervalo(servidores[i].media_atencion);

					servidores[i].ocupado = 1;

					servidores[i].numeros_atendidos++;

					servidores[i].tiempo_acumulado +=t ;

					servidores[i].ocupado_hasta = t_actual + t + 5;

				}

			}

		}

		t_actual++;

	}

	resumen_colas();

	resumen_servidores();

	return EXIT_SUCCESS;

}