#include <stdlib.h>
#include <stdio.h>

typedef enum {CARGA = 0, DESCARGA} t_operacao;

typedef enum {OP_INVALIDA = 0, OK, CAP_TOTAL, CAP_ESGOTADA } t_resultado;

typedef enum {NORMAL = 0, URGENTE} t_urgencia;


typedef struct pedido {
   int        socket;
   t_operacao operacao;
   int        quantidade;
   t_urgencia urgencia;
} t_pedido;


typedef struct node {
	t_pedido* pedido;
	struct node* next;
} t_node;

typedef struct queue {
	t_node* head;
	t_node* tail;
} t_queue;


typedef struct prioqueue {
	t_queue* urgente;
	t_queue* normal;
} t_prioqueue;


void inserir(t_queue* q, t_pedido *p){
	t_node *elemento = malloc(sizeof(t_node));
	elemento->pedido = p;
	elemento->next = NULL;
	

	/* 1. insercao */
	if (q->head == NULL) {		
		q->head = elemento;
		q->tail = elemento;
	}
	
	/* depois da 1. insercao */
	else {
		q->tail->next = elemento;
		q->tail = elemento;
	}
	printf("pedido qnt: %d\n",q->tail->pedido->quantidade);
}


t_pedido* remover(t_queue* q){
	if (q->head == NULL) {
		return NULL;
	}
	t_node* head_antigo = q->head;
	t_pedido* val = head_antigo->pedido;
	free(head_antigo);
	q->head = q->head->next;
	return val;
}


void prioqueue_inserir(t_prioqueue *q, t_pedido *p) {
	if (p->urgencia == NORMAL) {
		inserir(q->normal, p);
	} else {
		inserir(q->urgente, p);
	}
}

t_pedido* prioqueue_remover(t_prioqueue *q) {
	if (q->urgente->head != NULL) {
		return remover(q->urgente);
	} else {
		return remover(q->normal);
	}
	return NULL;
}

int main(){

	t_pedido* elemento1;
	elemento1 = malloc(sizeof(t_pedido));
	elemento1->socket = 1;
	elemento1->operacao = DESCARGA;
	elemento1->quantidade = 1;
	elemento1->urgencia = NORMAL;
	
	t_pedido* elemento2;
	elemento2 = malloc(sizeof(t_pedido));
	elemento2->socket = 1;
	elemento2->operacao = DESCARGA;
	elemento2->quantidade = 2;
	elemento2->urgencia = NORMAL;
	
	t_pedido* elemento3;
	elemento3 = malloc(sizeof(t_pedido));
	elemento3->socket = 1;
	elemento3->operacao = DESCARGA;
	elemento3->quantidade = 3;
	elemento3->urgencia = NORMAL;
	
	t_pedido* elemento4;
	elemento4 = malloc(sizeof(t_pedido));
	elemento4->socket = 1;
	elemento4->operacao = DESCARGA;
	elemento4->quantidade = 4;
	elemento4->urgencia = NORMAL;
	
	
	t_prioqueue qnt_uni = {malloc(sizeof(t_queue)), malloc(sizeof(t_queue))};
	
	prioqueue_inserir(&qnt_uni, elemento1);
	printf("depois 1. insercao:\n");	
	printf("urgente_head: %d\n", qnt_uni.urgente->head->pedido->quantidade);
	//printf("urgente_tail: %d\n", qnt_uni.urgente->tail->pedido->quantidade);
	/*
	printf("normal_head: %d\n", qnt_uni.normal->head->pedido->quantidade);
	printf("normal_tail: %d\n", qnt_uni.normal->tail->pedido->quantidade);
	*/
	
	/*
	
	t_queue q = {NULL, NULL};
	
	inserir(&q, elemento1);
	printf("depois 1. insercao:\n");	
	printf("head: %d\n", q.head->pedido->quantidade);
	printf("tail: %d\n", q.tail->pedido->quantidade);

	inserir(&q, elemento2);
	printf("depois 2. insercao:\n");
	printf("head: %d\n", q.head->pedido->quantidade);
	printf("tail: %d\n", q.tail->pedido->quantidade);
	
	inserir(&q, elemento3);
	printf("depois 3. insercao:\n");
	printf("head: %d\n", q.head->pedido->quantidade);
	printf("tail: %d\n", q.tail->pedido->quantidade);
	
	inserir(&q, elemento4);
	printf("depois 4. insercao:\n");
	printf("head: %d\n", q.head->pedido->quantidade);
	printf("tail: %d\n", q.tail->pedido->quantidade);	
	
	printf("depois 1. remocao:\n");
	t_pedido *p = remover(&q);
	printf("elemento devolvido: %d\n", p->quantidade);
	free(p);
	printf("head: %d\n", q.head->pedido->quantidade);
	printf("tail: %d\n", q.tail->pedido->quantidade);
	*/
	return 0;
}