package framepack.boundarypack;

import framepack.*;
import framepack.configurationpack.*;
import java.io.*;
import java.lang.reflect.*;
import javax.servlet.http.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;
import org.w3c.dom.*;
import toolspack.*;

/**
 * Classe deputata alla costruzione dell'interfaccia da presentare all'utente
 * @author Stefano Ricciarelli
 * @version 1.2.1 - Date: 29-06-2002
 */

public class Viewer {

  private Configurator config;
  private XmlTools xmlTools;
  private RequestResolverXML requestResolverXML;

  public Viewer() {
    config = Configurator.getInstance();
    xmlTools = XmlTools.getInstance();
    requestResolverXML = RequestResolverXML.getInstance();
  }

  /**
   * Unico metodo pubblico. Provvede a eseguire le operazioni di visualizzazione
   * legate alla richiesta request e a produrre l'output sulla risposta response
   * @param request la richiesta alla servlet
   * @param response la risposta della servlet
   * @return true se tutto è andato a buon fine, false altrimenti
   */
  public boolean execute(HttpServletRequest request, HttpServletResponse response) {
    HttpSession session      = request.getSession();
    Document requestXML      = (Document)session.getAttribute("requestXML");
    Document _beansToViewXML = requestResolverXML.getBeansToViewXML(requestXML);
    if (_beansToViewXML==null) return false;
    Logger.DOMtoXMLfile(_beansToViewXML, "_beansToView.xml");
    //cerco in _beansToViewXML la pagina statica da restituire o l'xslRenderer
    String type = _beansToViewXML.getDocumentElement().getAttribute("type");
    if (type==null) type="";
    if (type.equals("html"))
      //restituisco una pagina statica
      return returnStaticPage(_beansToViewXML.getDocumentElement(), response);
    if (type.equals("xsl")) {
      //reperisco lo stato da renderizzare
      Document beansStateXML = getBeansStateXML(_beansToViewXML
      , (ObjectSet)session.getAttribute("sessionBeans")
      , config.getApplicationBeanInstances());
      if (beansStateXML==null) return false;
      Logger.DOMtoXMLfile(beansStateXML, "_beansState.xml");
      //renderizzo lo stato con un file xsl
      return returnDynamicPage(beansStateXML, _beansToViewXML.getDocumentElement(), response);
    }
    Logger.print(this, "Errore in _beansToView.xml. Type = " + type);
    return false;
  }

  /**
   * Provvede a stampare sulla risposta response il file html di risposta indicato nell'
   * elemento beansToViewRoot
   * @param beansToViewRoot l'elemento DOM contenente il riferimento al file html
   * @param response la risposta della servlet alla richiesta
   * @return true se tutto è andato a buon fine, false altrimenti
   */
  private boolean returnStaticPage(Element beansToViewRoot, HttpServletResponse response) {
    try{
      NodeList nodes = beansToViewRoot.getElementsByTagName("htmlPage");
      String outputHTMLFileName = config.getOutputPagesPath()
        + ((Element)nodes.item(0)).getAttribute("fileName");
      PrintWriter printWriter = response.getWriter();
      response.setContentType("text/html");
      FileReader fileReader = new FileReader(outputHTMLFileName);
      BufferedReader bufferedReader = new BufferedReader(fileReader);
      String s;
      while ( (s=bufferedReader.readLine()) !=null )
        printWriter.println(s);
    } catch (Exception ex){
      Logger.print(this, "ERRORE in _beansToViewXML o scrivendo l'html di output");
      return false;
    }
    return true;
  }

  /**
   * Costruisce il documento _beansStateXML richiamando il metodo getXMLRepresentation()
   * dei sessionBeans e/o applicationBeans indicati nel documento _beansToViewXML
   * @param _beansToViewXML il documento xml indicante i bean da visualizzare, cioè i
   * bean a cui chiedere lo stato invocando il metodo
   * @param sessionBeans l'insieme dei sessionBeans getXMLRepresentation()
   * @param applicationBeans L'insieme degli applicationBeans
   * @return il documento _beansStateXML ottenuto impilando i documenti xml dello stato
   * di ciascun bean interrogato sotto un tag corrispondente al nome del bean
   */
  private Document getBeansStateXML(Document _beansToViewXML
  , ObjectSet sessionBeans, ObjectSet applicationBeans) {
    Document beansStateXML = xmlTools.newDocument();
    Element beansStateXMLRoot = beansStateXML.createElement("beansStateXMLRoot");
    beansStateXML.appendChild(beansStateXMLRoot);
    NodeList beans = _beansToViewXML.getElementsByTagName("showBean");
    Object bean;
    int i;
    for (i=0; i<beans.getLength(); i++) {
      String beanName = ((Element)beans.item(i)).getAttribute("name");
      Logger.print(this, "getBeansStateXML: cerco il bean " + beanName + " di " + beans.getLength());
      bean = null;
      bean = sessionBeans.getValue(beanName);
      if (bean==null) { //cerco allora fra gli applicationBean
        bean = applicationBeans.getValue(beanName);
        if (bean==null) {Logger.print(this, "ERRORE in getBeansStateXML"); return null;}
      }
      Document singleBeanStateXML;
      try{
        Class  classe = bean.getClass();
        Method metodo = classe.getMethod("getXMLRepresentation", new Class[]{} );
        singleBeanStateXML = (Document)metodo.invoke(bean, null);
      } catch (Exception ex) {
        Logger.print(this, "ERRORE in getBeansStateXML: impossibile trovare il metodo getXMLRepresentation per il bean " + bean);
        return null;
      }
      //creo un nodo col nome del bean. Necessario! non può bastare la radice che
      //inserisce il bean stesso perché non è in grado di distinguere nel caso in cui
      //abbia due istanze diverse di una stessa classe!
      Element beanRoot = beansStateXML.createElement(beanName);
      beansStateXMLRoot.appendChild(beanRoot);
      beanRoot.appendChild(beansStateXML.importNode(
        singleBeanStateXML.getDocumentElement(), true ));
    }//for i
    return beansStateXML;
  }

  /**
   * Provvede a scrivere sulla risposta response il risultato della trasformazione
   * di beansStateXML secondo le indicazioni contenute in beansToViewRoot. Tali indicazioni
   * concernono il file XSl con cui trasformare beansStateXML e/o il file XSL da collegare
   * al precedente documento XML come processing instruction per effettuare una
   * trasformazione XSL lato client
   * @param beansStateXML lo stato da renderizzare
   * @param beansToViewRoot l'elemento DOM contente le inidacazioni sul rendering da
   * effettuare
   * @param response la risposta della servlet alla richiesta
   * @return true se tutto è andato a buon fine, false altrimenti
   */
  private boolean returnDynamicPage(Document beansStateXML, Element beansToViewRoot,
  HttpServletResponse response) {
    NodeList nodes1 = beansToViewRoot.getElementsByTagName("serverSideXslRenderer");
    NodeList nodes2 = beansToViewRoot.getElementsByTagName("clientSideXslRenderer");
    if (  nodes1.getLength()> 1 || nodes2.getLength()> 1 ||
         (nodes1.getLength()==0 && nodes2.getLength()==0)   ) {
      Logger.print(this, "ERRORE in _beansToViewXML");
      return false;
    }
    Document outXML;
    if (nodes1.getLength()==1) { //esiste il serverSideXslRenderer
      String serverSideXslRendererFileName = config.getOutputPagesPath()
        + ((Element)nodes1.item(0)).getAttribute("fileName");
      Logger.print(this, "serverSideXslRendererFileName: " + serverSideXslRendererFileName);
      //Eseguo la trasformazione xsl del contenuto xml
      outXML = serverSideTransform(beansStateXML, serverSideXslRendererFileName);
      Logger.DOMtoXMLfile(outXML, "_pre-out.xml");
      if (outXML == null) return false;
    } else outXML = beansStateXML; //non esiste il serverSideXslRenderer
    if (nodes2.getLength()==1) { //esiste il clientSideXslRenderer
      //String clientSideXslRendererFileName = config.getOutputPagesPath()
      //  + ((Element)nodes2.item(0)).getAttribute("fileName");
//NB: il clientSideXslRendererURL è un percorso URL completo mentre il
//serverSideXslRendererFileName è un nome di file a partire dal percorso config.getOutputPagesPath()
      String clientSideXslRendererURL = ((Element)nodes2.item(0)).getAttribute("URL");
      Logger.print(this, "clientSideXslRendererFileName: " + clientSideXslRendererURL);
      outXML.insertBefore(outXML.createProcessingInstruction("xml-stylesheet",
        "type=\"text/xsl\" href=\"" + clientSideXslRendererURL + "\""),
        outXML.getDocumentElement() );
    }
    //Invio outXML come risposta
    Logger.DOMtoXMLfile(outXML, "_out.xml");
    try{
      //Logger.getPartial();
      PrintWriter printWriter = response.getWriter();
      response.setContentType("text/html");
      DOMSource domSource       = new DOMSource(outXML);
      StreamResult streamResult = new StreamResult(printWriter);
      Transformer transformer   = xmlTools.getCopier();
      transformer.transform(domSource, streamResult);
      //Logger.print(this, "tempo rendering output page = " + Logger.getPartial());
    }
    catch (Exception ex) {Logger.print(this, "Errore nella trasformazione" + ex); return false; }
    return true;
  }

  /**
   * Effettua la trasformazione del documento beansStateXML con il documento XSL del file
   * renderXSLfileName
   * @param beansStateXML il documento xml da trasformare
   * @param renderXSLfileName il nome del file XSL da utilizzare per la trasformazione
   * (nome assoluto di file, compreso percorso)
   * @return il documento xml trasformato
   */
  private Document serverSideTransform(Document beansStateXML, String renderXSLfileName){
    Transformer renderXSLTransformer = xmlTools.createTransformer(renderXSLfileName);
    DOMSource xmlSource = new DOMSource(beansStateXML);
    DOMResult xhtmlResult = new DOMResult(xmlTools.newDocument());
    try {renderXSLTransformer.transform(xmlSource, xhtmlResult);}
    catch (Exception ex) {Logger.print(this, "Errore nella trasformazione serverside" + ex); return null; }
    return (Document)xhtmlResult.getNode();
  }


} //FINE CLASSE