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

     }

 }