/*
    * (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.communication;
  
  import java.text.MessageFormat;
  import java.util.regex.Pattern;
  
  import net.sf.urlchecker.commands.RetryHandler;
  import net.sf.urlchecker.communication.configurers.ClientConfigurer;
  import net.sf.urlchecker.communication.configurers.ExceptionHandlersConfigurer;
  import net.sf.urlchecker.communication.configurers.MethodsConfigurer;
  import net.sf.urlchecker.communication.configurers.RetriesConfigurer;
  import net.sf.urlchecker.communication.configurers.URLPatternConfigurer;
  import net.sf.urlchecker.communication.configurers.ValidCodesConfigurer;
  
  import org.apache.commons.configuration.ConfigurationException;
  import org.apache.commons.configuration.XMLConfiguration;
  import org.apache.commons.httpclient.HttpClient;
  import org.apache.commons.httpclient.HttpConnectionManager;
  import org.apache.commons.httpclient.HttpMethod;
  import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;
  import org.apache.commons.httpclient.SimpleHttpConnectionManager;
  import org.apache.commons.httpclient.params.HttpMethodParams;
  
  /**
   * A FACTORY for creating Communication objects.
   * 
   * <p>
   * <b> $Id: CommunicationFactory.java 182 2010-12-13 22:51:53Z georgosn $</b>
   * </p>
   * 
   * @author $LastChangedBy: georgosn $
   * @version $LastChangedRevision: 182 $
   */
  public final class CommunicationFactory
          extends
          GenericCommunicationFactory<HttpClient, HttpConnectionManager, HTTPMethods, HttpMethod> {
  
      /** The Constant FACTORY. */
      private static final CommunicationFactory FACTORY = new CommunicationFactory();
  
      /**
       * Returns 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;
  
      }
  
      /**
       * {@inheritDoc}
       * 
       * Configure client.
       */
      @Override
      public HttpClient configureClient(final boolean localThreadSceme)
              throws ConfigurationException {
          synchronized (this) {
              if (null == client) {
  
                  multithreaded = localThreadSceme;
                  if (multithreaded) {
                      manager = new MultiThreadedHttpConnectionManager();
                  } else {
                      manager = new SimpleHttpConnectionManager();
                  }
  
                  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();
                 client = current.configureWith(config);
                 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);
         }
     }
 
     /**
      * {@inheritDoc}
      * 
      * Gets the method.
      */
     @Override
     public HttpMethod getMethod(final String source) {
         if (!configured) {
             throw new IllegalStateException();
         }
         HTTPMethods type = getMethodType(source);
         if (null == type) {
             type = HTTPMethods.HEAD;
         }
         final HttpMethod method = type.getMethod(source);
         method.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,
                 new RetryHandler());
 
         return method;
     }
 
     /**
      * {@inheritDoc}
      * 
      * Gets the method type.
      */
     @Override
     public HTTPMethods getMethodType(final String source) {
         if (!configured) {
             throw new IllegalStateException();
         }
         synchronized (this) {
             HTTPMethods retValue = methods.get(source);
             if (retValue == null) {
                 retValue = methods.get(null);
             }
 
             return retValue;
         }
     }
 
     /**
      * {@inheritDoc}
      * 
      * Shutdown.
      */
     @Override
     public void shutdown() {
         synchronized (this) {
             if (multithreaded) {
                 MultiThreadedHttpConnectionManager.shutdownAll();
                 multithreaded = false;
             }
             if (null != client) {
                 client.getState().clear();
                 client.getState().clearCookies();
                 client.getState().clearCredentials();
                 client.getState().clearProxyCredentials();
                 client = null;
             }
             configured = false;
         }
     }
 
 }