package jcgp;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Random;

import javafx.beans.property.SimpleIntegerProperty;
import jcgp.function.Arithmetic;
import jcgp.function.BitwiseLogic;
import jcgp.function.BooleanLogic;
import jcgp.function.Function;
import jcgp.function.FunctionSet;
import jcgp.modules.ea.EvolutionaryAlgorithm;
import jcgp.modules.ea.MuPlusLambda;
import jcgp.modules.ea.TournamentSelection;
import jcgp.modules.fitness.FitnessFunction;
import jcgp.modules.fitness.TestCase;
import jcgp.modules.fitness.TestCaseEvaluator;
import jcgp.modules.mutator.Mutator;
import jcgp.modules.mutator.PointMutator;
import jcgp.parameters.BooleanParameter;
import jcgp.parameters.DoubleParameter;
import jcgp.parameters.IntegerParameter;
import jcgp.parameters.Parameter;
import jcgp.population.Population;

/**
 * @author Eduardo Pedroni
 *
 */
public class JCGP {

	/**
	 * 
	 * 
	 * @author Eduardo Pedroni
	 *
	 */
	public static class Resources {
		private HashMap<String, Parameter> parameters = new HashMap<String, Parameter>();

		private Random numberGenerator;
		
		private TestCase[] testCases;
		
		// function sets
		private FunctionSet[] functionSets =  new FunctionSet[] {
				new Arithmetic(),
				new BitwiseLogic(),
				new BooleanLogic() };
		private FunctionSet functionSet = functionSets[0];
		
		public Resources() {
			createCoreParameters();
			
			numberGenerator = new Random(getInt("seed"));
			set("arity", functionSet.getMaxArity());
		}
		
		public int getInt(String key) {
			if (parameters.get(key) instanceof IntegerParameter) {
				return ((IntegerParameter) parameters.get(key)).get();
			} else if (parameters.get(key) instanceof DoubleParameter) {
				return (int) ((DoubleParameter) parameters.get(key)).get();
			} else {
				throw new ClassCastException("Could not cast " + parameters.get(key).getClass() + " to int.");
			}
		}
		
		public double getDouble(String key) {
			if (parameters.get(key) instanceof IntegerParameter) {
				return (double) ((IntegerParameter) parameters.get(key)).get();
			} else if (parameters.get(key) instanceof DoubleParameter) {
				return ((DoubleParameter) parameters.get(key)).get();
			} else {
				throw new ClassCastException("Could not cast " + parameters.get(key).getClass() + " to double.");
			}
		}
		
		public boolean getBoolean(String key) {
			if (parameters.get(key) instanceof BooleanParameter) {
				return ((BooleanParameter) parameters.get(key)).get();
			} else {
				throw new ClassCastException("Could not cast " + parameters.get(key).getClass() + " to int.");
			}
		}
		
		public void set(String key, Object value) {
			if (parameters.get(key) instanceof IntegerParameter) {
				((IntegerParameter) parameters.get(key)).set(((Integer) value).intValue());
			} else if (parameters.get(key) instanceof DoubleParameter) {
				((DoubleParameter) parameters.get(key)).set(((Double) value).doubleValue());
			} else if (parameters.get(key) instanceof BooleanParameter) {
				((BooleanParameter) parameters.get(key)).set(((Boolean) value).booleanValue());
			}
		}
		
		public Parameter getParameter(String key) {
			return parameters.get(key);
		}
		
		public boolean contains(String key) {
			return parameters.containsKey(key);
		}
		
		private void createCoreParameters() {
			parameters.put("rows", new IntegerParameter(8, "Rows"));
			parameters.put("columns", new IntegerParameter(9, "Columns"));
			parameters.put("inputs", new IntegerParameter(3, "Inputs"));
			parameters.put("outputs", new IntegerParameter(3, "Outputs"));
			parameters.put("popSize", new IntegerParameter(5, "Population"));
			parameters.put("levelsBack", new IntegerParameter(2, "Levels back"));
			
			IntegerParameter nodes = new IntegerParameter(1, "Nodes", false, true);
			nodes.valueProperty().bind(((SimpleIntegerProperty) ((IntegerParameter) parameters.get("rows")).valueProperty()).multiply((SimpleIntegerProperty) ((IntegerParameter) parameters.get("columns")).valueProperty()));
			parameters.put("nodes", nodes);
						
			parameters.put("generations", new IntegerParameter(1000000, "Generations"));
			parameters.put("currentGen", new IntegerParameter(1, "Generation", false, false));
			
			parameters.put("runs", new IntegerParameter(5, "Runs"));
			parameters.put("currentRun", new IntegerParameter(1, "Run", false, false));

			parameters.put("arity", new IntegerParameter(0, "Max arity", true, true));
			parameters.put("seed", new IntegerParameter(123, "Seed"));
			
			parameters.put("verbose", new BooleanParameter(false, "Verbose"));
			parameters.put("report", new IntegerParameter(1, "Report"));
		}
		
		/**
		 * 
		 * 
		 * @return the iterator for the set of base parameters
		 */
		public Iterator<Entry<String, Parameter>> iterator() {
			return parameters.entrySet().iterator();
		}
		
		/*
		 * Utility functions
		 */
		public int getRandomInt(int limit) {
			return numberGenerator.nextInt(limit);
		}
		
		public double getRandomDouble(int limit) {
			return numberGenerator.nextDouble() * limit;
		}
		
		public double getRandomDouble() {
			return numberGenerator.nextDouble();
		}
		
		/*
		 * FunctionSet functions
		 */
		public Function getRandomFunction() {
			return functionSet.getAllowedFunction(numberGenerator.nextInt(functionSet.getAllowedFunctionCount()));
		}

		public Function getFunction(int index) {
			return functionSet.getAllowedFunction(index);
		}
		
		public void setFunctionSet(int index) {
			functionSet = functionSets[index];
		}
		
		/**
		 * @return the functionSets
		 */
		public FunctionSet[] getFunctionSets() {
			return functionSets;
		}

		/**
		 * @return the functionSet
		 */
		public FunctionSet getFunctionSet() {
			return functionSet;
		}
		
		/*
		 * Test cases
		 */
		public void setTestCases(TestCase ... testCases) {
			this.testCases = testCases;
		}

		public TestCase getTestCase(int index) {
			return testCases[index];
		}

		public int getTestCaseCount() {
			return testCases.length;
		}
	}
	
	private Resources resources = new Resources();
	
	/*
	 * The following arrays contain all available modules. These collections are read by the GUI
	 * when generating menus, so modules not added here will *NOT* be selectable in the GUI.
	 * 
	 * Each array is accompanied by a field which contains a reference to the currently selected
	 * module, 0 by default.
	 */
	// mutators
	private Mutator[] mutators = new Mutator[] {
			new PointMutator() };
	private Mutator mutator;
	
	// evolutionary algorithms
	private EvolutionaryAlgorithm[] evolutionaryAlgorithms = new EvolutionaryAlgorithm[] {
			new MuPlusLambda(),
			new TournamentSelection()};
	private EvolutionaryAlgorithm evolutionaryAlgorithm;
	
	// fitness evaluators
	private FitnessFunction[] fitnessFunctions = new FitnessFunction[] {
			new TestCaseEvaluator() };
	private FitnessFunction fitnessFunction;

	/*
	 * the population of chromosomes
	 */
	private Population population;
	
	public JCGP() {
		
		population = new Population(resources);

		evolutionaryAlgorithm = evolutionaryAlgorithms[0];
		
		mutator = mutators[0];
		
		fitnessFunction = fitnessFunctions[0];
		
		resources.setTestCases(new TestCase(new Integer[]{1, 2, 3}, new Integer[]{4, 5, 6}),
							   new TestCase(new Integer[]{1, 12, 4}, new Integer[]{6, 21, 2}));
//		for (int i = 0; i < (int) resources.get("generations"); i++) {
//			
//			resources.set("currentGen", ((int) resources.get("currentGen")) + 1);
//			
//			fitnessFunction.evaluate(population, resources);
//			evolutionaryAlgorithm.evolve(population, mutator, resources);
//			
//			System.out.println("fitness: " + evolutionaryAlgorithm.getFittestChromosome().getFitness());
//			
//			if (evolutionaryAlgorithm.getFittestChromosome().getFitness() >= 6) {
//				System.out.println("solution found");
//				evolutionaryAlgorithm.getFittestChromosome().printNodes();
//				break;
//			}
//		}	
	}


	public Resources getResources() {
		return resources;
	}


	public Population getPopulation() {
		return population;
	}


	/**
	 * @return the mutators
	 */
	public Mutator[] getMutators() {
		return mutators;
	}


	/**
	 * @return the mutator
	 */
	public Mutator getMutator() {
		return mutator;
	}


	/**
	 * @return the evolutionaryAlgorithms
	 */
	public EvolutionaryAlgorithm[] getEvolutionaryAlgorithms() {
		return evolutionaryAlgorithms;
	}


	/**
	 * @return the evolutionaryAlgorithm
	 */
	public EvolutionaryAlgorithm getEvolutionaryAlgorithm() {
		return evolutionaryAlgorithm;
	}


	/**
	 * @return the fitnessFunctions
	 */
	public FitnessFunction[] getFitnessFunctions() {
		return fitnessFunctions;
	}


	/**
	 * @return the fitnessFunction
	 */
	public FitnessFunction getFitnessFunction() {
		return fitnessFunction;
	}
	
	
	/**
	 * @param mutator the mutator to set
	 */
	public void setMutator(int index) {
		this.mutator = mutators[index];
	}


	/**
	 * @param evolutionaryAlgorithm the evolutionaryAlgorithm to set
	 */
	public void setEvolutionaryAlgorithm(int index) {		
		this.evolutionaryAlgorithm = evolutionaryAlgorithms[index];
	}


	/**
	 * @param fitnessFunction the fitnessFunction to set
	 */
	public void setFitnessFunction(int index) {
		this.fitnessFunction = fitnessFunctions[index];
	}
	
	public void nextGeneration() {
		resources.set("currentGen", resources.getInt("currentGen") + 1);
		
		fitnessFunction.evaluate(population, resources);
		evolutionaryAlgorithm.evolve(population, mutator, resources);
		
		if (evolutionaryAlgorithm.getFittestChromosome().getFitness() >= 6) {
			System.out.println("solution found");
			evolutionaryAlgorithm.getFittestChromosome().printNodes();
		} else {
			System.out.println("Generation: " + resources.getInt("currentGen") + ", fitness: " + evolutionaryAlgorithm.getFittestChromosome().getFitness());
		}
	}
	
	public void start() {		
		while (resources.getInt("currentGen") <= resources.getInt("generations")) {
			nextGeneration();
		}
		// TODO print something?
	}
}