package toolspack;

import framepack.configurationpack.*;
import java.io.File;
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.stream.*;
import org.w3c.dom.*;

/**
 * Classe che fornisce metodi utili per la manipolazione di documenti DOM - XML e
 * trasformazioni XSL.
 * Si tratta di una classe singleton, ossia della quale è presente una sola istanza.
 * E' una soluzione simile ad una classe con soli metodi statici, tuttavia in questo
 * modo si è sicuri che venga chiamato il costruttore della classe prima che venga invocato
 * un qualunque metodo. Inoltre si dispone di un riferimento ad un oggetto che come
 * tale può essere passato ad altri oggetti.
 * NB: La classe è utilizzata unicamente dai Viewer, dai Controller e dalla MainServlet,
 * non dal Configurator perché altrimenti avrei un ciclo nell'inizializzazione.
 * NB2: I metodi sono tutti synchronized dal momento che questa classe può essere invocata
 * contemporaneamente da più oggetti controller e/o da più oggetti viewer. Si ricorda che
 * l'implemantazione dei metodi relativi al trattamento di DOM-XML non garantisce correttezza
 * in presenza di richieste concorrenti
 * @author Stefano Ricciarelli
 * @version 1.2 - Date: 28-06-2002
 */


public class XmlTools {

  private static XmlTools instance = new XmlTools();
  private DocumentBuilderFactory dbFactory = null;
  private DocumentBuilder documentBuilder= null;
  private TransformerFactory tFactory = null;
  private Configurator config;

  /**
   * Il costruttore è privato poiché si tratta di una classe singleton
   */
  private XmlTools() {
    dbFactory = DocumentBuilderFactory.newInstance();
    tFactory = TransformerFactory.newInstance();
    try { documentBuilder = dbFactory.newDocumentBuilder();
    } catch (Exception ex) {Logger.print(this, "ERRORE creando DocumentBuilder nel costruttore" + ex); }
    config = Configurator.getInstance();
  }

  /**
   * Metodo statico da invocare per ottenere il riferimeto all'unico oggetto esistente
   * di questa classe
   * @return il riferimento all'unico oggetto di questa classe
   */
  public static XmlTools getInstance() {
    return instance;
  }

  /**
   * Crea un nuovo documento XML
   * @return il nuovo documento
   */
  public synchronized Document newDocument() {
    Document doc = documentBuilder.newDocument();
    if (doc == null) Logger.print(this, "ERRORE creando Document");
    return doc;
  }

  /**
   * Crea un trasformatore a partire da un file XLS. Si ricordi che il trasformatore
   * non può essere utilizzato in concorrenza, in caso richiedere un'altro trasformatore.
   * @param fileName il nome del file, compreso percorso
   * @return il trasformatore
   */
  public synchronized Transformer createTransformer(String fileName) {
    try {
    File file = new File(fileName);
    Logger.print(this, "File trovato! - " + fileName);
    return tFactory.newTransformer(new StreamSource(file));
    } catch (Exception ex) {
      Logger.print(this, "ERRORE creando il Transformer:" + ex);
      return null;
    }
  }

  /**
   * Crea un nuovo trasformatore che effettua una semplice copia. Si ricordi che
   * il trasformatore non può essere utilizzato in concorrenza, in caso richiedere
   * un'altro trasformatore.
   * @return il trasformatore
   */
  public synchronized Transformer getCopier() {
    try { return tFactory.newTransformer(); }
    catch (Exception ex) {
      Logger.print(this, "ERRORE tentando di restituire un copiatore");
      return null; }
  }

} // FINE CLASSE


/*  public synchronized DocumentBuilder newDocumentBuilder() {
    try {
      DocumentBuilder docBuilder = dbFactory.newDocumentBuilder();
      if (docBuilder == null) Logger.print(this, "ERRORE creando DocumentBuilder");
      return docBuilder;
    } catch (Exception ex) {
      Logger.print(this, "ERRORE creando DocumentBuilder" + ex);
      return null;
    }
   }*/

/**
   * Dati due documenti xml corretti li fonde in un documento unico di radice rootName avente
   * doc1 e doc2 come nodi figli
   * @param doc1
   * @param doc2
   * @param rootName
   * @return
   */
/*  private Document mergeDocument(Document doc1, Document doc2, String rootName) {
    try {
      Document doc = xmlTools.newDocument();
      Element docRoot = doc.createElement(rootName);
      doc.appendChild(docRoot);
      Element doc1Root = (Element)doc.importNode(doc1.getDocumentElement(), true);
      Element doc2Root = (Element)doc.importNode(doc2.getDocumentElement(), true);
      docRoot.appendChild(doc1Root);
      docRoot.appendChild(doc2Root);
      return doc;
    }
    catch (Exception ex) {
      Tester.print(this, "errore nella fusione " + ex);
      return null;
    }
  }*/