/*
    * Copyright (c) 2007, Peter Mika All rights reserved.
    * 
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    * 
    * - Redistributions of source code must retain the above copyright notice, this
    *   list of conditions and the following disclaimer.
    * - Redistributions in binary form must reproduce the above copyright notice,
   *   this list of conditions and the following disclaimer in the documentation
   *   and/or other materials provided with the distribution. 
   * - Neither the name of the openrdf.org nor the names of its contributors may
   *   be used to endorse or promote products derived from this software without
   *   specific prior written permission.
   * 
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   * 
   */
  package org.openrdf.elmo.smusher;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  
  import org.openrdf.OpenRDFException;
  import org.openrdf.elmo.sesame.SesameManager;
  import org.openrdf.elmo.smusher.listener.CounterListener;
  import org.openrdf.elmo.smusher.listener.SmusherListener;
  import org.openrdf.model.Resource;
  import org.openrdf.repository.Repository;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /** A version of the IterativeSmusher for smushers that are independent, i.e.
   * the matches found using one smusher do not influence the matches found with 
   * another smusher. In such case, every smusher is executed only once and only
   * the TransitivitySmusher is iterated.
   * 
   * @see TransitivitySmusher
   * @author Peter Mika (pmika@cs.vu.nl)
   *
   */
  public class FastIterativeSmusher extends AbstractSmusher {
      
      protected List<Smusher> _smushers = new ArrayList<Smusher>();
       protected int _lastCount = -1;
      protected final static Logger _logger = LoggerFactory.getLogger(FastIterativeSmusher.class);
     
      public FastIterativeSmusher() {
          
      }
         
      public void addSmusher(Smusher smusher) {
          if (smusher != null) {
              _smushers.add(smusher);
          }
      }
      
      public void removeSmusher(Smusher smusher) {
          if (smusher != null) {
              _smushers.remove(smusher);
          }
      }
      
      private class MetaListener implements SmusherListener {
          
          Collection _listeners = new HashSet();
          
          public MetaListener(Collection listeners) {
              _listeners = listeners;
          }
          public void start() {          
          }
          public void matchFound(Resource first, Resource second) {
              Iterator subit = _listeners.iterator();
              while (subit.hasNext()) {
                  SmusherListener nextListener = (SmusherListener) subit.next();
                  nextListener.matchFound(first, second);
              }
          }
          
          public void commit() {
          }
          
          public void finish() {                
          }
          
     }
     
     public void smush(SesameManager firstRepository, SesameManager secondRepository) throws OpenRDFException {
         
       
         
         //Register our own listener with all of the smushers
         MetaListener metaListener = new MetaListener(_listeners);
         CounterListener counterListener = new CounterListener();
         
         for (int i = 0; i < _smushers.size(); i++) {
             Smusher nextSmusher = (Smusher) _smushers.get(i);
             nextSmusher.addListener(metaListener);
             nextSmusher.addListener(counterListener);
         }
         
         //Start all the registered listeners
         Iterator it = _listeners.iterator();
         while (it.hasNext()) {
             SmusherListener nextListener = (SmusherListener) it.next();
             nextListener.start();
         }
         
         //Run all the smushers once
         for (int i = 0; i < _smushers.size(); i++) {
             Smusher nextSmusher = (Smusher) _smushers.get(i);
             nextSmusher.smush(firstRepository, secondRepository);   
         }
         
         //Commit all the registered listeners
         it = _listeners.iterator();
         while (it.hasNext()) {
             SmusherListener nextListener = (SmusherListener) it.next();
             nextListener.commit();
         }
        
         _logger.debug("First iteration found " + counterListener.getCount() + " matches");
         
         
         //Iterate the SameAsTransitivitySmusher
         Smusher transSmusher = new TransitivitySmusher();
         transSmusher.addListener(metaListener);
         transSmusher.addListener(counterListener);
         
         _lastCount = -1;
         int newCount = 0;
         //Run all the smushers until they collectively produce more hits
         //than in the previous iteration
         while (newCount > _lastCount) {
             
             _lastCount = newCount;
             counterListener.reset();
             //Apply the transitivity rule of owl:sameAs
             transSmusher.smush(firstRepository, secondRepository);
            
             newCount = counterListener.getCount();
             _logger.debug("Last iteration found " + newCount + " matches");
             
             //Commit all the registered listeners
             it = _listeners.iterator();
             while (it.hasNext()) {
                 SmusherListener nextListener = (SmusherListener) it.next();
                 nextListener.commit();
             }
         }
         _lastCount = newCount;
         
         //Finish all the registered listeners
         it = _listeners.iterator();
         while (it.hasNext()) {
             SmusherListener nextListener = (SmusherListener) it.next();
             nextListener.finish();
         }
        
     }
 
     /**
      * @return Returns the _lastCount.
      */
     public int getLastCount() {
         return _lastCount;
     }
 
     
 }