/*
    * Copyright 2007 Hippo
    *
    * Licensed under the Apache License, Version 2.0 (the  "License"); 
    * you may not use this file except in compliance with the License. 
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" 
   * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
   * See the License for the specific language governing permissions and 
   * limitations under the License.
   */
  package nl.hippo.client.webdav.utils;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import javax.xml.transform.ErrorListener;
  import javax.xml.transform.Result;
  import javax.xml.transform.Source;
  import javax.xml.transform.Templates;
  import javax.xml.transform.Transformer;
  import javax.xml.transform.TransformerConfigurationException;
  import javax.xml.transform.TransformerException;
  import javax.xml.transform.TransformerFactory;
  import javax.xml.transform.stream.StreamSource;
  
  import nl.hippo.client.api.ClientException;
  import nl.hippo.client.webdav.WebdavResponse;
  
  /**
   * Wraps an xslt transformer
   */
  public class XslTransformer {
  
      private static TransformerFactory transformerFactory = TransformerFactory.newInstance();
      private static ErrorMultiplexer errorMultiplexer = new ErrorMultiplexer();
      static {
          transformerFactory.setErrorListener(errorMultiplexer);
      }
  
      private XslTransformer() {
          //This class contains only static methods and should not be instantiated
      }
  
      /**
       * A map of precompiled xslt templates
       */
      private static Map templates = Collections.synchronizedMap(new HashMap());
  
      /**
       * Perform an xslt transformation
       * 
       * @param xslt IntputStream on a UTF-8 encoded valid xslt document
       * @param source XML source
       * @param result XML result
       * @return A list of errors 
       * 
       * @throws ClientException If something went wrong.
       */
      public static List transform(WebdavResponse xslt, Source source, Result result) throws ClientException {
          try {
              
              //Precompile the xsl to a Templates object collecting all errors/warnings.
              Templates template;
              ErrorHandler handler = new ErrorHandler();
              errorMultiplexer.addListener(handler);
              if (templates.containsKey(xslt)) {
                  template = (Templates) templates.get(xslt);
              } else {
                  template = transformerFactory.newTemplates(new StreamSource(xslt.getResponseAsStream()));
                  templates.put(xslt, template);
              }
              
              Transformer transformer = template.newTransformer();            
              transformer.transform(source, result);
              errorMultiplexer.removeListener(handler);
              return handler.errors();
          } catch (TransformerConfigurationException e) {
              throw new ClientException("transformation failed", e);
          } catch (TransformerException e) {
              throw new ClientException("transformation failed", e);
          }
      }
  
      /**
       * Perform an identity xslt transformation
       * @param source XML source
       * @param result XML result
       * @throws ClientException If something went wrong
       */
      public static void identityTransform(Source source, Result result) throws ClientException {
         try {
             Transformer identityTransformer = transformerFactory.newTransformer();
             identityTransformer.transform(source, result);
         } catch (TransformerConfigurationException e) {
             throw new ClientException("Transformation failed.", e);
         } catch (TransformerException e) {
             throw new ClientException("Transformation failed.", e);
         }
     }
 }
 
 class ErrorHandler implements ErrorListener {
     List errors = new ArrayList();
 
     public void error(TransformerException exception) throws TransformerException {
         errors.add("TransformerException, error: " + exception.toString());
     }
 
     public void fatalError(TransformerException exception) throws TransformerException {
         errors.add("TransformerException, fatal error: " + exception.toString());
     }
 
     public void warning(TransformerException exception) throws TransformerException {
         errors.add("TransformerException, warning: " + exception.toString());
     }
     
     public List errors() {
         return errors;
     }
 };
 
 class ErrorMultiplexer implements ErrorListener {
     
     private List listeners = Collections.synchronizedList(new ArrayList());
 
     void addListener(ErrorListener listener) {
         listeners.add(listener);
     }
 
     void removeListener(ErrorListener listener) {
         listeners.remove(listener);
     }
 
     public void error(TransformerException exception) throws TransformerException {
         Iterator it = listeners.iterator();
         while (it.hasNext()) {
             ErrorListener listener = (ErrorListener) it.next();
             listener.error(exception);
         }
     }
 
     public void fatalError(TransformerException exception) throws TransformerException {
         Iterator it = listeners.iterator();
         while (it.hasNext()) {
             ErrorListener listener = (ErrorListener) it.next();
             listener.error(exception);
         }
     }
 
     public void warning(TransformerException exception) throws TransformerException {
         Iterator it = listeners.iterator();
         while (it.hasNext()) {
             ErrorListener listener = (ErrorListener) it.next();
             listener.error(exception);
         }
     }
 }