package ac.essex.ecj.problems;

import ec.gp.GPProblem;
import ec.gp.GPIndividual;
import ec.gp.koza.KozaFitness;
import ec.simple.SimpleProblemForm;
import ec.EvolutionState;
import ec.Individual;
import ec.util.Parameter;
import ac.essex.ecj.imaging.PixelLoader;
import ac.essex.ecj.util.TrainingData;
import ac.essex.ecj.util.Counter;
import ac.essex.ecj.data.DoubleData;
import ac.essex.ecj.fitness.FitnessCalculator;

import java.util.Vector;
import java.text.DecimalFormat;

/**
 * <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: 17-Aug-2006
 * @version 1.0
 */
public class PixelProblem extends GPProblem implements SimpleProblemForm {

    public static final String SAVE_RESULTS_TO = "/home/ooechs/ECJ_Tutorial/results/";
    public static final String TRAINING_DIRECTORY = "/home/ooechs/ECJ_Tutorial/data/";


    /**
     * Make the image publicly accessible here. One of the hard things in ECJ is
     * passing references around, because you have to override functions with
     * fixed signatures. Each node does get passed a reference of this Problem
     * object, so all its public members will be accessible to the nodes.
     * <p/>
     * The PixelLoader is a Java class that allows us to access raw PixelData from
     * an image.
     */
    public PixelLoader image;

    /**
     * References to the current location on the image where the GP program is to be run.
     */
    public int x, y;

    /**
     * This Vector will hold all the Training Data.
     */
    Vector<TrainingData> trainingData;

    /**
     * An instance of the data object that passes information between nodes in the tree.
     */
    public DoubleData input;

    /**
     * Remember when we started. Evaluation time is an important consideration in GP.
     */
    private long startTime;

    public void setup(EvolutionState state, Parameter base) {

        // Essential, do not forget this line!
        super.setup(state, base);

        // set up the input, also essential if you don't like NullPointerExceptions
        input = (DoubleData) state.parameters.getInstanceForParameterEq(base.push(P_DATA), null, DoubleData.class);
        input.setup(state, base.push(P_DATA));

        // Initialise the training data
        trainingData = new Vector<TrainingData>(100);

        try {

            PixelLoader testImage = new PixelLoader(TRAINING_DIRECTORY + "test.bmp");
            PixelLoader truthImage = new PixelLoader(TRAINING_DIRECTORY + "truth.bmp");

            trainingData.add(new TrainingData(testImage, truthImage));

            System.out.println("Loaded " + trainingData.size() + " test images.");

            startTime = System.currentTimeMillis();

        } catch (Exception e) {
            System.out.println("Could not load training data.");
            System.exit(1);
        }

    }

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

        /**
         * The individual's fitness will be its worst fitness value. This will reward
         * generalists.
         */
        float overallFitness = -1;

        int hits = 0;

        /**
         * Loop through each training data set
         */
        for (int i = 0; i < trainingData.size(); i++) {
            TrainingData data = trainingData.elementAt(i);

            /**
             * Give the GP individuals access to the image by
             * putting a reference to it in the publicly available
             * "image" member of the problem class.
             */
            this.image = data.image;

            /**
             * These are the statistics that we're intereted in measuring
             * We'll pass these to the fitnes calculator which will give us
             * a metric as to how good the individual is.
             */
            int TP = 0;
            int FP = 0;
            int totalTruePixels = 0;

            /**
             * Loop through every pixel on the image, evaluate the program on that
             * pixel and then decide if it was right or wrong.
             */
            for (int y = 1; y < data.image.getHeight() - 1; y++)
                for (int x = 1; x < data.image.getWidth() - 1; x++) {

                    /**
                     * Like the image, give the GP inviduals access to
                     * where we are on the image by putting X and Y into
                     * the publicly available members on this Problem class
                     */
                    this.x = x;
                    this.y = y;

                    /**
                     * A particularly vile instance of ECJ boilerplate, used to evaluate the individual.
                     */
                    ((GPIndividual) ind).trees[0].child.eval(state, threadnum, input, stack, ((GPIndividual) ind), this);

                    /**
                     * In a binary classification output, we say that positive values equate to a "yes"
                     * and negative values to a "no"
                     */
                    boolean result = input.value > 0;

                    if (data.isExpected(x, y)) {

                        totalTruePixels++;

                        if (result) {
                            TP++;
                            hits++;
                        }

                    } else {

                        if (result) FP++;

                    }

                }

            /**
             * Okay, we've evaluated the whole image; it's time to calculate the thisFitness
             */
            float thisFitness = FitnessCalculator.getKozaFitness(TP, FP, totalTruePixels);

            /**
             * Only take the lowest fitness
             */
            if (overallFitness == -1 || thisFitness < overallFitness) {
                overallFitness = thisFitness;
            }

        }


        overallFitness = FitnessCalculator.createKozaFitness(overallFitness);

        KozaFitness f = ((KozaFitness) ind.fitness);
        f.setStandardizedFitness(state, overallFitness);
        f.hits = hits;
        ind.evaluated = true;

        // print out a dot, so anybody looking knows ECJ is alive.
        System.out.print(".");

    }

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

        System.out.println("\nBEST INDIVIDUAL'S STATISTICS:");

        DecimalFormat formatter = new DecimalFormat("0.00");

        // This counts which generation we're on.
        Counter.counter++;

        try {

            /**
             * The individual's fitness will be its worst fitness value. This will reward
             * generalists.
             */
            float overallFitness = -1;

            int hits = 0;

            /**
             * Loop through each training data set
             */
            for (int i = 0; i < trainingData.size(); i++) {
                TrainingData data = trainingData.elementAt(i);

                /**
                 * Give the GP individuals access to the image by
                 * putting a reference to it in the publicly available
                 * "image" member of the problem class.
                 */
                this.image = data.image;

                PixelLoader copy = new PixelLoader(image.getFile());

                /**
                 * These are the statistics that we're intereted in measuring
                 * We'll pass these to the fitnes calculator which will give us
                 * a metric as to how good the individual is.
                 */
                int TP = 0;
                int FP = 0;
                int TN = 0;

                int totalTruePixels = 0;
                int totalFalsePixels = 0;

                /**
                 * Loop through every pixel on the image, evaluate the program on that
                 * pixel and then decide if it was right or wrong.
                 */
                for (int y = 1; y < data.image.getHeight() - 1; y++)
                    for (int x = 1; x < data.image.getWidth() - 1; x++) {

                        /**
                         * Like the image, give the GP inviduals access to
                         * where we are on the image by putting X and Y into
                         * the publicly available members on this Problem class
                         */
                        this.x = x;
                        this.y = y;

                        /**
                         * A particularly vile instance of ECJ boilerplate, used to evaluate the individual.
                         */
                        ((GPIndividual) ind).trees[0].child.eval(state, threadnum, input, stack, ((GPIndividual) ind), this);

                        /**
                         * In a binary classification output, we say that positive values equate to a "yes"
                         * and negative values to a "no"
                         */
                        boolean result = input.value > 0;

                        copy.setPixel(x, y , 0);

                        if (data.isExpected(x, y)) {

                            totalTruePixels++;

                            if (result) {
                                TP++;
                                hits++;
                                copy.setPixelBlue(x, y);
                            }

                        } else {

                            totalFalsePixels++;

                            if (result) {
                                FP++;
                                copy.setPixelRed(x, y);
                            } else {
                                TN++;
                            }

                        }

                    }

                /** Save the copy **/
                copy.save(SAVE_RESULTS_TO + "results_gen" + Counter.getCounterNumber() + "_class " + i + ".bmp");

                /**
                 * Okay, we've evaluated the whole image; it's time to calculate the thisFitness
                 */
                float thisFitness = FitnessCalculator.getKozaFitness(TP, FP, totalTruePixels);

                /**
                 * Only take the lowest fitness
                 */
                if (overallFitness == -1 || thisFitness < overallFitness) {
                    overallFitness = thisFitness;
                }

                /**
                 * Work out sensitivity and specificity
                 */
                double sensitivity = TP / (double) totalTruePixels;
                double specificity = TN / (double) totalFalsePixels;
                System.out.println("TP (Sensitivity) : " + sensitivity);
                System.out.println("TN (Specificity) : " + specificity);


            }

            overallFitness = FitnessCalculator.createKozaFitness(overallFitness);

            System.out.println("Overall Fitness: " + formatter.format(overallFitness) + ", hits: " + hits);
            System.out.println("Saved results as: results_gen" + Counter.getCounterNumber() + "_class[n].bmp");
            System.out.println("Total Time So Far: " + ((System.currentTimeMillis() - startTime) / 1000) + " seconds");
            System.out.println();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}