/*

     dsh-evolve  Framework for evolutionary algorithms.

     Copyright (c) 2005-2013 held jointly by the individual authors.

     This library is free software; you can redistribute it and/or modify it

     under the terms of the GNU Lesser General Public License as published

     by the Free Software Foundation; either version 3 of the License, or (at

     your option) any later version.

     This library is distributed in the hope that it will be useful, but WITHOUT

     ANY WARRANTY; with out even the implied warranty of MERCHANTABILITY or

     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public

     License for more details.

     You should have received a copy of the GNU Lesser General Public License

     along with this library;  if not, write to the Free Software Foundation,

     Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA.

     > http://www.fsf.org/licensing/licenses/lgpl.html

     > http://www.opensource.org/licenses/lgpl-license.php

 */

 package org.dishevelled.evolve.impl;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Iterator;

 import javax.swing.event.EventListenerList;

 import org.dishevelled.evolve.EvolutionaryAlgorithm;

 import org.dishevelled.evolve.EvolutionaryAlgorithmEvent;

 import org.dishevelled.evolve.EvolutionaryAlgorithmListener;

 import org.dishevelled.evolve.ExitStrategy;

 import org.dishevelled.evolve.Fitness;

 import org.dishevelled.evolve.Mutation;

 import org.dishevelled.evolve.Recombination;

 import org.dishevelled.evolve.Selection;

 import org.dishevelled.weighted.WeightedMap;

 import org.dishevelled.weighted.HashWeightedMap;

 /**

  * Implementation of an evolutionary algorithm function.

  *

  * @param <I> individual type

  * @author  Michael Heuer

  * @version $Revision: 320 $ $Date: 2007-10-23 14:06:38 -0500 (Tue, 23 Oct 2007) $

  */

 public final class EvolutionaryAlgorithmImpl<I>

     implements EvolutionaryAlgorithm<I>

 {

     /** Default hash map load factor. */

     private static final float DEFAULT_LOAD_FACTOR = 0.75f;

     /** Listener list. */

     private EventListenerList listenerList = new EventListenerList();

     /**

      * Create a new evolutionary algorithm function implementation.

      */

     public EvolutionaryAlgorithmImpl()

     {

         // empty

     }

     /** {@inheritDoc} */

     public Collection<I> evolve(final Collection<I> individuals,

                                 final ExitStrategy<I> exitStrategy,

                                 final Recombination<I> recombination,

                                 final Mutation<I> mutation,

                                 final Fitness<I> fitness,

                                 final Selection<I> selection)

     {

         checkParameters(individuals, exitStrategy, recombination, mutation, fitness, selection);

         // initialize population with individuals

         Collection<I> population = new ArrayList<I>(individuals);

         // initialize fitness scores to 0.0d

         WeightedMap<I> scores = new HashWeightedMap<I>(population.size(), DEFAULT_LOAD_FACTOR);

         for (I i : individuals)

         {

             scores.put(i, Double.valueOf(0.0d));

         }

         int time = 0;

         while (!exitStrategy.evaluate(population, scores, time))

         {

             fireExitFailed(population, scores, time);

             // recombine population

             Collection<I> recombined = recombination.recombine(population);

             fireRecombined(population, recombined);

             // mutate amongst themselves

             Collection<I> mutated = mutation.mutate(recombined);

             fireMutated(recombined, mutated);

             // evalute fitness

             for (I i : mutated)

             {

                 Double score = fitness.score(i);

                 scores.put(i, score);

                 fireFitnessCalculated(i, score);

             }

             // select individuals for next generation

             population = selection.select(mutated, scores);

             fireSelected(mutated, population, scores);

             // remove last generation from scores

             for (Iterator<I> keys = scores.keySet().iterator(); keys.hasNext(); )

             {

                 I i = keys.next();

                 if (!population.contains(i))

                 {

                     keys.remove();

                 }

             }

             time++;

         }

         // exit strategy condition(s) met, return successful population

         fireExitSucceeded(population, scores, time);

         return population;

     }

     /**

      * Check that the specified parameters are valid.

      *

      * @param individuals collection of individuals, must not be null and must contain

      *    at least one individual

      * @param exitStrategy exit strategy function, must not be null

      * @param recombination recombination function, must not be null

      * @param mutation mutation function, must not be null

      * @param fitness fitness function, must not be null

      * @param selection selection function, must not be null

      */

     private void checkParameters(final Collection<I> individuals,

                                  final ExitStrategy<I> exitStrategy,

                                  final Recombination<I> recombination,

                                  final Mutation<I> mutation,

                                  final Fitness<I> fitness,

                                  final Selection<I> selection)

     {

         // check for null or otherwise illegal parameters

         if (individuals == null)

         {

             throw new IllegalArgumentException("individuals must not be null");

         }

         if (individuals.size() == 0)

         {

             throw new IllegalArgumentException("individuals must not be empty");

         }

         if (exitStrategy == null)

         {

             throw new IllegalArgumentException("exitStrategy must not be null");

         }

         if (recombination == null)

         {

             throw new IllegalArgumentException("recombination must not be null");

         }

         if (mutation == null)

         {

             throw new IllegalArgumentException("mutation must not be null");

         }

         if (fitness == null)

         {

             throw new IllegalArgumentException("fitness must not be null");

         }

         if (selection == null)

         {

             throw new IllegalArgumentException("selection must not be null");

         }

     }

    /**

      * Add the specified evolutionary algorithm listener.

      *

      * @param l evolutionary algorithm listener to add

      */

     /** {@inheritDoc} */

     public void addEvolutionaryAlgorithmListener(final EvolutionaryAlgorithmListener<I> l)

     {

         listenerList.add(EvolutionaryAlgorithmListener.class, l);

     }

     /** {@inheritDoc} */

     public void removeEvolutionaryAlgorithmListener(final EvolutionaryAlgorithmListener<I> l)

     {

         listenerList.remove(EvolutionaryAlgorithmListener.class, l);

     }

     /** {@inheritDoc} */

     public int getEvolutionaryAlgorithmListenerCount()

     {

         return listenerList.getListenerCount(EvolutionaryAlgorithmListener.class);

     }

     /** {@inheritDoc} */

     public EvolutionaryAlgorithmListener<I>[] getEvolutionaryAlgorithmListeners()

     {

         return (EvolutionaryAlgorithmListener<I>[]) listenerList.getListeners(EvolutionaryAlgorithmListener.class);

     }

     /**

      * Fire an exit failed event to all registered listeners.

      *

      * @param population population

      * @param scores fitness scores

      * @param time time

      */

     private void fireExitFailed(final Collection<I> population, final WeightedMap<I> scores, final int time)

     {

         Object[] listeners = listenerList.getListenerList();

         EvolutionaryAlgorithmEvent<I> e = null;

         for (int i = listeners.length - 2; i >= 0; i -= 2)

         {

             if (listeners[i] == EvolutionaryAlgorithmListener.class)

             {

                 if (e == null)

                 {

                     e = new EvolutionaryAlgorithmEvent<I>(this, population, scores, time);

                 }

                 ((EvolutionaryAlgorithmListener<I>) listeners[i + 1]).exitFailed(e);

             }

         }

     }

     /**

      * Fire an exit succeeded event to all registered listeners.

      *

      * @param population population

      * @param scores fitness scores

      * @param time time

      */

     private void fireExitSucceeded(final Collection<I> population, final WeightedMap<I> scores, final int time)

     {

         Object[] listeners = listenerList.getListenerList();

         EvolutionaryAlgorithmEvent<I> e = null;

         for (int i = listeners.length - 2; i >= 0; i -= 2)

         {

             if (listeners[i] == EvolutionaryAlgorithmListener.class)

             {

                 if (e == null)

                 {

                     e = new EvolutionaryAlgorithmEvent<I>(this, population, scores, time);

                 }

                 ((EvolutionaryAlgorithmListener<I>) listeners[i + 1]).exitSucceeded(e);

             }

         }

     }

     /**

      * Fire a recombined event to all registered listeners.

      *

      * @param population population

      * @param recombined recombined

      */

     private void fireRecombined(final Collection<I> population, final Collection<I> recombined)

     {

         Object[] listeners = listenerList.getListenerList();

         EvolutionaryAlgorithmEvent<I> e = null;

         for (int i = listeners.length - 2; i >= 0; i -= 2)

         {

             if (listeners[i] == EvolutionaryAlgorithmListener.class)

             {

                 if (e == null)

                 {

                     e = new EvolutionaryAlgorithmEvent<I>(this, population, recombined, (Collection<I>) null);

                 }

                 ((EvolutionaryAlgorithmListener<I>) listeners[i + 1]).recombined(e);

             }

         }

     }

     /**

      * Fire a mutated event to all registered listeners.

      *

      * @param recombined recombined

      * @param mutated mutated

      */

     private void fireMutated(final Collection<I> recombined, final Collection<I> mutated)

     {

         Object[] listeners = listenerList.getListenerList();

         EvolutionaryAlgorithmEvent<I> e = null;

         for (int i = listeners.length - 2; i >= 0; i -= 2)

         {

             if (listeners[i] == EvolutionaryAlgorithmListener.class)

             {

                 if (e == null)

                 {

                     e = new EvolutionaryAlgorithmEvent<I>(this, null, recombined, mutated);

                 }

                 ((EvolutionaryAlgorithmListener<I>) listeners[i + 1]).mutated(e);

             }

         }

     }

     /**

      * Fire a fitness calculated event to all registered listeners.

      *

      * @param individual individual

      * @param score score

      */

     private void fireFitnessCalculated(final I individual, final Double score)

     {

         Object[] listeners = listenerList.getListenerList();

         EvolutionaryAlgorithmEvent<I> e = null;

         for (int i = listeners.length - 2; i >= 0; i -= 2)

         {

             if (listeners[i] == EvolutionaryAlgorithmListener.class)

             {

                 if (e == null)

                 {

                     e = new EvolutionaryAlgorithmEvent<I>(this, individual, score);

                 }

                 ((EvolutionaryAlgorithmListener<I>) listeners[i + 1]).fitnessCalculated(e);

             }

         }

     }

     /**

      * Fire a selected event to all registered listeners.

      *

      * @param population population

      * @param selected selected

      * @param scores fitness scores

      */

     private void fireSelected(final Collection<I> population,

                               final Collection<I> selected,

                               final WeightedMap<I> scores)

     {

         Object[] listeners = listenerList.getListenerList();

         EvolutionaryAlgorithmEvent<I> e = null;

         for (int i = listeners.length - 2; i >= 0; i -= 2)

         {

             if (listeners[i] == EvolutionaryAlgorithmListener.class)

             {

                 if (e == null)

                 {

                     e = new EvolutionaryAlgorithmEvent<I>(this, population, selected, scores);

                 }

                 ((EvolutionaryAlgorithmListener<I>) listeners[i + 1]).selected(e);

             }

         }

     }

 }