/*
    * (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.commands;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.concurrent.ExecutionException;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  import java.util.concurrent.Future;
  import java.util.concurrent.TimeUnit;
  
  import net.sf.urlchecker.commands.CheckUrlsGeneric;
  import net.sf.urlchecker.commands.Command;
  import net.sf.urlchecker.commands.Context;
  import net.sf.urlchecker.commands.Result;
  import net.sf.urlchecker.events.BasicChainEvent;
  import net.sf.urlchecker.events.EventTypes;
  
  import org.apache.commons.configuration.ConfigurationException;
  import org.apache.http.client.HttpClient;
  import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
  import org.apache.http.protocol.HttpContext;
  import org.apache.log4j.Logger;
  
  /**
   * The Class CheckUrlsCommand for the new httpClient. Use this implementation
   * together with the CommunicationBuilder in the v2.communication package if you
   * want to move on to the new appache.http.client. The new Constructor in this
   * class allows for deeper configuration of the execution environment.
   * 
   * <p>
   * <b> $Id: CheckUrlsCommand.java 183 2010-12-17 19:10:21Z georgosn $</b>
   * </p>
   * 
   * @author $LastChangedBy: georgosn $
   * @version $LastChangedRevision: 183 $
   */
  public class CheckUrlsCommand extends CheckUrlsGeneric<HttpClient> {
  
      /** The Constant LOGGER. */
      private static final Logger LOGGER = Logger.getLogger(CheckUrlsCommand.class
                                                 .getName());
  
      /** The local context. */
      protected final HttpContext localContext;
  
      /**
       * Instantiates a new check URLs command.
       * 
       * @param successor
       *            the successor
       * @param newClient
       *            the new client
       */
      public CheckUrlsCommand(Command successor, HttpClient newClient) {
          super(successor, newClient);
          localContext = null;
      }
  
      /**
       * Instantiates a new check URLs command.
       * 
       * @param successor
       *            the successor
       * @param newClient
       *            the new client
       * @param foreignContext
       *            the foreign context
       */
      public CheckUrlsCommand(Command successor, HttpClient newClient,
              HttpContext foreignContext) {
          super(successor, newClient);
          localContext = foreignContext;
      }
  
      /*
       * (non-Javadoc)
       * 
       * @see net.sf.urlchecker.commands.CheckUrlsGeneric#isMultithreaded()
       */
     /** {@inheritDoc} */
     @Override
     public boolean isMultithreaded() {
         return client.getConnectionManager().getClass()
                 .isAssignableFrom(ThreadSafeClientConnManager.class);
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see
      * net.sf.urlchecker.commands.CheckUrlsGeneric#multithreadedExecution(net
      * .sf.urlchecker.commands.Context, java.util.Iterator)
      */
     /** {@inheritDoc} */
     @Override
     protected void multithreadedExecution(Context context, Iterator<Result> iter)
             throws ConfigurationException {
         final ExecutorService service = Executors.newFixedThreadPool(context
                 .getResults().size());
         final List<Future<CheckUrlsProcess>> tasks = new ArrayList<Future<CheckUrlsProcess>>();
 
         while (iter.hasNext()) {
             fireEvent(new BasicChainEvent(this, context, EventTypes.FORK));
             final CheckUrlsProcess process = new CheckUrlsProcess(client,
                     localContext, iter.next());
             final Future<CheckUrlsProcess> future = service.submit(process,
                     process);
             tasks.add(future);
         }
 
         try {
             for (final Future<CheckUrlsProcess> f : tasks) {
                 final Result result = f.get().getResult();
 
                 if (LOGGER.isDebugEnabled()) {
                     LOGGER.debug(result.getResult() + " for " + result.getURI()
                             + " with " + result.getUserData());
                 }
             }
 
             service.shutdown();
         } catch (final InterruptedException e) {
             LOGGER.error(e);
             fireEvent(new BasicChainEvent(this, context, EventTypes.EXCEPTION));
         } catch (final ExecutionException e) {
             LOGGER.error(e);
             fireEvent(new BasicChainEvent(this, context, EventTypes.EXCEPTION));
         } finally {
             try {
                 if (!service.isShutdown()) {
                     service.awaitTermination(terminationTime, TimeUnit.SECONDS);
                 }
             } catch (final InterruptedException e) {
                 LOGGER.error(e);
                 fireEvent(new BasicChainEvent(this, context,
                         EventTypes.EXCEPTION));
             } finally {
                 if (!service.isShutdown()) {
                     service.shutdownNow();
                 }
             }
         }
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see
      * net.sf.urlchecker.commands.CheckUrlsGeneric#singlethreadedExecution(java
      * .util.Iterator)
      */
     /** {@inheritDoc} */
     @Override
     protected void singlethreadedExecution(Iterator<Result> iter)
             throws ConfigurationException {
         while (iter.hasNext()) {
             final CheckUrlsProcess process = new CheckUrlsProcess(client,
                     localContext, iter.next());
             process.run();
         }
 
     }
 }