package toolspack;

import java.util.Vector;
import java.lang.reflect.*;
import java.lang.*;


/**
 * Crea un pool di oggetti che vengono gestiti attraverso acquire e release.
 * Affinché non si verifichino problemi deve essere usato solo con oggetti privi
 * di stato interno (ossia che producono sempre gli stessi output con stessi input),
 * viceversa chi usa gli oggetti del pool deve preoccuparsi di verificarne il loro
 * stato iniziale.
 * @author Stefano Ricciarelli
 * @version 1.2 - Date: 28-06-2002
 */
public class ObjectPool {

  private Object[] instances;
  private boolean[] busy;
  private int instanceNumber = 0;

  /** Da utilizzare solo nel caso in cui gli oggetti che dovranno fare parte del pool
   *  abbiano un costruttore senza argomenti.
   *  @param className nome della classe degli oggetti del pool
   *  @param num numero di istanze degli oggetti di classe className che devono essere presenti nel pool
   */
  //Vedi alla fine i vecchi costruttori commentati
  //Costruttore. Ovviamente non avrebbe senso renderlo synchronized! Ed infatti il compilatore lo rifiuta
  //Costruttore nel caso di oggetti con costruttore senza argomenti
  public ObjectPool(String className, int num) {
    Class classe;
    Logger.print(this, "Creazione del pool");
    try {
      classe = Class.forName(className);
      instanceNumber = num;
      instances = new Object[instanceNumber];
      busy = new boolean[instanceNumber];
      int i;
      for (i=0; i<instanceNumber; i++) {
        instances[i] = classe.newInstance();
        busy[i] = false;
      }
      Logger.print(this, "Creato pool di " + instanceNumber + "oggetti correttamente");
    }
    catch (Exception ex) {
      Logger.print(this, "Nessun pool di oggetti creato!");
      instanceNumber = 0;
      instances = null;
    }

  }

  /**
   * @param objectClassName nome della classe degli oggetti del pool
   * @param objectConstructorParam argomenti per costruire gli oggetti del pool
   * @param num numero di istanze degli oggetti di classe className che devono essere presenti nel pool
   */
  public ObjectPool(String objectClassName, Object[] objectConstructorParam, int num) {
    Logger.print(this, "Creazione del pool con parametro costruttore");
    try {
      Logger.print(this, "inzio...");
      Class objectClass = Class.forName(objectClassName);
      Logger.print(this, "Creazione di istanze di classe " + objectClass);
      Class[] objectConstructorParamType = getClasses(objectConstructorParam);
      Logger.print(this, "Con parametri del costruttore: " + objectConstructorParamType);
      Constructor objectConstructor = objectClass.getConstructor(objectConstructorParamType);
      Logger.print(this, "Creazione di istanze attraverso il costruttore " + objectConstructor);
      instanceNumber = num;
      instances = new Object[instanceNumber];
      busy = new boolean[instanceNumber];
      int i;
      for (i=0; i<instanceNumber; i++) {
        instances[i] = objectConstructor.newInstance(objectConstructorParam);
        busy[i] = false;
      }
    }
    catch (Exception ex) {
      Logger.print(this, "Creazione del pool abortita " + ex);
      instanceNumber = 0;
      instances = null;
    }
  }

  private static Class[] getClasses(Object[] o) {
    int i;
    int len = o.length;
    Class[] c = new Class[len];
    for (i=0; i<len; i++)
      c[i] = o[i].getClass();
    return c;
  }

  /**
   * Acquisisce un oggetto del pool se ne esiste uno libero, restituisce null altrimenti.
   * @return l'oggetto acquisito oppure null se nessun oggetto è disponibile
   */
  public synchronized Object acquireInstanceNoBlocking() {
    int i;
    for (i=0; i<instanceNumber; i++) {
      if (! busy[i]) {
        busy[i] = true;
        //Tester.print(this, "Acquire a buon fine, rilasciata l'istanza " + instances[i].toString());
        return instances[i];
      }
    }
    return null; //ritorna null se non c'è alcuna istanza disponibile
  }

  /**
   * Acquisisce un oggetto del pool. Nel caso non ne esista uno libero resta in
   * attesa indefinita che se ne liberi uno. Il metodo può quindi essere bloccante.
   * @return l'oggetto acquisito
   */
  public synchronized Object acquireInstance() {
    Object o = null;
    //Tester.print(this, "Tentativo di acquisire un istanza");
    while (o == null) {

      o = acquireInstanceNoBlocking();
      if (o == null) try {
        Logger.print(this, "Attesa per acquisire l'istanza");
        this.wait();}
        catch (Exception ex) {}
      // si usa così la wait? Non è che poi resta bloccato all'interno di questo metodo sync
      // e nessun altro possa più accedere agli altri metodi sync??
      // Bisogna forse usare una variabile condizione???
    }
    return o;
  }

  /** Acquisisce un oggetto del pool. Nel caso non ne esista uno libero resta in
   *  attesa che se ne liberi uno per al massimo msec millisecondi. Il metodo può
   *  quindi essere bloccante.
   *  @param msec tempo massimo d'attesa
   *  @return l'oggetto acquisito
   */
  public synchronized Object acquireInstanceTimeOut(int msec) {
    Object o = null;
    o = acquireInstanceNoBlocking();
    if (o == null) {
      try {
        this.wait(msec);
      }
      catch (Exception ex) {}
      o = acquireInstanceNoBlocking();
    }
    return o;
  }

  /**
   * Rilascia un'oggetto del pool che viene consegnato ad un altro eventuale cliente
   * in attesa di un oggetto o viene reso disponibile per future acquisizioni.
   * @param instance l'istanza da rilasciare
   */
  public synchronized void releaseInstance(Object instance) {
    int i;
    for (i=0; i<instanceNumber; i++) {
      // x.equals(y) e' analogo a x==y
      if (instances[i].equals(instance)) busy[i] = false;
    }
    this.notify();
    //Tester.print(this, "Pool: finita di eseguire la release");
  }

}

/*  //Costruttore nel caso di oggetti con costruttore con molteplici argomenti
  public ObjectPool(String className, Object[] paramValue, int num) {
    Class classe;
    Class[] paramClass;
    Constructor[] costruttori;
    Constructor costruttore;
    int i, j;
    int numArgCostruttore = paramValue.length;
    paramClass = new Class[numArgCostruttore];
    try {
      classe = Class.forName(className);
      costruttori = classe.getConstructors();
      for (j=0; j<numArgCostruttore; j++) {
        paramClass[j] = paramValue[j].getClass();
      }
      //index = length+1;
      i=0;
      boolean match;
      match = false;
      while ( match==false  && i<costruttori.length) {
        if (numArgCostruttore==costruttori[i].getParameterTypes().length) {
          match=true;
          j=0;
          while ( j<numArgCostruttore && match==true) {
            if ( (costruttori[i].getParameterTypes())[j].getName() != paramClass[j].getName() )
              match = false;
            j++;
          }
        }
        i++;
      }
      i--;
      //Ho determinato il giusto costruttore da usare
      costruttore = costruttori[i];
      instanceNumber = num;
      instances = new Object[instanceNumber];
      busy = new boolean[instanceNumber];
      for (i=0; i<instanceNumber; i++) {
        instances[i] = costruttore.newInstance(paramValue);
        busy[i] = false;
      }
    }
    catch (Exception ex) {
      instanceNumber = 0;
      instances = null;
    }
  }

  //Costruttore nel caso di oggetti con costruttore con un solo argomento
  public ObjectPool(String className, Object paramValue, int num) {
    Class classe;
    Class paramClass;
    Constructor[] costruttori;
    Constructor costruttore;
    int i, j;
    try {
      classe = Class.forName(className);
      costruttori = classe.getConstructors();
      paramClass = paramValue.getClass();
      i=0;
      boolean match;
      match = false;
      while ( match==false  && i<costruttori.length) {
        if (costruttori[i].getParameterTypes().length==1) {
          if ( (costruttori[i].getParameterTypes())[0].getName().equals(paramClass.getName()) )
            match = true;
        }
        i++;
      }
      i--;
      //Ho determinato il giusto costruttore da usare
      costruttore = costruttori[i];
      instanceNumber = num;
      instances = new Object[instanceNumber];
      busy = new boolean[instanceNumber];
      for (i=0; i<instanceNumber; i++) {
        instances[i] = costruttore.newInstance(new Object[]{paramValue});
        busy[i] = false;
      }
    }
    catch (Exception ex) {
      instanceNumber = 0;
      instances = null;
    }
  }
*/