package ac.essex.ooechs.ecj.ecj2java.example.problems;

import ac.essex.ooechs.ecj.ecj2java.JavaWriter;
import ac.essex.ooechs.ecj.ecj2java.example.data.DoubleData;
import ec.EvolutionState;
import ec.Individual;
import ec.gp.GPIndividual;
import ec.gp.GPProblem;
import ec.gp.koza.KozaFitness;
import ec.simple.SimpleProblemForm;
import ec.util.Parameter;

import java.io.File;
import java.io.IOException;

/**
 * Uses GP to solve simple maths problems.
 * Note that you will have to change the paths specified so the Java
 * file can be saved properly.
 * <p/>
 * <p/>
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version,
 * provided that any use properly credits the author.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details at http://www.gnu.org
 * </p>
 *
 * @author Olly Oechsle, University of Essex, Date: 05-Sep-2006
 * @version 1.0
 */
public class MathsProblem extends GPProblem implements SimpleProblemForm {

    // CHANGE THESE SETTINGS ACCORDING TO YOUR PREFERENCES
    public static final String classPackage = "ac.essex.ooechs.ecj.ecj2java.example.individuals";
    public static final String outputDirectory = "/home/ooechs/Ecj2Java/src/ac/essex/ooechs/ecj/ecj2java/example/individuals/";
    // END SETTINGS

    public DoubleData input;

    public double x;
    public double y;

    public Object protoClone() throws CloneNotSupportedException {
        MathsProblem newobj = (MathsProblem) (super.protoClone());
        newobj.input = (DoubleData) (input.protoClone());
        return newobj;
    }

    public void setup(final EvolutionState state, final Parameter base) {

        // very important, remember this
        super.setup(state, base);

        // set up the input ( equally important if you don't want
        input = (DoubleData) state.parameters.getInstanceForParameterEq(base.push(P_DATA), null, DoubleData.class);
        input.setup(state, base.push(P_DATA));

    }

    int dotCount = 0;

    public void evaluate(final EvolutionState state, final Individual ind, final int threadnum) {

        // ensure we only evaluate the individual once
        if (!ind.evaluated) {

            float fitness = 0.0f;

            int TP = 0;

            // x and y are public variables so the GP nodes
            // have access to them outside this method.
            for (y = 0; y <= 50; y+=1) {
                for (x = 0; x <= 50; x+=1) {

                    // lets get the problem to work out the
                    // pythagoras equation. The code in this file
                    // may seem a little contrived - we already know
                    // the pythagoras equation! But if you were
                    // to feed your program results from the real world
                    // it may be able to find an equation to describe them
                    // that you didn't already know.
                    double expected = Math.sqrt((x * x) + (y * y));

                    // this is the code to run the individual
                    ((GPIndividual) ind).trees[0].child.eval(state, threadnum, input, stack, ((GPIndividual) ind), this);

                    // and get the individual's result
                    double received = input.x;

                    // add the difference to the expected value. Fitness of 0 is perfect.
                    fitness += Math.abs(expected - received);

                    // work out if it is "close enough" for a TP
                    if (isSimilarTo(expected, received, 0.05)) TP++;

                }
            }

            // convert to KozaFitness, which expects 0 as perfect fitness
            KozaFitness f = ((KozaFitness) ind.fitness);
            if (fitness == 1.0f) fitness = 0.0f;
            f.setStandardizedFitness(state, fitness);

            f.hits = TP;
            ind.evaluated = true;

            dotCount++;
            // only print out every 20th dot (save filling the screen with dots!)
            if (dotCount % 20 == 0) System.out.print(".");

        }
    }

    public boolean isSimilarTo(double number1, double number2, double threshold) {

        double difference = Math.abs(number1 - number2);

        return (difference / number1) < threshold;

    }

    static int counter = 0;

    public void describe(final Individual ind, final EvolutionState state, final int threadnum, final int log, final int verbosity) {

        state.output.println("\n\nBest Individual", verbosity, log);

        KozaFitness f = ((KozaFitness) ind.fitness);

        counter++;

        /**
         * Create a ECJ2Java Writer here, with the following parameters:
         */

        String className = "MathsSolution" + counter;
        String functionSignature = "public double calculate(double x, double y)";
        String comment = "Fitness: " + f.hits;
        JavaWriter writer = new JavaWriter(className, functionSignature, comment, classPackage);

        /**
         * Decide where the Java file is to be saved:
         */
        File saveTo = new File(outputDirectory);

        /**
         * Generate and save the file
         */
        try {
            writer.saveJavaCode((GPIndividual) ind, saveTo);
        } catch (IOException e) {
            e.printStackTrace();
        }

        /**
         * And that's all there is to it!
         */
        System.out.println("TP: " + f.hits);
        System.out.println("Total Error: " + f.standardizedFitness());

    }


}