package org.apache.fulcrum.parser;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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.
   */
  
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.List;
  
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.Part;
  
  import org.apache.avalon.framework.configuration.Configurable;
  import org.apache.avalon.framework.configuration.Configuration;
  import org.apache.avalon.framework.configuration.ConfigurationException;
  import org.apache.avalon.framework.logger.AbstractLogEnabled;
  import org.apache.avalon.framework.logger.LogEnabled;
  import org.apache.avalon.framework.service.ServiceException;
  import org.apache.avalon.framework.service.ServiceManager;
  import org.apache.avalon.framework.service.Serviceable;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
  import org.apache.fulcrum.parser.ValueParser.URLCaseFolding;
  import org.apache.fulcrum.parser.pool.BaseValueParserFactory;
  import org.apache.fulcrum.parser.pool.BaseValueParserPool;
  import org.apache.fulcrum.parser.pool.CookieParserFactory;
  import org.apache.fulcrum.parser.pool.CookieParserPool;
  import org.apache.fulcrum.parser.pool.DefaultParameterParserFactory;
  import org.apache.fulcrum.parser.pool.DefaultParameterParserPool;
  import org.apache.fulcrum.pool.PoolException;
  import org.apache.fulcrum.pool.PoolService;
  
  
  /**
   * The DefaultParserService provides the default implementation
   * of a {@link ParserService}.
   *
   * @author <a href="mailto:tv@apache.org">Thomas Vandahl</a>
   * @version $Id: BaseValueParser.java 542062 2007-05-28 00:29:43Z seade $
   */
  public class DefaultParserService
      extends AbstractLogEnabled
      implements ParserService,
                 Configurable, Serviceable
  {
  
      /** The folding from the configuration */
      private URLCaseFolding folding = URLCaseFolding.NONE;
  
      /** The automaticUpload setting from the configuration */
      private boolean automaticUpload = AUTOMATIC_DEFAULT;
  
      /**
       * The parameter encoding to use when parsing parameter strings
       */
      private String parameterEncoding = PARAMETER_ENCODING_DEFAULT;
      
      /**
       * reintroduced fulcrum, may be used in the case, that 
       * commons pool2 is not configured exactly as needed properly as fast fall back.
       */
      private boolean useFulcrumPool = FULCRUM_POOL_DEFAULT;
      
      
      /**
       * The Fulcrum pool service component to use (optional), by default it is deactivated and commons pool is used.
       */
      private PoolService fulcrumPoolService = null;
  
      /** 
       * Use commons pool to manage value parsers 
       */
      private BaseValueParserPool valueParserPool;
  
      /** 
       * Use commons pool to manage parameter parsers 
       */
      private DefaultParameterParserPool parameterParserPool;
  
      /** 
       * Use commons pool to manage cookie parsers 
       */
     private CookieParserPool cookieParserPool;
 
 
     public DefaultParserService() 
     {
     }
     
     public DefaultParserService(GenericObjectPoolConfig<?> config) 
     {
 	    // init the pool
 	    valueParserPool 
     		= new BaseValueParserPool(new BaseValueParserFactory(), config);
 
 	    parameterParserPool 
 	    	= new DefaultParameterParserPool(new DefaultParameterParserFactory(), config);
     }
 
     
     /**
      * Get the character encoding that will be used by this ValueParser.
      */
     @Override
     public String getParameterEncoding()
     {
         return parameterEncoding;
     }
     
     /**
      * Set the character encoding that will be used by this ValueParser.
      */
     public void setParameterEncoding(String encoding)
     {
         parameterEncoding = encoding;
     }
 
     /**
      * Trims the string data and applies the conversion specified in
      * the property given by URL_CASE_FOLDING.  It returns a new
      * string so that it does not destroy the value data.
      *
      * @param value A String to be processed.
      * @return A new String converted to the case as specified by URL_CASE_FOLDING and trimmed.
      */
     @Override
     public String convert(String value)
     {
         return convertAndTrim(value);
     }
 
     /**
      * Convert a String value according to the url-case-folding property.
      *
      * @param value the String to convert
      *
      * @return a new String.
      *
      */
     @Override
     public String convertAndTrim(String value)
     {
         return convertAndTrim(value, getUrlFolding());
     }
 
     /**
      * A static version of the convert method, which
      * trims the string data and applies the conversion specified in
      * the property given by URL_CASE_FOLDING.  It returns a new
      * string so that it does not destroy the value data.
      *
      * @param value A String to be processed.
      * @return A new String converted to lowercase and trimmed.
      */
     @Override
     public String convertAndTrim(String value, URLCaseFolding fold)
     {
         if (value == null)
         {
             return "";
         }
 
         String tmp = value.trim();
 
         switch (fold)
         {
             case NONE:
             {
                 break;
             }
 
             case LOWER:
             {
                 tmp = tmp.toLowerCase();
                 break;
             }
 
             case UPPER:
             {
                 tmp = tmp.toUpperCase();
                 break;
             }
 
             default:
             {
                 getLogger().error("Passed " + fold + " as fold rule, which is illegal!");
                 break;
             }
         }
         return tmp;
     }
 
     /**
      * Gets the folding value from the configuration
      *
      * @return The current Folding Value
      */
     @Override
     public URLCaseFolding getUrlFolding()
     {
         return folding;
     }
 
     /**
      * Gets the automaticUpload value from the configuration
      *
      * @return The current automaticUpload Value
      */
     @Override
     public boolean getAutomaticUpload()
     {
         return automaticUpload;
     }
 
     /**
      * Parse the given request for uploaded files
      *
      * @return A list of {@link javax.servlet.http.Part}s
      *
      * @throws ServiceException if parsing fails
      */
     @Override
     public List<Part> parseUpload(HttpServletRequest request) throws ServiceException
     {
         try
         {
             return new ArrayList<Part>(request.getParts());
         }
         catch (IOException | ServletException e)
         {
             throw new ServiceException(ParserService.ROLE, "Could not parse upload request", e);
         }
     }
 
     /**
      * Get a {@link ValueParser} instance from the service. Use the
      * given Class to create the object.
      *
      * @return An object that implements ValueParser
      *
      * @throws InstantiationException if the instance could not be created
      */
     @SuppressWarnings("unchecked")
 	@Override
     public <P extends ValueParser> P getParser(Class<P> ppClass) throws InstantiationException
     {
         P vp = null;
 
         try
         {
             if (useFulcrumPool) {
                 try
                 {
                     P parserInstance = (P) fulcrumPoolService.getInstance(ppClass);
                     vp = parserInstance;
                 }
                 catch (PoolException pe)
                 {
                     throw new InstantiationException("Parser class '" + ppClass + "' is illegal. " + pe.getMessage());
                 }
             } else if ( ppClass.equals(BaseValueParser.class) )
             {
             	BaseValueParser parserInstance = null;
 				try {
 				    parserInstance = valueParserPool.borrowObject();
 					vp = (P) parserInstance;
 					if (vp == null) {
                         throw new InstantiationException("Could not borrow object from pool: " + valueParserPool);
                     }
 				} catch (Exception e) {
                     try {
                         valueParserPool.invalidateObject(parserInstance);
                         parserInstance = null;
                     } catch (Exception e1) {
                         throw new InstantiationException("Could not invalidate object " + e1.getMessage() + " after exception: " + e.getMessage());
                     }
 				}
             } else if ( ppClass.equals(DefaultParameterParser.class) )
             {
                 DefaultParameterParser parserInstance = null;
                 try {
                     parserInstance = parameterParserPool.borrowObject();
                 	vp = (P) parserInstance;
                 	if (vp == null) {
                         throw new InstantiationException("Could not borrow object from pool: " + parameterParserPool);
                     }
                 } catch (Exception e) {
                     try {
                         parameterParserPool.invalidateObject(parserInstance);
                         parserInstance = null;
                     } catch (Exception e1) {
                         throw new InstantiationException("Could not invalidate object " + e1.getMessage() + " after exception: " + e.getMessage());
                     }
                 }
             } else if ( ppClass.equals(DefaultCookieParser.class) )
             {
                 DefaultCookieParser parserInstance = null;
                 try {
                     parserInstance = cookieParserPool.borrowObject();
                 	vp = (P) parserInstance;
                     if (vp == null) {
                           throw new InstantiationException("Could not borrow object from pool: " + cookieParserPool);
                     }
                 } catch (Exception e) {
                     try {
                         cookieParserPool.invalidateObject(parserInstance);
                         parserInstance = null;
                     } catch (Exception e1) {
                         throw new InstantiationException("Could not invalidate object " + e1.getMessage() + " after exception: " + e.getMessage());
                     }
                 }
             }
             
             if (vp != null && vp instanceof ParserServiceSupport ) {
                 ((ParserServiceSupport)vp).setParserService(this);
             } else {
                 throw new InstantiationException("Could not set parser");
             }
             if (vp instanceof LogEnabled) 
             {
                 ((LogEnabled)vp).enableLogging(getLogger().getChildLogger(ppClass.getSimpleName()));
             }
         }
         catch (ClassCastException x)
         {
             throw new InstantiationException("Parser class '" + ppClass + "' is illegal. " + x.getMessage());
         }
 
         return vp;
     }
 
     /**
      * Clears the parse and puts it back into
      * the pool service. This allows for pooling 
      * and recycling
      * 
      * As we are not yet using org.apache.fulcrum.pool.Recyclable, we call insteda {@link ValueParser#dispose()}.
      *
      * @param parser The value parser to use
      */
     @Override
     public void putParser(ValueParser parser)
     {
         parser.clear();
         parser.dispose(); 
     
         if (useFulcrumPool) {
             
             fulcrumPoolService.putInstance(parser);
             
         } else if( parser.getClass().equals(BaseValueParser.class) )
         {
             valueParserPool.returnObject( (BaseValueParser) parser );
         
         } else if ( parser.getClass().equals(DefaultParameterParser.class) ||
                 parser instanceof DefaultParameterParser)
         {
             parameterParserPool.returnObject( (DefaultParameterParser) parser );
         	
         } else if ( parser.getClass().equals(DefaultCookieParser.class) ||
                 parser instanceof DefaultCookieParser)
         {
             cookieParserPool.returnObject( (DefaultCookieParser) parser );
         	
         } else {
             // log
             getLogger().warn(parser.getClass() + " could not be put back into any pool exhausting some pool");
             // log even borrowed count of each pool?: cookieParserPool.getBorrowedCount())
             }
     }
 
     /**
      * Avalon component lifecycle method
      * 
      * @param conf the configuration
      * @throws ConfigurationException Generic exception
      */
     @Override
     public void configure(Configuration conf) throws ConfigurationException
     {
         String foldString = conf.getChild(URL_CASE_FOLDING_KEY).getValue(URLCaseFolding.NONE.name()).toLowerCase();
 
         folding = URLCaseFolding.NONE;
 
         getLogger().debug("Setting folding from " + foldString);
 
         if (StringUtils.isNotEmpty(foldString))
         {
             try
             {
                 folding = URLCaseFolding.valueOf(foldString.toUpperCase());
             }
             catch (IllegalArgumentException e)
             {
                 getLogger().error("Got " + foldString + " from " + URL_CASE_FOLDING_KEY + " property, which is illegal!");
                 throw new ConfigurationException("Value " + foldString + " is illegal!", e);
             }
         }
 
         parameterEncoding = conf.getChild(PARAMETER_ENCODING_KEY)
                             .getValue(PARAMETER_ENCODING_DEFAULT).toLowerCase();
 
         automaticUpload = conf.getChild(AUTOMATIC_KEY).getValueAsBoolean(AUTOMATIC_DEFAULT);
         
         useFulcrumPool = conf.getChild(FULCRUM_POOL_KEY).getValueAsBoolean(FULCRUM_POOL_DEFAULT);
         
         if (useFulcrumPool) {
             if (fulcrumPoolService == null) 
             {
                     // only for fulcrum  pool, need to call internal service, if role pool service is set
                     throw new ConfigurationException("Fulcrum Pool is activated", new ServiceException(ParserService.ROLE,
                             "Fulcrum enabled Pool Service requires " +
                             PoolService.ROLE + " to be available"));
             }
             getLogger().info("Using Fulcrum Pool Service: "+ fulcrumPoolService);
         } else {
             // reset not used fulcrum pool
             fulcrumPoolService = null;
             
             // Define the default configuration
             GenericObjectPoolConfig config = new GenericObjectPoolConfig();
             config.setMaxIdle(DEFAULT_MAX_IDLE);
             config.setMaxTotal(DEFAULT_POOL_CAPACITY);
 
             // init the pool
             valueParserPool 
                 = new BaseValueParserPool(new BaseValueParserFactory(), config);
 
             // init the pool
             parameterParserPool 
                 = new DefaultParameterParserPool(new DefaultParameterParserFactory(), config);
             
             // init the pool
             cookieParserPool 
                 = new CookieParserPool(new CookieParserFactory(), config);
             
             getLogger().info("Init Commons2 Pool Services.." );
             getLogger().info(valueParserPool.getClass().getName());
             getLogger().info(parameterParserPool.getClass().getName());
             getLogger().info(cookieParserPool.getClass().getName());
         }
         
         Configuration[] poolChildren = conf.getChild(POOL_KEY).getChildren();
         if (poolChildren.length > 0) {
             GenericObjectPoolConfig genObjPoolConfig = new GenericObjectPoolConfig();
             genObjPoolConfig.setMaxIdle(DEFAULT_MAX_IDLE);
             genObjPoolConfig.setMaxTotal(DEFAULT_POOL_CAPACITY);
             for (Configuration poolConf : poolChildren) {
                 // use common pool2 configuration names
                 switch (poolConf.getName()) {
                 case "maxTotal":
                     int defaultCapacity = poolConf.getValueAsInteger();
                     genObjPoolConfig.setMaxTotal(defaultCapacity);
                     break;
                 case "maxWaitMillis":
                     int maxWaitMillis = poolConf.getValueAsInteger();
                     genObjPoolConfig.setMaxWaitMillis(maxWaitMillis);
                     break;
                 case "blockWhenExhausted":
                     boolean blockWhenExhausted = poolConf.getValueAsBoolean();
                     genObjPoolConfig.setBlockWhenExhausted(blockWhenExhausted);
                     break;
                 case "maxIdle":
                     int maxIdle = poolConf.getValueAsInteger();
                     genObjPoolConfig.setMaxIdle(maxIdle);
                     break;
                 case "minIdle":
                     int minIdle = poolConf.getValueAsInteger();
                     genObjPoolConfig.setMinIdle(minIdle);
                     break;
                 case "testOnReturn":
                     boolean testOnReturn = poolConf.getValueAsBoolean();
                     genObjPoolConfig.setTestOnReturn(testOnReturn);
                     break;
                 case "testOnBorrow":
                     boolean testOnBorrow = poolConf.getValueAsBoolean();
                     genObjPoolConfig.setTestOnBorrow(testOnBorrow);
                     break;
                 case "testOnCreate":
                     boolean testOnCreate = poolConf.getValueAsBoolean();
                     genObjPoolConfig.setTestOnCreate(testOnCreate);
                     break;
                 default:
                     
                     break;
                 }  
             }    
             // reinit the pools
             valueParserPool.setConfig(genObjPoolConfig);
             parameterParserPool.setConfig(genObjPoolConfig);
             cookieParserPool.setConfig(genObjPoolConfig);
             
             getLogger().debug(valueParserPool.toString());
             getLogger().debug(parameterParserPool.toString());
             getLogger().debug(cookieParserPool.toString());
         }
                 
     }
 
     // ---------------- Avalon Lifecycle Methods ---------------------
     /**
      * Avalon component lifecycle method
      * 
      * @param manager The service manager instance
      * @throws ServiceException generic exception
      * 
      */
     @Override
     public void service(ServiceManager manager) throws ServiceException
     {
         // only for fulcrum  pool, need to call internal service, if role pool service is set
         if (manager.hasService(PoolService.ROLE))
         {
             fulcrumPoolService = (PoolService)manager.lookup(PoolService.ROLE);
         } 
         // no check here, until configuration is read
     }
 }