package org.apache.turbine.services.rundata;
   
   /*
    * 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.util.HashMap;
  import java.util.Iterator;
  import java.util.Locale;
  import java.util.Map;
  
  import javax.servlet.ServletConfig;
  import javax.servlet.ServletContext;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import org.apache.commons.configuration2.Configuration;
  import org.apache.fulcrum.parser.CookieParser;
  import org.apache.fulcrum.parser.DefaultCookieParser;
  import org.apache.fulcrum.parser.DefaultParameterParser;
  import org.apache.fulcrum.parser.ParameterParser;
  import org.apache.fulcrum.parser.ParserService;
  import org.apache.fulcrum.pool.PoolException;
  import org.apache.fulcrum.pool.PoolService;
  import org.apache.turbine.Turbine;
  import org.apache.turbine.services.InitializationException;
  import org.apache.turbine.services.TurbineBaseService;
  import org.apache.turbine.services.TurbineServices;
  import org.apache.turbine.util.RunData;
  import org.apache.turbine.util.ServerData;
  import org.apache.turbine.util.TurbineException;
  
  /**
   * The RunData Service provides the implementations for RunData and
   * related interfaces required by request processing. It supports
   * different configurations of implementations, which can be selected
   * by specifying a configuration key. It may use pooling, in which case
   * the implementations should implement the Recyclable interface.
   *
   * @author <a href="mailto:ilkka.priha@simsoft.fi">Ilkka Priha</a>
   * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
   * @version $Id: TurbineRunDataService.java 1854787 2019-03-04 18:30:25Z tv $
   */
  public class TurbineRunDataService
      extends TurbineBaseService
      implements RunDataService
  {
  
      /** The default implementation of the RunData object*/
      private static final String DEFAULT_RUN_DATA =
          DefaultTurbineRunData.class.getName();
  
      /** The default implementation of the Parameter Parser object */
      private static final String DEFAULT_PARAMETER_PARSER =
          DefaultParameterParser.class.getName();
  
      /** The default implementation of the Cookie parser object */
      private static final String DEFAULT_COOKIE_PARSER =
          DefaultCookieParser.class.getName();
  
      /** The map of configurations. */
      private final Map<String, Object> configurations = new HashMap<String, Object>();
  
      /** A class cache. */
      private final Map<String, Class<?>> classCache = new HashMap<String, Class<?>>();
  
      /** Private reference to the pool service for object recycling */
      private PoolService pool = null;
  
      /** Private reference to the parser service for parser recycling */
      private ParserService parserService = null;
  
      /**
       * Constructs a RunData Service.
       */
      public TurbineRunDataService()
      {
          super();
      }
  
      /**
       * Initializes the service by setting the pool capacity.
       *
       * @throws InitializationException if initialization fails.
      */
     @Override
     public void init()
             throws InitializationException
     {
         // Create a default configuration.
         String[] def = new String[]
         {
             DEFAULT_RUN_DATA,
             DEFAULT_PARAMETER_PARSER,
             DEFAULT_COOKIE_PARSER
         };
         configurations.put(DEFAULT_CONFIG, def.clone());
 
         // Check other configurations.
         Configuration conf = getConfiguration();
         if (conf != null)
         {
             String key,value;
             String[] config;
             String[] plist = new String[]
             {
                 RUN_DATA_KEY,
                 PARAMETER_PARSER_KEY,
                 COOKIE_PARSER_KEY
             };
             for (Iterator<String> i = conf.getKeys(); i.hasNext();)
             {
                 key = i.next();
                 value = conf.getString(key);
                 for (int j = 0; j < plist.length; j++)
                 {
                     if (key.endsWith(plist[j]) && key.length() > plist[j].length() + 1)
                     {
                         key = key.substring(0, key.length() - plist[j].length() - 1);
                         config = (String[]) configurations.get(key);
                         if (config == null)
                         {
                             config = def.clone();
                             configurations.put(key, config);
                         }
                         config[j] = value;
                         break;
                     }
                 }
             }
         }
 
 		pool = (PoolService)TurbineServices.getInstance().getService(PoolService.ROLE);
 
         if (pool == null)
         {
             throw new InitializationException("RunData Service requires"
                 + " configured Pool Service!");
         }
 
         parserService = (ParserService)TurbineServices.getInstance().getService(ParserService.ROLE);
 
         if (parserService == null)
         {
             throw new InitializationException("RunData Service requires"
                 + " configured Parser Service!");
         }
 
         setInit(true);
     }
 
     /**
      * Shutdown the service
      *
      * @see org.apache.turbine.services.TurbineBaseService#shutdown()
      */
     @Override
     public void shutdown()
     {
         classCache.clear();
         super.shutdown();
     }
 
     /**
      * Gets a default RunData object.
      *
      * @param req a servlet request.
      * @param res a servlet response.
      * @param config a servlet config.
      * @return a new or recycled RunData object.
      * @throws TurbineException if the operation fails.
      */
     @Override
     public RunData getRunData(HttpServletRequest req,
                               HttpServletResponse res,
                               ServletConfig config)
             throws TurbineException
     {
         return getRunData(DEFAULT_CONFIG, req, res, config);
     }
 
     /**
      * Gets a RunData instance from a specific configuration.
      *
      * @param key a configuration key.
      * @param req a servlet request.
      * @param res a servlet response.
      * @param config a servlet config.
      * @return a new or recycled RunData object.
      * @throws TurbineException if the operation fails.
      * @throws IllegalArgumentException if any of the parameters are null.
      * TODO The "key" parameter should be removed in favor of just looking up what class via the roleConfig avalon file.
      */
     @Override
     public RunData getRunData(String key,
                               HttpServletRequest req,
                               HttpServletResponse res,
                               ServletConfig config)
             throws TurbineException,
             IllegalArgumentException
     {
         // The RunData object caches all the information that is needed for
         // the execution lifetime of a single request. A RunData object
         // is created/recycled for each and every request and is passed
         // to each and every module. Since each thread has its own RunData
         // object, it is not necessary to perform synchronization for
         // the data within this object.
         if (req == null || res == null || config == null)
         {
             throw new IllegalArgumentException("HttpServletRequest, "
                 + "HttpServletResponse or ServletConfig was null.");
         }
 
         // Get the specified configuration.
         String[] cfg = (String[]) configurations.get(key);
         if (cfg == null)
         {
             throw new TurbineException("RunTime configuration '" + key + "' is undefined");
         }
 
         TurbineRunData data;
         try
         {
     		Class<?> runDataClazz = classCache.get(cfg[0]);
     		if (runDataClazz == null)
     		{
     		    runDataClazz = Class.forName(cfg[0]);
     		    classCache.put(cfg[0], runDataClazz);
     		}
 
             Class<?> parameterParserClazz = classCache.get(cfg[1]);
             if (parameterParserClazz == null)
             {
                 parameterParserClazz = Class.forName(cfg[1]);
                 classCache.put(cfg[1], parameterParserClazz);
             }
 
             Class<?> cookieParserClazz = classCache.get(cfg[2]);
             if (cookieParserClazz == null)
             {
                 cookieParserClazz = Class.forName(cfg[2]);
                 classCache.put(cfg[2], cookieParserClazz);
             }
 
             data = (TurbineRunData) pool.getInstance(runDataClazz);
             @SuppressWarnings("unchecked") // ok
             ParameterParser pp = parserService.getParser((Class<ParameterParser>)parameterParserClazz);
             data.get(Turbine.class).put(ParameterParser.class, pp);
 
             @SuppressWarnings("unchecked") // ok
             CookieParser cp = parserService.getParser((Class<CookieParser>)cookieParserClazz);
             data.get(Turbine.class).put(CookieParser.class, cp);
 
             Locale locale = req.getLocale();
 
             if (locale == null)
             {
                 // get the default from the Turbine configuration
                 locale = data.getLocale();
             }
 
             // set the locale detected and propagate it to the parsers
             data.setLocale(locale);
         }
         catch (PoolException pe)
         {
             throw new TurbineException("RunData configuration '" + key + "' is illegal caused a pool exception", pe);
         }
         catch (ClassNotFoundException | ClassCastException | InstantiationException x)
         {
             throw new TurbineException("RunData configuration '" + key + "' is illegal", x);
         }
 
         // Set the request and response.
         data.get(Turbine.class).put(HttpServletRequest.class, req);
         data.get(Turbine.class).put(HttpServletResponse.class, res);
 
         // Set the servlet configuration.
         data.get(Turbine.class).put(ServletConfig.class, config);
         data.get(Turbine.class).put(ServletContext.class, config.getServletContext());
 
         // Set the ServerData.
         data.get(Turbine.class).put(ServerData.class, new ServerData(req));
 
         return data;
     }
 
     /**
      * Puts the used RunData object back to the factory for recycling.
      *
      * @param data the used RunData object.
      * @return true, if pooling is supported and the object was accepted.
      */
     @Override
     public boolean putRunData(RunData data)
     {
         if (data instanceof TurbineRunData)
         {
             parserService.putParser(((TurbineRunData) data).getParameterParser());
             parserService.putParser(((TurbineRunData) data).getCookieParser());
 
             return pool.putInstance(data);
         }
         else
         {
             return false;
         }
     }
 }