package jcgp;

import java.util.HashMap;
import java.util.Random;

import javafx.beans.property.SimpleIntegerProperty;
import jcgp.modules.ea.EvolutionaryAlgorithm;
import jcgp.modules.ea.StandardEA;
import jcgp.modules.fitness.FitnessFunction;
import jcgp.modules.fitness.TestCase;
import jcgp.modules.fitness.TruthTableEvaluator;
import jcgp.modules.function.Arithmetic;
import jcgp.modules.function.BitwiseLogic;
import jcgp.modules.function.BooleanLogic;
import jcgp.modules.function.FunctionSet;
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.parameters.Parameters;
import jcgp.population.Population;

public class CGP {

	// CGP components
	private Mutator[] mutators = new Mutator[] {
			new PointMutator()};
	private Mutator mutator = mutators[0];
	
	private EvolutionaryAlgorithm[] evolutionaryAlgorithms = new EvolutionaryAlgorithm[] {
			new StandardEA()};
	private EvolutionaryAlgorithm evolutionaryAlgorithm = evolutionaryAlgorithms[0];
	
	private FitnessFunction[] fitnessFunctions = new FitnessFunction[] {
			new TruthTableEvaluator()};
	private FitnessFunction fitnessFunction = fitnessFunctions[0];

	private FunctionSet[] functionSets =  new FunctionSet[] {
			new FunctionSet("Arithmetic",
					new Arithmetic.Addition(),
					new Arithmetic.Subtraction(),
					new Arithmetic.Multiplication(),
					new Arithmetic.Division()),

			new FunctionSet("32-bit logic",
					new BitwiseLogic.And(), 
					new BitwiseLogic.Or(), 
					new BitwiseLogic.Nand(), 
					new BitwiseLogic.Nor(), 
					new BitwiseLogic.Xor(),
					new BitwiseLogic.Xnor(),
					new BitwiseLogic.Not()),

			new FunctionSet("1-bit logic",
					new BooleanLogic.And(), 
					new BooleanLogic.Or(), 
					new BooleanLogic.Nand(), 
					new BooleanLogic.Nor(), 
					new BooleanLogic.Xor(),
					new BooleanLogic.Xnor(),
					new BooleanLogic.Not())};

	
	
	private Population population;

	private static HashMap<String, Parameter> parameters = new HashMap<String, Parameter>();

	public CGP() {
		createBaseParameters();

		for (int i = 0; i < Parameters.getTotalGenerations(); i++) {
			
			((SimpleIntegerProperty) get("currentGen").getValue()).set(i);
			fitnessFunction.evaluate(population);
			evolutionaryAlgorithm.evolve(population, mutator);
			
			if (evolutionaryAlgorithm.getFittestChromosome().getFitness() >= 3) {
				break;
			}
		}	
	}

	private void createBaseParameters() {
		// make fundamental parameters
		parameters.put("rows", new IntegerParameter(3, "Rows"));
		parameters.put("columns", new IntegerParameter(3, "Columns"));
		parameters.put("inputs", new IntegerParameter(3, "Inputs"));
		parameters.put("outputs", new IntegerParameter(3, "Outputs"));
		parameters.put("popSize", new IntegerParameter(5, "Population"));
		
		parameters.put("nodes", new IntegerParameter(9, "", true, true));
		
		parameters.put("gens", new IntegerParameter(100, "Generations"));
		parameters.put("currentGen", new IntegerParameter(0, "Generation"));
		parameters.put("runs", new IntegerParameter(5, "Runs"));
		
		parameters.put("debug", new BooleanParameter(false, "Debug"));
	}

//	/**
//	 * 
//	 */
//	private void loadModules() {
//		// initialise function set
//		FunctionSet functionSet = new FunctionSet(new Arithmetic.Addition(), new Arithmetic.Subtraction(), new Arithmetic.Multiplication());
//		
//		// initialise utilities
//		Utilities.setResources(new Random(1234), functionSet);
//		
//		// initialise fitness function and truth table
//		TruthTable.setTestCases(new TestCase(new Object[] {2, 5, 4}, new Object[] {1, 10, 15}));
//		fitnessFunction = new TruthTableEvaluator();
//
//		// initialise EA
//		evolutionaryAlgorithm = new StandardEA();
//		mutator = new StandardMutator();
//		
//		// initialise population
//		population = new Population();
//	}
	
	// Parameter methods
	public static void registerParameter(String key, Parameter value) {
		parameters.put(key, value);
	}
	
	public static Parameter get(String key) {
		return parameters.get(key);
	}
	
	public static boolean contains(String key) {
		return parameters.containsKey(key);
	}
	
	// Utility methods
	
}