package gestorerisorse;

// utilizzo i semafori della libreria concurrent
import java.util.Vector;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;

// dichiaro la classe GESTORE e costruisco il semaforo
public class Manager extends Thread
{

    private Semaphore risorse;          // Semaforo che simul le risosrse disponibili
    private Semaphore attesaProcessi[];   // Semaforo dove si mettono in attesa i processi in attesa di risosrse
    private Vector<Process> codaAttesa1;  // Coda dei Processi in attesa di una risorsa
    private Vector<Process> codaAttesa2;  // Coda dei Processi in attesa di due richieste

    private int sumTime = 0;

    private int count = 0;


    private Lock mutex;

    // dichiaro il costruttore
    public Manager(int m , int n)
    {
        // Il semaforo si occupa di effettuare la sincronizzazione dei threads
        // e l'attesa perchè si liberino le risorse

        this.risorse = new Semaphore(m);

        this.codaAttesa1 = new Vector();
        this.codaAttesa2 = new Vector();

        this.attesaProcessi = new Semaphore[n];

         // Inizializzo i vari semafori dei Processi con 0 permessi
        for(int i = 0; i < n; i++)
            this.attesaProcessi[i] = new Semaphore(0);

        this.mutex = new ReentrantLock();
    }

    // definisco i metodi
    public void richiestaUno(Process p)
    {

        // controllo il tempo iniziale di attesa che mi sarà utile poi
        // per controllare il suo valore dopo la richiesta di una risorsa
        this.mutex.lock();

        System.out.println("Il processo" +p.pid +" richiede una risorsa");
        System.out.println("risorse: " +this.risorse.availablePermits());

        try
        {
            if(this.risorse.tryAcquire(1))
            {
                this.risorse.acquire();
                System.out.println("Risorsa assegnata al processo" +p.pid);
            }
            else
            {
                System.out.println("Non sono disponibili risorse quindi metto in attesa il processo" +p.pid);
                // Non posso asseganre una risorsa al processo
                this.codaAttesa1.addElement(p);
                this.mutex.unlock();
                this.attesaProcessi[p.pid].acquire();
            }

        }
        catch (InterruptedException ex)

        {
            System.out.println(ex);
        }
        finally
        {
            this.mutex.unlock();
            this.count++;
        }
    }

    public void richiestaDue(Process p)
    {

        // come sopra faccio il calcolo del tempo prima della richiesta di due risorse

        this.mutex.lock();

        System.out.println("Il processo" +p.pid +" richiede due risorse");
        System.out.println("risorse: " +this.risorse.availablePermits());

        try
        {
            if(this.risorse.tryAcquire(2))
            {
                this.risorse.acquire(2);


                System.out.println("Risorsa assegnata al processo" +p.pid);
            }
            else
            {
                System.out.println("Non sono disponibili risorse quindi metto in attesa il processo" +p.pid);
                this.codaAttesa2.addElement(p);
                this.mutex.unlock();
                this.attesaProcessi[p.pid].acquire();
            }
        }
        catch (InterruptedException ex)
        {
            System.out.println(ex);
        }
        finally
        {
            this.mutex.unlock();
            this.count++;
        }

    }

    public void rilascioUno()
    {
        // Rilaslio una risorsa
        this.risorse.release();

        // Visto che un processo ha rilasciato una risorsa gestisco gli eventuali processi in attesa di risorse
        this.gestisciProcessi();

        System.out.println(Thread.currentThread().getName() + " ha rilasciato 1 risorsa");
        System.out.println("risorse: " +this.risorse.availablePermits());

    }

    public void rilascioDue()
    {
        // Rilascio due risosrse
        this.risorse.release(2);

        // Visto che un processo ha rilasciato una risorsa gestisco gli eventuali processi in attesa di risorse
        this.gestisciProcessi();

        System.out.println(Thread.currentThread().getName() + " ha rilasciato 2 risorse");
        System.out.println("risorse: " +this.risorse.availablePermits());
    }

    public void gestisciProcessi()
    {
        int minore = 0;

        System.out.println("Controllo se ci sono processi in coda e le risorse rilasciate sono sufficienti");

        // Controllo se ci sono 2 risorse disponibili e almeno un processo attende per due risorse
        while (this.risorse.tryAcquire(2) && !this.codaAttesa2.isEmpty())
        {

            // Cerco il processo di pid minore
            for(int i = 0; i < this.codaAttesa2.size(); i++)
            {
                 if (this.codaAttesa2.elementAt(minore).pid > this.codaAttesa2.elementAt(i).pid)
                 {
                     minore = i;
                 }
                 try
                 {
                     // Assegno le risorse al processo con indice nel vettore (minore)
                     this.risorse.acquire(2);
                     this.attesaProcessi[this.codaAttesa2.elementAt(minore).pid].release();
                     System.out.println("Assegno 2 risorse al processo" +this.codaAttesa2.elementAt(minore).pid +" in coda alla posizione: " +minore);
                     this.codaAttesa2.remove(minore);
                 }
                 catch(InterruptedException e)
                 {
                    System.out.println(e);
                 }
            }
        }

        // Azzero l'indice del processo con pid minore
        minore = 0;

        // Controllo se c'è 1 risorsa disponibile e almeno un processo attende per una risorsa
        while (this.risorse.tryAcquire(1) && !this.codaAttesa1.isEmpty())
        {

            // Cerco il processo di pid minore
            for(int i = 0; i < this.codaAttesa1.size(); i++)
            {
                 if (this.codaAttesa1.elementAt(minore).pid > this.codaAttesa1.elementAt(i).pid)
                 {
                     minore = i;
                 }
                 try
                 {
                     // Assegno le risorse al processo con indice nel vettore (minore)
                     this.risorse.acquire(1);
                     this.attesaProcessi[this.codaAttesa1.elementAt(minore).pid].release();
                     System.out.println("Assegno 1 risorsa al processo" +this.codaAttesa1.elementAt(minore).pid +" in coda alla posizione: " +minore);
                     this.codaAttesa1.remove(minore);
                 }
                 catch(InterruptedException e)
                 {
                    System.out.println(e);
                 }
            }
        }
    }

    // Creo un metodo che per salvare il totale dei tempi di attesa dei vari processi
    // utile per calcolare poi il tempo medio di attesa
    public void sumTime(int currTime)
    {
        this.sumTime += currTime;
    }

    // Con il metodo getCount ritorno il numero di volte che ho calcolato
    // un waiting time, ciclando n-volte e incrementando la variabile count
    public double getAvgTime()
    {
        return this.sumTime / count;

    }
}