package ac.essex.ooechs.ecj.ecj2java.nodes;

import ec.gp.*;
import ec.EvolutionState;
import ec.Problem;
import ec.util.Code;
import ec.util.DecodeReturn;

import java.io.DataInput;
import java.io.IOException;
import java.io.DataOutput;

// If you have downloaded ECJ2Java, you'll need to change this
// to your own DoubleData class that you use. There is an example
// of such a class in ac.essex.ooechs.ecj.ecj2java.example.data
import ac.essex.ooechs.ecj.commons.data.DoubleData;
//import ac.essex.ooechs.ecj.ecj2java.example.data.DoubleData;


/**
 * <p>
 * ParseableERC is an adapter class that serves two functions:
 * <ol>
 * <li>It allows ECJ2Java to write the ERC into pure java</li>
 * <li>It makes ERCs easier to code</li>
 * </ol>
 * </p>
 *
 * <p>
 * It adapts a number of unpleasant methods in the ERC class that don't
 * need to be altered often (if at all).
 * </p>
 *
 * <p>
 * It implements the functionality required by ParseableNode which allows
 * the node to be converted into pure java.
 * </p>
 *
 * <p>
 * Implementation is easy - just take your existing ERC and extend
 * ParseableERC instead of ERC. The only required methods are setNumber()
 * and name().
 * </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: 06-Sep-2006
 * @version 1.0
 */
public abstract class ParseableERC extends ERC implements ParseableNode {

    protected int type = ParseableNode.ERC;
    protected double value;

    /**
     * Set the value of the ERC here
     */
    public abstract double setNumber(final EvolutionState state, final int thread);

    /**
     * Mutates the node's "value".  This is called by mutating operators
     * which specifically <i>mutate</i> the "value" of ERCs, as opposed to
     * replacing them with whole new ERCs. The default form of this function
     * simply calls resetNode(state,thread), but you might want to modify
     * this to do a specialized form of mutation, applying gaussian
     * noise for example.
     */
    public void mutateERC(final EvolutionState state, final int thread) {
        // move the value within +- 25% of its original position
        value *= 1 + ((Math.random() * 0.5) - 0.25);
    }

    /**
     * The name of the class that ECK uses.
     */
    public abstract String name();

    public ParseableNode getChild(int index) {
        return (ParseableNode) children[index];
    }

    public int getType() {
        return type;
    }

    public String getValue() {
        return String.valueOf(value);
    }

    public void setValue(double value) {
        this.value = value;
    }

    public int countChildren() { return 0; }

    String variableName;

    /**
     * When the java writer uses this node, it may use a variable name to describe it.
     */
    public String getVariableName() {
        return variableName;
    }
    /**
     * Attaches a variable name to this node, used by JavaWriter
     */
    public void setVariableName(String name) {
        this.variableName = name;
    }

    public String getJavaCode() {
        switch (getObjectType()) {
            case DOUBLE:
                return String.valueOf(value);
            case BOOLEAN:
                return value == 1 ? "true" : "false";
            case INT:
                return String.valueOf((int) value);
            default:
                // should not get here
                System.err.println("Missing type in ParseableERC, getJavaCode: " + getObjectType() + ", " + getClass());
                return getValue();
        }
    }

    public String getLineComment() {
        return null;
    }

    public void setType(int type) {
        this.type = type;
    }

    // ECJ ERC stuff below
    // This is all pretty much boilerplate code and you'll rarely need to look at it,
    // much less repeat it in every ERC class you write!

    public void resetNode(final EvolutionState state, final int thread) {
        value = setNumber(state, thread);
    }

    public boolean nodeEquals(final GPNode node) {
        // check first to see if we're the same kind of ERC --
        // won't work for subclasses; in that case you'll need
        // to change this to isAssignableTo(...)
        if (this.getClass() != node.getClass()) return false;
        // now check to see if the ERCs hold the same value
        return (((ParseableERC) node).value == value);
    }

    public void readNode(final EvolutionState state, final DataInput dataInput) throws IOException {
        value = dataInput.readDouble();
    }

    public void writeNode(final EvolutionState state, final DataOutput dataOutput) throws IOException {
        dataOutput.writeDouble(value);
    }

    public String encode() {
        return Code.encode(value);
    }

    public boolean decode(DecodeReturn dret) {
        // store the position and the string in case they
        // get modified by Code.java
        int pos = dret.pos;
        String data = dret.data;

        // decode
        Code.decode(dret);

        if (dret.type != DecodeReturn.T_DOUBLE) // uh oh!
        {
            // restore the position and the string; it was an error
            dret.data = data;
            dret.pos = pos;
            return false;
        }

        // store the data
        value = dret.d;
        return true;
    }

    public String toStringForHumans() {
        return "" + value;
    }

    public void eval(final EvolutionState state, final int thread, final GPData input, final ADFStack stack, final GPIndividual individual, final Problem problem) {
        DoubleData rd = ((DoubleData) (input));
        rd.x = value;
    }

    public int nodeHashCode() {
        // a reasonable hash code
        return this.getClass().hashCode() + Float.floatToIntBits((float) value);
    }

}