package framepack.configurationpack;

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

/**
 * Classe deputata all'elaborazione degli elementi <applicationBeans> e <sessionBeans> del BeanDescriptor.xml. Produce per l'insieme
 * di application e session beans in questione un array di BeanDescriptor
 * @author Stefano Ricciarelli
 * @version 1.2 - Date: 28-06-2002
 */

public class BeanDescriptorCreator {

  private static String[] abn; //applicationBeanNames
  private static String[] sbn; //sessionBeanNames
  private static Class[]  abc; //applicationBeanClasses
  private static Class[]  sbc; //sessionBeanClasses

  public BeanDescriptorCreator(String[] abn, String[] sbn, Class[] abc, Class[] sbc) {
    this.abn = abn;
    this.sbn = sbn;
    this.abc = abc;
    this.sbc = sbc;
  }

  /**
   * Unico metodo pubblico. Dato un insieme di bean, sessionBeans o applicationBeans,
   * presenti nell'elemento beanElement restituisce un'array di descrittori per questi bean
   * @param beanElement il sottoalbero dei bean, ad esempio:
   * <applicationBeans>
   *    <bean ... />
   *    <bean ... />
   * </applicationBeans>
   * @return un array di descrittori, uno per ciascun bean.
   */
  public BeanDescriptor[] createBeanDescriptor(Element beanElement) {
    //tipoBean = sessionBeans OR applicationBeans
    String tipoBean = beanElement.getNodeName();
    //Seleziono tutti i tag <bean> del beanElement
    NodeList BeanNodes = beanElement.getElementsByTagName("bean");
    int BeanNumber = BeanNodes.getLength();
    BeanDescriptor[] beanDescriptor = new BeanDescriptor[BeanNumber];
    int i; NodeList nodeList; Element beanTag;
    Class beanClass;
    //Logger.print("BeanDescriptorCreator: createBeanDescriptor: BeanNumber = " + BeanNumber);
    for (i=0; i<BeanNumber; i++) {
      Logger.print(this, "createBeanDescriptor per il bean "
        + (tipoBean.equals("applicationBeans") ? abn[i]: sbn[i]) );
      beanDescriptor[i] = new BeanDescriptor();
      //considero l'i-esimo tag <bean>
      beanTag  = (Element)BeanNodes.item(i);
      //elaboro tutti i tag <listenTo> di questo bean
      nodeList = beanTag.getElementsByTagName("listenTo");
      if (! setEventLink(nodeList, beanDescriptor[i], tipoBean) ) return null;
      Logger.print(this, "setEventLink OK per il bean "
        + (tipoBean.equals("applicationBeans") ? abn[i]: sbn[i]) );
      //elaboro tutti i tag <usedBean> di questo bean
      nodeList = beanTag.getElementsByTagName("usedBean");
      if (tipoBean.equals("sessionBeans")) beanClass = sbc[i];
      else  beanClass = abc[i];
      if (! setReferenceLink(nodeList, beanDescriptor[i], tipoBean, beanClass) ) return null;
      Logger.print(this, "setReferenceLink OK per il bean "
        + (tipoBean.equals("applicationBeans") ? abn[i]: sbn[i]) );
      //elaboro tutti i tag <initCall> di questo bean
      nodeList = beanTag.getElementsByTagName("initCall");
      if (tipoBean.equals("sessionBeans")) beanClass = sbc[i];
      else beanClass = abc[i];
      if (! setInitCall(nodeList, beanDescriptor[i], tipoBean, beanClass) ) return null;
      Logger.print(this, "setInitCall OK per il bean "
        + (tipoBean.equals("applicationBeans") ? abn[i]: sbn[i]) );
    }
    return beanDescriptor;
  }

  /**
   * Dato un bean di tipo tipoBean e un elenco di nodi del tipo:
   * <initCall methodName="nomeMetodo">
   *     <params>
   *       <param value="valore"/>
   *     </params>
   * </initCall>
   * provvede ad aggiornare i campi initMethods e params del beanDescriptor
   * inserendovi tutti i metodi e relativi parametri da chiamare per questo bean
   * @param nodeList la lista dei nodi di tipo <initCall> del bean
   * @param beanDescriptor il beanDescriptor del bean
   * @param tipoBean il tipo di bean
   * @param beanClass la classe del bean
   * @return true se l'operazione è andata a buon fine, false altrimenti
   */
  private static boolean setInitCall(NodeList nodeList, BeanDescriptor beanDescriptor
  , String tipoBean, Class beanClass) {
  try{
    Logger.print("BeanDescriptorCreator: setInitCall per il bean di classe " + beanClass);
    int initCallNumber = nodeList.getLength();
    beanDescriptor.initMethods = new Method   [initCallNumber];
    beanDescriptor.params      = new Document [initCallNumber];
    int k, index;
    String methodName;
    Element initCallElement;
    XmlTools xmlTools = XmlTools.getInstance();
    for (k=0; k<initCallNumber; k++) {
      Logger.print("BeanDescriptorCreator: setInitCall: ciclo " + k);
      initCallElement = (Element)nodeList.item(k);
      methodName      = initCallElement.getAttribute("methodName");
      NodeList params = initCallElement.getElementsByTagName("params");
      if (params.getLength() > 1) {
        Logger.print("BeanDescriptorCreator: setInitCall: ERRORE troppi parametri");
        return false;
      }
      if (params.getLength()==0) { //nessun parametro
        beanDescriptor.params[k] = null;
        try {beanDescriptor.initMethods[k] = beanClass.getMethod(methodName
        , new Class[]{}); }
        catch (Exception ex) {
          Logger.print("BeanDescriptorCreator: setInitCall: ERRORE " + ex);
          return false;
        }
      } else { //un parametro
        Document doc = xmlTools.newDocument();
        doc.appendChild(doc.importNode(params.item(0), true));
        beanDescriptor.params[k] = doc;
        try { beanDescriptor.initMethods[k] = beanClass.getMethod(methodName
        , new Class[]{Class.forName("org.w3c.dom.Document")}); }
        catch (Exception ex) {
          Logger.print("BeanDescriptorCreator: setInitCall: ERRORE " + ex);
          return false;
        }
      }
    } //for k
    return true;
  }catch(Exception ex) {
    Logger.print("BeanDescriptorCreator: setInitCall: ERRORE " + ex);
    return false;
  }//catch
  }


  /**
   * Dato un bean di tipo tipoBean e un elenco di nodi del tipo:
   * <listenTo eventSource="beanSorgenteEventi" eventName="nomeEvento"
   * eventPackage="packageEvento" />
   * provvede ad aggiornare i campi eventSourceBeanIndex, eventSourceBeanIndexType,
   * addListenerMethods del beanDescriptor inserendovi l'indice del bean sorgente
   * degli eventi, il tipo di tale bean (a/s) e il metodo di tale bean per aggiungervi
   * un listener
   * @param nodeList la lista dei nodi di tipo <listenTo> del bean
   * @param beanDescriptor il beanDescriptor del bean
   * @param tipoBean il tipo di questo bean
   * @return true se l'operazione è andata a buon fine, false altrimenti
   */
  private static boolean setEventLink(
  NodeList nodeList, BeanDescriptor beanDescriptor, String tipoBean) {
    Logger.print("BeanDescriptorCreator: setEventLink: entrato");
    int eventSourceBeanNumber = nodeList.getLength();
    beanDescriptor.eventSourceBeanIndex     = new int   [eventSourceBeanNumber];
    beanDescriptor.eventSourceBeanIndexType = new char  [eventSourceBeanNumber];
    beanDescriptor.addListenerMethods       = new Method[eventSourceBeanNumber];
    int k, index;
    String eventSourceBeanName, eventName, eventPackage;
    Element eventSourceElement;
    for (k=0; k<eventSourceBeanNumber; k++) {
      Logger.print("BeanDescriptorCreator: setEventLink: ciclo " + k);
      eventSourceElement   = (Element)nodeList.item(k);
      eventSourceBeanName  = eventSourceElement.getAttribute("eventSource");
      eventName            = eventSourceElement.getAttribute("eventName");
      eventPackage         = eventSourceElement.getAttribute("eventPackage");
      Class eventSourceBeanClass;
      if (tipoBean.equals("applicationBeans")) {
        //cerco la sorgente degli eventi prima fra gli AB e poi fra i SB
        index = search(abn, eventSourceBeanName);
        if (index == -1) {
          index = search(sbn, eventSourceBeanName);
          if (index == -1) {Logger.print("BeanDescriptorCreator: ERRORE inizializzando gli eventi"); return false; }
          eventSourceBeanClass = sbc[index];
          beanDescriptor.eventSourceBeanIndexType[k] = 's';
        } else {
          eventSourceBeanClass = abc[index];
          beanDescriptor.eventSourceBeanIndexType[k] = 'a';
        }
        beanDescriptor.eventSourceBeanIndex[k] = index;
      } else {
        //cerco la sorgente degli eventi solo fra i SB
        index = search(sbn, eventSourceBeanName);
        if (index == -1) {Logger.print("BeanDescriptorCreator: ERRORE inizializzando gli eventi"); return false; }
        eventSourceBeanClass = sbc[index];
        beanDescriptor.eventSourceBeanIndex[k]     = index;
        beanDescriptor.eventSourceBeanIndexType[k] = 's';
      }

      try {
        Method method =
          eventSourceBeanClass.getMethod("add" + eventName + "Listener",
          new Class[]{Class.forName(eventPackage + "." + eventName + "Listener")});
        beanDescriptor.addListenerMethods[k] = method;
      } catch (Exception ex) {Logger.print("errore inizializzando gli eventi2");return false; }
    }//for
  return true;
  }


  /**
   * Dato un bean di tipo tipoBean e un elenco di nodi del tipo:
   * <usedBean beanName="nomeBean" setReferenceMethod="nomeMetodoSet" />
   * provvede ad aggiornare i campi usedBeanIndex, usedBeanIndexType, setReferenceMethods
   * del beanDescriptor inserendovi l'indice del bean da inserire come riferimento,
   * il tipo di bean (a/s) e il metodo da utilizzare per settare il riferimento.
   * @param nodeList la lista dei nodi di tipo <usedBean> del bean
   * @param beanDescriptor il beanDescriptor del bean
   * @param tipoBean il tipo di bean
   * @param usingBeanClass la classe di questo bean
   * @return true se l'operazione è andata a buon fine, false altrimenti
   */
  private static boolean setReferenceLink(
  NodeList nodeList, BeanDescriptor beanDescriptor, String tipoBean, Class usingBeanClass) {
    Logger.print("BeanDescriptorCreator: setReferenceLink: entrato");
    int usedBeanNumber = nodeList.getLength();
    beanDescriptor.usedBeanIndex       = new int   [usedBeanNumber];
    beanDescriptor.usedBeanIndexType   = new char  [usedBeanNumber];
    beanDescriptor.setReferenceMethods = new Method[usedBeanNumber];
    int k, index;
    String usedBeanName, setReferenceMethodName;
    Element usedBeanElement;
    for (k=0; k<usedBeanNumber; k++) {
      Logger.print("BeanDescriptorCreator: setReferenceLink: ciclo " + k);
      usedBeanElement        = (Element)nodeList.item(k);
      usedBeanName           = usedBeanElement.getAttribute("beanName");
      setReferenceMethodName = usedBeanElement.getAttribute("setReferenceMethod");
      Class usedBeanClass;
      if (tipoBean.equals("applicationBeans")) {
        //cerco il bean usato solo fra gli AB
        index = search(abn, usedBeanName);
        if (index == -1) {
          Logger.print("BeanDescriptorCreator: ERRORE inizializzando i riferimenti");
          return false; }
        usedBeanClass = abc[index];
        beanDescriptor.usedBeanIndex[k]     = index;
        beanDescriptor.usedBeanIndexType[k] = 'a';
      } else {
        //cerco il bean usato prima fra i SB e poi fra gli AB
        index = search(sbn, usedBeanName);
        if (index == -1) {
          index = search(abn, usedBeanName);
          if (index == -1) {
            Logger.print("BeanDescriptorCreator: ERRORE inizializzando i riferimenti");
            return false; }
          usedBeanClass = abc[index];
          beanDescriptor.usedBeanIndexType[k] = 'a';
        } else {
          usedBeanClass = sbc[index];
          beanDescriptor.usedBeanIndexType[k] = 's';
        }
        beanDescriptor.usedBeanIndex[k] = index;
      }
      Method method = Reflect.getMethodRecursive(usingBeanClass, setReferenceMethodName, usedBeanClass);
      if (method == null) {
        Logger.print("BeanDescriptorCreator: ERRORE inizializzando i riferimenti - metodo non trovato");
        return false; }
      beanDescriptor.setReferenceMethods[k] = method;
    }//for
  return true;
  }

  /**
   * Ricerca una stringa all'interno di un array di stringhe e restituisce la
   * prima posizione in cui è presente la stringa cercata.
   * @param array l'array di stringhe
   * @param key la stringa da ricercare
   * @return la posizione della stringa nell'array, a partire da 0. -1 se non è presente
   */
  private static int search(String[] array, String key) {
    int index = 0;
    while (index<array.length)
      if (array[index].equals(key)) return index;
      else index++;
    return -1;
  }

}