/*
    * Copyright (c) 2002-2022, City of Paris
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions
    * are met:
    *
    *  1. Redistributions of source code must retain the above copyright notice
   *     and the following disclaimer.
   *
   *  2. Redistributions in binary form must reproduce the above copyright notice
   *     and the following disclaimer in the documentation and/or other materials
   *     provided with the distribution.
   *
   *  3. Neither the name of 'Mairie de Paris' nor 'Lutece' nor the names of its
   *     contributors may be used to endorse or promote products derived from
   *     this software without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   *
   * License 1.0
   */
  package fr.paris.lutece.util.xml;
  
  import fr.paris.lutece.portal.service.util.AppLogService;
  import fr.paris.lutece.portal.service.util.AppPropertiesService;
  
  import java.io.StringWriter;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Properties;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.ConcurrentMap;
  
  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.TransformerFactoryConfigurationError;
  import javax.xml.transform.stream.StreamResult;
  
  /**
   * This class provides methods to transform XML documents using XSLT with cache
   */
  public final class XmlTransformer
  {
      private static final String ERROR_MESSAGE_XLST = "Error transforming document XSLT : ";
      public static final String PROPERTY_TRANSFORMER_POOL_SIZE = "service.xmlTransformer.transformerPoolSize";
      public static final int TRANSFORMER_POOL_SIZE = AppPropertiesService.getPropertyInt( PROPERTY_TRANSFORMER_POOL_SIZE, 2 );
      public static final int MAX_TRANSFORMER_SIZE = 1000;
      private static final List<ConcurrentMap<String, Templates>> transformersPoolList = new ArrayList<>( TRANSFORMER_POOL_SIZE );
  
      static
      {
          for ( int i = 0; i < TRANSFORMER_POOL_SIZE; i++ )
          {
              transformersPoolList.add( new ConcurrentHashMap<String, Templates>( MAX_TRANSFORMER_SIZE ) );
          }
      }
  
      /**
       * This method try to get a templates instance from cache or create a new one if can't.
       *
       * Previously (before 6.0.0) it returned directly a transformer, now it returns a templates which can create transformers cheaply.
       * 
       * @param stylesheet
       *            The XML document content
       * @param strStyleSheetId
       *            The StyleSheet Id
       * @return XmlTransformer object
       * @throws TransformerException
       */
      private Templates getTemplates( Source stylesheet, String strStyleSheetId ) throws TransformerException
      {
          Templates result = null;
  
          if ( TRANSFORMER_POOL_SIZE > 0 )
          {
              int nTransformerListIndex = 0;
  
              do
              {
                 result = transformersPoolList.get( nTransformerListIndex ).remove( strStyleSheetId );
                 nTransformerListIndex++;
             }
             while ( ( result == null ) && ( nTransformerListIndex < TRANSFORMER_POOL_SIZE ) );
         }
 
         if ( result == null )
         {
             // only one thread can use transformer
             try
             {
                 result = TransformerFactory.newInstance( ).newTemplates( stylesheet );
                 AppLogService.debug( " --  XML Templates instantiation : strStyleSheetId= {}", strStyleSheetId );
             }
             catch( TransformerConfigurationException e )
             {
                 String strMessage = e.getMessage( );
 
                 if ( e.getLocationAsString( ) != null )
                 {
                     strMessage += ( "- location : " + e.getLocationAsString( ) );
                 }
 
                 throw new TransformerException( ERROR_MESSAGE_XLST + strMessage, e.getCause( ) );
             }
             catch( TransformerFactoryConfigurationError e )
             {
                 throw new TransformerException( ERROR_MESSAGE_XLST + e.getMessage( ), e );
             }
         }
 
         return result;
     }
 
     /**
      * Remove all Templates instance from cache. Previously (before 6.0.0) the cache stored transformers, now it stores templates.
      */
     public static void cleanTransformerList( )
     {
         for ( ConcurrentMap<String, Templates> transformerList : transformersPoolList )
         {
             transformerList.clear( );
         }
     }
 
     /**
      * Gets the number of templates. Previously (before 6.0.0) the cache stored transformers, now it stores templates.
      * 
      * @return the transformers count
      */
     public static int getTransformersCount( )
     {
         int nCount = 0;
 
         for ( ConcurrentMap<String, Templates> transformerList : transformersPoolList )
         {
             nCount += transformerList.size( );
         }
 
         return nCount;
     }
 
     /**
      * Release Transformer instance in cache. Previously (before 6.0.0) the cache stored transformers, now it stores templates.
      * 
      * @param templates
      *            The XML templates
      * @param strStyleSheetId
      *            The StyleSheet Id
      */
     private void releaseTemplates( Templates templates, String strStyleSheetId )
     {
         if ( TRANSFORMER_POOL_SIZE > 0 )
         {
             Templates result = null;
             ConcurrentMap<String, Templates> transformerList = null;
             int nTransformerListIndex = 0;
 
             do
             {
                 transformerList = transformersPoolList.get( nTransformerListIndex );
                 nTransformerListIndex++;
 
                 // This set of action is not performed atomically but it can not cause problems
                 if ( transformerList.size( ) < MAX_TRANSFORMER_SIZE )
                 {
                     result = transformerList.putIfAbsent( strStyleSheetId, templates );
                 }
                 else
                 {
                     // Aggressive release ( speed up GC )
                     transformerList.clear( );
 
                     AppLogService.info( "XmlTransformer : cache is full, you may need to increase cache size." );
                 }
             }
             while ( ( result != null ) && ( nTransformerListIndex < TRANSFORMER_POOL_SIZE ) );
         }
     }
 
     /**
      * Transform XML documents using XSLT with cache
      * 
      * @param source
      *            The XML document content
      * @param stylesheet
      *            The XSL source
      * @param strStyleSheetId
      *            The StyleSheet Id
      * @param params
      *            Parameters that can be used by the XSL StyleSheet
      * @param outputProperties
      *            Properties to use for the XSL transform. Will overload the XSL output definition.
      * @return The output document
      * @throws TransformerException
      *             The exception
      */
     public String transform( Source source, Source stylesheet, String strStyleSheetId, Map<String, String> params, Properties outputProperties )
             throws TransformerException
     {
         Templates templates = this.getTemplates( stylesheet, strStyleSheetId );
         Transformer transformer = templates.newTransformer( );
 
         if ( outputProperties != null )
         {
             transformer.setOutputProperties( outputProperties );
         }
 
         if ( params != null )
         {
             transformer.clearParameters( );
 
             for ( Entry<String, String> entry : params.entrySet( ) )
             {
                 transformer.setParameter( entry.getKey( ), entry.getValue( ) );
             }
         }
 
         StringWriter sw = new StringWriter( );
         Result result = new StreamResult( sw );
 
         try
         {
             transformer.transform( source, result );
         }
         catch( TransformerException e )
         {
             String strMessage = "strStyleSheetId = " + strStyleSheetId + " " + e.getMessage( );
 
             if ( e.getLocationAsString( ) != null )
             {
                 strMessage += ( " - location : " + e.getLocationAsString( ) );
             }
 
             throw new TransformerException( ERROR_MESSAGE_XLST + strMessage, e.getCause( ) );
         }
         finally
         {
             this.releaseTemplates( templates, strStyleSheetId );
         }
 
         return sw.toString( );
     }
 }