package net.sf.jclec.problem.funopt;

import java.util.Comparator;

import net.sf.jclec.IFitness;
import net.sf.jclec.IConfigure;

import net.sf.jclec.base.AbstractEvaluator;

import net.sf.jclec.fitness.SimpleValueFitness;
import net.sf.jclec.fitness.ValueFitnessComparator;

import org.apache.commons.configuration.Configuration;

import org.apache.commons.lang.builder.EqualsBuilder;

/**
 * Function optimization evaluator.
 *  
 * @author Sebastián Ventura
 */

public class FuncOptEvaluator extends AbstractEvaluator<IFuncOptIndividual> implements IConfigure
{
	/////////////////////////////////////////////////////////////////
	// --------------------------------------- Serialization constant
	/////////////////////////////////////////////////////////////////

	/** Generated by Eclipse */
	
	private static final long serialVersionUID = 3613350191235561000L;

	/////////////////////////////////////////////////////////////////
	// --------------------------------------------------- Properties
	/////////////////////////////////////////////////////////////////

	/** Function to optimize */
	
	protected IFunction function;
	
	/** Maximize of minimize functions? */
	
	protected boolean maximize;
	
	/////////////////////////////////////////////////////////////////
	// ------------------------------------------- Internal variables
	/////////////////////////////////////////////////////////////////

	/** Fitness comparator */
	
	protected transient ValueFitnessComparator comparator;
	
	/////////////////////////////////////////////////////////////////
	// ------------------------------------------------- Constructors
	/////////////////////////////////////////////////////////////////

	/**
	 * Empty constructor.
	 */
	
	public FuncOptEvaluator() 
	{
		super();
	}

	/////////////////////////////////////////////////////////////////
	// ------------------------------- Setting and getting properties
	/////////////////////////////////////////////////////////////////

	/**
	 * Access to function to optimize
	 * 
	 * @return Function to optimize
	 */
	
	public IFunction getFunction() 
	{
		return function;
	}

	/**
	 * Set the function to optimize
	 * 
	 * @param function Function to optimize
	 */
	
	public void setFunction(IFunction function) 
	{
		this.function = function;
	}

	/**
	 * Is this evaluator being used to maximize a function?
	 *  
	 * @return true If evaluator is used to maximize function, false
	 * 		   otherwise.
	 */
	
	public boolean isMaximize() 
	{
		return maximize;
	}

	/**
	 * Set the maximize flag.
	 * 
	 * @param maximize Actual maximize flag.
	 */

	public void setMaximize(boolean maximize) 
	{
		this.maximize = maximize;
	}
	
	/////////////////////////////////////////////////////////////////
	// ------------------------ Overwriting AbstractEvaluator methods
	/////////////////////////////////////////////////////////////////
	
	/**
	 * Configuration method.
	 * 
	 * Configuration setting for FuncOptEvaluator are:
	 * 
	 * <ul>
	 * <li>
	 * <code>function: complex</code></p>
	 * Function to optimize
	 * </li>
	 * <li>
	 * <code>maximize: boolean (default true)</code></p>
	 * Is this a maximization problem?
	 * </li>
	 * </ul> 
	 */
	
	@SuppressWarnings("unchecked")
	public void configure(Configuration settings) 
	{
		// Function to optimize
		try {
			// Random generator classname
			String functionClassname = 
				settings.getString("function[@type]");
			// Random generator class
			Class<? extends IFunction> functionClass = 
				(Class<? extends IFunction>) Class.forName(functionClassname);
			// Random generator instance
			IFunction function = functionClass.newInstance();
			// Init function (if necessary)
			if (function instanceof IConfigure) {
				((IConfigure) function).configure(settings.subset("function"));
			}
			// Set random generator
			setFunction(function);
		} 
		catch (ClassNotFoundException e) {
			e.printStackTrace();
		} 
		catch (InstantiationException e) {
			e.printStackTrace();
		} 
		catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		// Maximize flag
		boolean maximize = settings.getBoolean("maximize", true);
		setMaximize(maximize);
		
	}

	/////////////////////////////////////////////////////////////////
	// ------------------------ Overwriting AbstractEvaluator methods
	/////////////////////////////////////////////////////////////////
	
	/**
	 * Apply function over  phenotype, then create a  instance of the
	 * SimpleValueFitness class  with its value set to function value 
	 * and assigns it to the individual.
	 * 
	 * @param ind Individual to evaluate
	 */
	
	@Override
	protected void evaluate(IFuncOptIndividual ind) 
	{
		ind.setFitness(new SimpleValueFitness(function.execute(ind.getPhenotype())));
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @return A ValueFitnessComparator object. 'inverse' flag of this
	 * 		   comparator is set to <code><b>not</b>(maximize)</code>.
	 * 
	 * @see org.ayrna.jclec.fitness.ValueFitnessComparator 
	 */
	
	public Comparator<IFitness> getComparator() 
	{		
		// Set fitness comparator (if necessary)
		if (comparator == null) {
			comparator = new ValueFitnessComparator(!maximize);
		}
		// Return comparator
		return comparator;
	}

	/////////////////////////////////////////////////////////////////
	// ------------------------- Overwriting java.lang.Object methods
	/////////////////////////////////////////////////////////////////

	/**
	 * Equality test is based on function and maximize properties.
	 */
	
	public boolean equals(Object other)
	{
		if (other instanceof FuncOptEvaluator) {
			// Type conversion
			FuncOptEvaluator cother = (FuncOptEvaluator) other;
			// 
			EqualsBuilder eb = new EqualsBuilder();
			eb.append(function, cother.function);
			eb.append(maximize, cother.maximize);
			return eb.isEquals();
		}
		else {
			return false;
		}
	}
}