package framepack.configurationpack;

import java.lang.reflect.Method;
import org.w3c.dom.*;
import toolspack.*;

/**
 * Classe deputata ad analizzare il BeanDescriptor.xml, quindi a istanziare application beans e session beans. Prevede una fase di
 * inizializzazione in cui crea, invocando il BeanDescriptorCreator, delle strutture dati in grado di velocizzare le successive
 * istanziazioni di session beans. Sempre in fase di inizializzazione provvede a istanziare e collegare correttamente gli application beans
 * @author Stefano Ricciarelli
 * @version 1.2 - Date: 28-06-2002
 */

public class BeanCreatorAndLinker {

  private static Document          beansDescriptorXML  = null;
  private static Object[]          applicationBeans    = null;
  private static ObjectSet         applicationBeansSet = null;

  private static String[]          applicationBeanNames;
  private static String[]          sessionBeanNames;
  private static Class[]           applicationBeanClasses;
  private static Class[]           sessionBeanClasses;
  private static BeanDescriptor[]  applicationBeanDescriptor;
  private static BeanDescriptor[]  sessionBeanDescriptor;

  /**
   * Costruttore
   * @param il documento beansDescriptorXML contenente le istruzioni per l'inizializzazione
   * dei bean
   */
  public BeanCreatorAndLinker(Document bdx) {
    beansDescriptorXML = bdx;
  }

  /**
   * Restituisce le istanze (sono uniche) degli applicationBeans correttamente
   * inizizializzate e configurate
   * @return l'ObjectSet contenente le istanze degli applicationBeans
   */
  public static ObjectSet getApplicationBeanInstances() {
    return applicationBeansSet;
  }

  /**
   * Restituisce delle nuove istanze dei sessionBeans correttamente inizizializzate e
   * configurate
   * @return l'ObjectSet contenente le istanze dei sessionBeans
   */
  public static ObjectSet getNewSessionBeanInstances() {
    Object[] sessionBeans = InstantiateSessionBeans();
    if (sessionBeans == null) return null;
    int i;
    ObjectSet sb = new ObjectSet();
    for (i=0; i<sessionBeans.length; i++)
      sb.setValue(sessionBeanNames[i], sessionBeans[i]);
    return sb;
  }

  /**
   * Provvede all'inizializzazione di tutte le strutture dati relative ai bean a
   * partire dal contenuto del documento di configurazione beansDescriptorXML passato
   * a questa classe all'atto della costrusione. NB: questo metodo statico deve quindi
   * essere chiamato solo dopo avere chiamato il costruttore della classe
   * @return true se l'operazione è andata a buon fine, false altrimenti
   */
  public static boolean initialize() {
    if (beansDescriptorXML == null) {
      Logger.print("Impossibile procedere all'inizializzazione. Invocare prima il costruttore!");
      return false;
    }
    Element sessionBeanElement = (Element)beansDescriptorXML
    .getElementsByTagName("sessionBeans").item(0);
    Element applicationBeanElement = (Element)beansDescriptorXML
    .getElementsByTagName("applicationBeans").item(0);
    if (sessionBeanElement == null || applicationBeanElement == null) {
      Logger.print("BeanCreatorAndLinker: ERRORE in BeansDescriptorXML");
      return false;
    }
    // 1 - inizializzo applicationBeanNames
    applicationBeanNames = createBeanNames(applicationBeanElement);
    if (applicationBeanNames == null) return false;
    // 2 - inizializzo sessionBeanNames:
    sessionBeanNames = createBeanNames(sessionBeanElement);
    if (sessionBeanNames == null) return false;
    // 3 - inizializzo applicationBeanClasses
    applicationBeanClasses = createBeanClasses(applicationBeanElement);
    if (applicationBeanClasses == null) return false;
    // 4 - inizializzo sessionBeanClasses
    sessionBeanClasses = createBeanClasses(sessionBeanElement);
    if (sessionBeanClasses == null) return false;
    // Creo i beanDescriptor
    BeanDescriptorCreator bdc = new BeanDescriptorCreator(applicationBeanNames
    ,sessionBeanNames, applicationBeanClasses, sessionBeanClasses);
    // 5 - inizializzo applicationBeanDescriptor
    applicationBeanDescriptor = bdc.createBeanDescriptor(applicationBeanElement);
    if (applicationBeanDescriptor == null) return false;
    Logger.print("applicationBeanDescriptor OK");
    // 6 - inizializzo sessionBeanDescriptor
    sessionBeanDescriptor = bdc.createBeanDescriptor(sessionBeanElement);
    if (sessionBeanDescriptor == null) return false;
    Logger.print("sessionBeanDescriptor OK");
    // 7 - creo gli applicationBeans
    if (!createAndLinkApplicationBean()) return false;
    Logger.print("Creazione ApplicationBeans OK");
    // 8 - creo l'ObjectSet degli applicationBeans
    applicationBeansSet = createApplicationBeansSet();
    return true;
  }

  /** Passi 1 e 2 dell'inizializzazione.
   * Analizza il sottoalbero <sessionBeans> o <applicationBeans> ed estrae i nomi
   * dei bean presenti
   * @param beanElement l'elemento <sessionBeans> o <applicationBeans> da analizzare
   * @return l'array di stringhe contenente i nomi dei bean presenti nell'elemento beanElement
   */
  private static String[] createBeanNames(Element beanElement) {
    NodeList beans = beanElement.getElementsByTagName("bean");
    String[]beanNames = new String[beans.getLength()];
    int j;
    for (j=0; j<beans.getLength(); j++) {
      beanNames[j] = ((Element)beans.item(j)).getAttribute("name");
      Logger.print("BeanCreatorAndLinker: creato il beanName \"" + beanNames[j]);
    }
    return beanNames;
  }

  /** Passi 3 e 4 dell'inizializzazione.
   * Analizza il sottoalbero <sessionBeans> o <applicationBeans> ed estrae i nomi
   * dei bean presenti
   * @param beanElement l'elemento <sessionBeans> o <applicationBeans> da analizzare
   * @return l'array di stringhe contenente i nomi dei bean presenti nell'elemento beanElement
   */
  private static Class[] createBeanClasses(Element beanElement) {
    NodeList beans = beanElement.getElementsByTagName("bean");
    int length = beans.getLength();
    Class[] beanClasses = new Class[length];
    int j;
    for (j=0; j<length; j++) {
      Element bean = (Element)beans.item(j);
      try { beanClasses[j] = Class.forName(bean.getAttribute("class"));
      } catch (Exception ex) {Logger.print("ERRORE in BeansDescriptorXML: " + ex);}
      Logger.print("BeanCreatorAndLinker: creata la beanClass \"" + beanClasses[j]);
    }
    return beanClasses;
  }

  /** Passo 7 dell'inizializzazione.
   * Crea, a partire dai beanDescriptor, le istanze degli applicationBean e le inizializza
   * correttamente eseguendo, nell'ordine: le chiamate iniziali, i collegamenti relativi
   * agli eventi, i collegamenti relativi ai riferimenti
   * @return true se l'operazione è andata a buon fine, false altrimenti
   */
  private static boolean createAndLinkApplicationBean() {
    int nbean = applicationBeanClasses.length;
    applicationBeans = new Object[nbean];
    int i, n, k;
    for (i=0; i<nbean; i++)
      try{
        //istanzio i bean
        applicationBeans[i] = applicationBeanClasses[i].newInstance();
        Logger.print("BeanCreatorAndLinker: creato l'application bean " +i+ " di "+nbean);
        //eseguo AB.initCall(params)
        if (applicationBeanDescriptor[i].initMethods != null) {
          n = applicationBeanDescriptor[i].initMethods.length;
          for (k=0; k<n; k++) {
            try{
              applicationBeanDescriptor[i].initMethods[k].invoke
              (applicationBeans[i], new Object[]{applicationBeanDescriptor[i].params[k]});
            } catch (Exception ex) {
              Logger.print("BeanCreatorAndLinker: ERRORE inizializzando l'applicationBean " + ex);
              return false;
            }
          }//for k
        }//if
        }
      catch (Exception ex) {
        Logger.print("BeanCreatorAndLinker: errore nella creazione degli oggetti applicationBean " + ex);
        return false;
      }
    for (i=0; i<nbean; i++) { //per ognuno degli applicationBeans:
      Logger.print("BeanCreatorAndLinker: collego l'application bean " +i);
      //eseguo AB.addListener(AB)
      if (applicationBeanDescriptor[i].addListenerMethods != null) {
        n = applicationBeanDescriptor[i].addListenerMethods.length;
        Object eventSourceBean;
        for (k=0; k<n; k++) { //eseguo AB.addListener(AB)
          try {
            if (applicationBeanDescriptor[i].eventSourceBeanIndexType[k] == 's') {
              Logger.print("BeanCreatorAndLinker: ERRORE nel beanLinkDescriptor");
              return false;
            }
            eventSourceBean = applicationBeans[applicationBeanDescriptor[i].eventSourceBeanIndex[k]];
            applicationBeanDescriptor[i].addListenerMethods[k].invoke(
              eventSourceBean, new Object[]{applicationBeans[i]});
          } catch (Exception ex) {
            Logger.print("BeanCreatorAndLinker: ERRORE collegando gli eventi degli applicationBeans");
            return false;
          }
        }//for k
        Logger.print("BeanCreatorAndLinker: settati "+k+" eventi per l'application bean "+i);
      }//if
      //eseguo AB.setReference(AB)
      if (applicationBeanDescriptor[i].setReferenceMethods != null) {
        n = applicationBeanDescriptor[i].setReferenceMethods.length;
        Object usedBean;
        for (k=0; k<n; k++) {
          try {
            if (applicationBeanDescriptor[i].usedBeanIndexType[k] == 's') {
              Logger.print("BeanCreatorAndLinker: ERRORE nel beanLinkDescriptor");
              return false;
            }
            usedBean = applicationBeans[applicationBeanDescriptor[i].usedBeanIndex[k]];
            applicationBeanDescriptor[i].setReferenceMethods[k].invoke(
              applicationBeans[i], new Object[]{usedBean});
          } catch (Exception ex) {
            Logger.print("BeanCreatorAndLinker: ERRORE collegando i riferimenti degli applicationBeans");
            return false;
          }
        }//for k
        Logger.print("BeanCreatorAndLinker: settati "+k+" riferimenti per l'application bean "+i);
      }//if
    }//for i
    return true;
  }

  /** Passo 8 dell'inizializzazione.
   * Inserisce in un ObjectSet gli applicationBeans creati e configurati e lo restituisce
   * al chiamante
   * @return l'ObjectSet degli applicationBeans
   */
  private static ObjectSet createApplicationBeansSet() {
    int i;
    ObjectSet ab = new ObjectSet();
    for (i=0; i<applicationBeans.length; i++)
      ab.setValue(applicationBeanNames[i], applicationBeans[i]);
    return ab;
  }

  /**
   * Crea, a partire dai beanDescriptor, delle nuove istanze dei sessionBean
   * e le inizializza correttamente eseguendo, nell'ordine: le chiamate iniziali,
   * i collegamenti relativi agli eventi, i collegamenti relativi ai riferimenti
   * @return l'array dei session beans creati e configurati correttamente, null in
   * caso di errore
   */
  private static Object[] InstantiateSessionBeans() {
    int nBean = sessionBeanClasses.length;
    Object[] sessionBeans = new Object[nBean];
    int i, n, k;
    for (i=0; i<nBean; i++)
      try{
        sessionBeans[i] = sessionBeanClasses[i].newInstance();
        //eseguo SB.initCall(params)
        if (sessionBeanDescriptor[i].initMethods != null) {
          n = sessionBeanDescriptor[i].initMethods.length;
          for (k=0; k<n; k++) {
            try{
              sessionBeanDescriptor[i].initMethods[k].invoke
              (sessionBeans[i], new Object[]{sessionBeanDescriptor[i].params[k]});
            } catch (Exception ex) {
              Logger.print("BeanCreatorAndLinker: ERRORE " + ex);
Logger.print("errore inizializzando il sessionBean "
+ sessionBeans[i] + " invocando il metodo " + sessionBeanDescriptor[i].initMethods[k] +
" guarda i parametri in errors.xml");
Logger.appendErrorXML(sessionBeanDescriptor[i].params[k], "parametri");
              return null;
            }
          }//for k
        }//if
      } catch (Exception ex) {
        Logger.print("BeanCreatorAndLinker: errore nella creazione degli oggetti sessionBeans " + ex);
        return null;
      }
    Logger.print("BeanCreatorAndLinker: creati tutti gli " + i + " sessionBeans");
    //Ho già creato tutti i bean: sia i SB che gli AB
    for (i=0; i<nBean; i++) { //per ognuno dei sessionBeans:
      //eseguo SB.addListener(SB) e SB.addListener(AB)
      if (sessionBeanDescriptor[i].addListenerMethods != null) {
        n = sessionBeanDescriptor[i].addListenerMethods.length;
        Logger.print("BeanCreatorAndLinker: collego il sessionBean " + i + " con " + n + "eventSource");
        Object eventSourceBean;
        for (k=0; k<n; k++) {
          try {
            if (sessionBeanDescriptor[i].eventSourceBeanIndexType[k] == 's')
                 eventSourceBean = sessionBeans    [sessionBeanDescriptor[i].eventSourceBeanIndex[k]];
            else eventSourceBean = applicationBeans[sessionBeanDescriptor[i].eventSourceBeanIndex[k]];
            sessionBeanDescriptor[i].addListenerMethods[k].invoke(
              eventSourceBean, new Object[]{sessionBeans[i]});
  Logger.print("BeanCreatorAndLinker: ho eseguito: " + eventSourceBean.toString() + "." +
  sessionBeanDescriptor[i].addListenerMethods[k].toString() + "(" +
  sessionBeans[i].toString() + ")" );
          } catch (Exception ex) {
            Logger.print("BeanCreatorAndLinker: ERRORE collegando gli eventi dei sessionBeans");
            return null;
          }
        }//for k
      }//if
      if (sessionBeanDescriptor[i].setReferenceMethods != null) {
        n = sessionBeanDescriptor[i].setReferenceMethods.length;
        Logger.print("BeanCreatorAndLinker: collego il sessionBean " + i + " con " + n + " altri bean");
        Object usedBean;
        for (k=0; k<n; k++) { //eseguo SB.setReference(AB) e SB.setReference(SB)
          try {
            if (sessionBeanDescriptor[i].usedBeanIndexType[k] == 's')
                 usedBean = sessionBeans    [sessionBeanDescriptor[i].usedBeanIndex[k]];
            else usedBean = applicationBeans[sessionBeanDescriptor[i].usedBeanIndex[k]];
            sessionBeanDescriptor[i].setReferenceMethods[k].invoke(
              sessionBeans[i], new Object[]{usedBean});
  Logger.print("BeanCreatorAndLinker: ho eseguito: " + sessionBeans[i].toString() + "." +
  sessionBeanDescriptor[i].setReferenceMethods[k].toString() + "(" +
  usedBean.toString() + ")" );
          } catch (Exception ex) {
            Logger.print("BeanCreatorAndLinker: ERRORE collegando i riferimenti dei sessionBeans");
            return null;
          }
        }//for k
      }//if
    }//for i
    return sessionBeans;
  }


} // FINE CLASSE