/*
    * (C)opyright 2010, Nikolaos Georgosopoulos
    *
    * This file is part of URLChecker.
   
       URLChecker is free software: you can redistribute it and/or modify
       it under the terms of the Lesser General Public License as published by
       the Free Software Foundation, either version 3 of the License, or
       (at your option) any later version.
  
      URLChecker is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU General Public License for more details.
  
      You should have received a copy of the Lesser General Public License
      along with URLChecker.  If not, see <http://www.gnu.org/licenses/>.
  
   */
  package net.sf.urlchecker.v2.communication;
  
  import java.text.MessageFormat;
  import java.util.regex.Pattern;
  
  import net.sf.urlchecker.communication.GenericCommunicationFactory;
  import net.sf.urlchecker.communication.configurers.ExceptionHandlersConfigurer;
  import net.sf.urlchecker.communication.configurers.RetriesConfigurer;
  import net.sf.urlchecker.communication.configurers.URLPatternConfigurer;
  import net.sf.urlchecker.communication.configurers.ValidCodesConfigurer;
  import net.sf.urlchecker.v2.communication.configurers.ClientConfigurer;
  import net.sf.urlchecker.v2.communication.configurers.MethodsConfigurer;
  
  import org.apache.commons.configuration.ConfigurationException;
  import org.apache.commons.configuration.XMLConfiguration;
  import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;
  import org.apache.http.client.HttpClient;
  import org.apache.http.client.methods.HttpRequestBase;
  import org.apache.http.conn.ClientConnectionManager;
  import org.apache.http.impl.client.DefaultHttpClient;
  
  /**
   * A factory for creating Communication objects.
   * 
   * <p>
   * <b> $Id: CommunicationFactory.java 183 2010-12-17 19:10:21Z georgosn $</b>
   * </p>
   * 
   * @author $LastChangedBy: georgosn $
   * @version $LastChangedRevision: 183 $
   */
  public class CommunicationFactory
          extends
          GenericCommunicationFactory<HttpClient, ClientConnectionManager, HTTPMethods, HttpRequestBase> {
  
      /** The Constant FACTORY. */
      private static final CommunicationFactory FACTORY = new CommunicationFactory();
  
      /**
       * Gets the single instance of CommunicationFactory.
       * 
       * @return single instance of CommunicationFactory
       */
      public static CommunicationFactory getInstance() {
          return FACTORY;
      }
  
      /**
       * Instantiates a new communication FACTORY.
       */
      private CommunicationFactory() {
          configured = false;
          client = null;
          multithreaded = false;
  
      }
  
      /*
       * (non-Javadoc)
       * 
       * @see
       * net.sf.urlchecker.communication.GenericCommunicationFactory#configureClient
       * (boolean)
       */
      /** {@inheritDoc} */
      @Override
      public HttpClient configureClient(boolean localThreadSceme)
              throws ConfigurationException {
          synchronized (this) {
              if (null == client) {
  
                  multithreaded = localThreadSceme;
  
                  XMLConfiguration config = null;
  
                  try {
                      config = new XMLConfiguration(fileName);
  
                  } catch (final ConfigurationException e) {
                      LOGGER.warn(MessageFormat.format(WARNINGS[0], new Object[] {
                             fileName, FILE_NOT_FOUND }));
                     try {
                         config = new XMLConfiguration(
                                 HTTPCONFIGURATION_FILENAME);
                     } catch (final ConfigurationException e1) {
                         LOGGER.warn(MessageFormat.format(WARNINGS[0],
                                 new Object[] { HTTPCONFIGURATION_FILENAME,
                                         NO_CONFIG }));
 
                     }
                 } finally {
                     if (config == null) {
                         throw new ConfigurationException("no configuration");
                     }
                 }
                 final ClientConfigurer current = new ClientConfigurer(
                         multithreaded);
                 client = current.configureWith(config);
 
                 // Configure retries
                 ((DefaultHttpClient) client)
                         .setHttpRequestRetryHandler(new RequestRetryHandler());
                 // ((DefaultHttpClient)client).setHttpConnectionManager(manager);
                 final RetriesConfigurer current1 = new RetriesConfigurer();
                 maxretries = current1.configureWith(config);
                 final MethodsConfigurer current2 = new MethodsConfigurer();
                 methods = current2.configureWith(config);
                 final ExceptionHandlersConfigurer current3 = new ExceptionHandlersConfigurer();
                 exceptionHandlers = current3.configureWith(config);
                 final ValidCodesConfigurer current4 = new ValidCodesConfigurer();
                 validCodes = current4.configureWith(config);
                 final URLPatternConfigurer current5 = new URLPatternConfigurer();
                 final String pattern = current5.configureWith(config);
                 urlpattern = null == pattern ? null : Pattern.compile(pattern);
                 // last statement always
                 configured = true;
             } else {
                 // in case a new client is requested with a different threading
                 // scheme than the one that is active, throw a configuration
                 // exception
                 if (localThreadSceme != multithreaded) {
                     throw new ConfigurationException(
                             "Builder can only return one type of configuration until shutdown");
                 }
             }
             return client;
         }
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see
      * net.sf.urlchecker.communication.GenericCommunicationFactory#configureClient
      * (boolean, java.lang.String)
      */
     /** {@inheritDoc} */
     @Override
     public HttpClient configureClient(boolean localThreadSceme, String FileName)
             throws ConfigurationException {
         synchronized (this) {
             fileName = FileName;
 
             return configureClient(localThreadSceme);
         }
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see
      * net.sf.urlchecker.communication.GenericCommunicationFactory#getMethod
      * (java.lang.String)
      */
     /** {@inheritDoc} */
     @Override
     public HttpRequestBase getMethod(String source) {
         if (!configured) {
             throw new IllegalStateException();
         }
         HTTPMethods type = getMethodType(source);
         if (null == type) {
             type = HTTPMethods.HEAD;
         }
         final HttpRequestBase method = type.getMethod(source);
         /*
          * method.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new
          * RetryHandler());
          */
 
         return method;
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see
      * net.sf.urlchecker.communication.GenericCommunicationFactory#getMethodType
      * (java.lang.String)
      */
     /** {@inheritDoc} */
     @Override
     public HTTPMethods getMethodType(String source) {
         if (!configured) {
             throw new IllegalStateException();
         }
         synchronized (this) {
             HTTPMethods retValue = methods.get(source);
             if (retValue == null) {
                 retValue = methods.get(null);
             }
 
             return retValue;
         }
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see
      * net.sf.urlchecker.communication.GenericCommunicationFactory#shutdown()
      */
     /** {@inheritDoc} */
     @Override
     public void shutdown() {
         synchronized (this) {
             if (multithreaded) {
                 MultiThreadedHttpConnectionManager.shutdownAll();
                 multithreaded = false;
             }
             if (null != client) {
                 client.getConnectionManager().shutdown();
                 client = null;
             }
             configured = false;
         }
     }
 
 }