/* Esame del 28/02/14
 * Una ditta che effettua vendite online dei propri prodotti gestisce le richieste di acquisto con un programma multithreading.
 * Questo programma è costituito da un thread che riceve le richieste e attiva, per ognuna di queste,
 * un thread per la gestione della richiesta stessa.
 * Il programma di gestione delle richieste è progettato in modo che abbia le seguenti caratteristiche:
 * 
 * 	- Non si possono gestire piu` di N richieste contemporaneamente: 
 * 	  se una richiesta arriva mentre nel sistema se ne stanno servendo N la nuova richiesta viene rifiutata
 * 	  (non rimane in attesa nel sistema);
 *
 *	- Ogni thread di gestione di una richiesta necessita della risorsa R per poter eseguire e tale risorsa
 *        puo' essere acquisita da un thread alla volta;
 *
 *	- Esistono due categorie di richieste, richieste di utenti gold e richieste di utenti silver:
 *	  alle richieste di utenti gold viene concesso l’uso della risorsa R con priorita' su quelle degli utenti
 *	  silver che attendono fino a quando non ci sono nel sistema thread che servono richieste gold.
 *
 *
 * Scrivere il programma in questione, usando il linguaggio C e la libreria pthread, concentrandosi solo
 * sugli aspetti di sincronizzazione tra i thread e di accesso alle risorse;
 * A tal scopo lasciare indicate in modo generico eventuali altre funzioni svolte dai thread.
 * Generare in modo casuale l’arrivo di richieste segnalandole tramite un semaforo su cui il thread di ricezione
 * si sincronizza.
 */

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

#define N 10


sem_t clienti; // # clienti
sem_t impiegati; // # impiegati liberi

typedef struct{
	int priority; // 1 gold, 0 silver
	char* richiesta;
} t_param;

pthread_mutex_t m_waiting;
int waiting;

sem_t s_priority; // Semaphore used to let silver user wait
int n; // numero di richieste in corso
pthread_mutex_t m_n; // mutex per n

int main(int argc, char const *argv[]){
	
	waiting = 0;

	return 0;
}

void* assegna_lavoro(){
	pthread_t tid;
	while(1){
		deaccoda();
		pthread_create(&tid, NULL, nuovoticket, (void *) &param);	
	}
}

void* nuovoticket(){

	pthread_mutex_lock(&m_n); // Inizio sez. critica
	if(n >= N){ // Se ci sono già N processi, sblocco mutex ed esco
		pthread_mutex_unlock(&m_n);
		return NULL;
	}
	++n;
	pthread_mutex_unlock(&m_n); // Fine sez. critica
	if(param->priority == 0) // Aspetto che non ci siano utenti con priorità gold.
		sem_wait(&s_priority);

	// LAVORO IL TICKET
	
	pthread_mutex_lock(&m_n); // Inizio sez. critica
	if(param->priority == 1 && n==0) // Se sono l'ultimo gold, rilascio priority così entrano eventuali silver
		sem_post(&s_priority);
	--n;
	pthread_mutex_unlock(&m_n);

}

// Probelmi:
// Il silver viene mai eseguito?