package Sequenic.T2ext.CoverageEngine.ga;

import java.util.LinkedList;
import java.util.List;
import java.util.Random;

import org.uncommons.watchmaker.framework.EvolutionaryOperator;

import Sequenic.T2.Engines.BaseEngine;
import Sequenic.T2.Engines.BaseEngineToolPlug;
import Sequenic.T2.Obj.Cloner;
import Sequenic.T2.Seq.CALL_METHOD;
import Sequenic.T2.Seq.CONST;
import Sequenic.T2.Seq.MkValStep;
import Sequenic.T2.Seq.ReportersPool;
import Sequenic.T2.Seq.Trace;
import Sequenic.T2.Seq.TraceStep;

/**
 * This is an EvolutionaryOperator that can mutate traces.
 * 
 * @author Christiaan Hees
 */
public class TraceMutation implements EvolutionaryOperator<Trace> {
	private Random rng;
	private String[] t2Args;
	
	public TraceMutation(String[] t2Args) {
		this.t2Args = t2Args;
	}
	
	/**
	 * Removes, adds and modifies steps from the selected traces.
	 * @see EvolutionaryOperator#apply(List, Random)
	 */
	@Override
	public <S extends Trace> List<S> apply(List<S> selectedCandidates, Random rng) {
		this.rng = rng;
		List<S> result = new LinkedList<S>();
		for(S trace : selectedCandidates) {
			// Clone the trace:
			try {
				trace = Cloner.clone(trace);
			} catch (Exception e) {
				System.out.println("Failed to clone trace "+trace);
				e.printStackTrace();
				System.exit(1);
			}
			
			// Mutate it:
			removeStep(trace);
			insertStep(trace);
			changeParams(trace);
			
			// TODO crossover?
			
			result.add(trace);
		}
		return result;
	}
	
	/**
	 * Possibly removes a single step in a random position from the trace.
	 * The object creation step is never removed.
	 */
	private void removeStep(Trace t) {
		// TODO tweak probability
		if(t.trace.size() <= 0 || rng.nextFloat() > 0.2) {
			return;
		}
		//System.out.println("DEBUG: removing a step from the trace");
		t.trace.remove(rng.nextInt(t.trace.size()));
		// FIXME recalculate REFs
	}
	
	/**
	 * Possibly adds a single random step in a random position to the trace.
	 */
	private void insertStep(Trace t) {
		// TODO tweak probability
		if(rng.nextFloat() > 0.8) {
			return;
		}
		
		BaseEngine engine = prepareEngine();
		
		int newStepPos = 0;
		if(t.trace.size() > 0) newStepPos = rng.nextInt(t.trace.size());
		
		// Remove the steps past the insertion point and save them for later:
		LinkedList<TraceStep> postSteps = new LinkedList<TraceStep>();
		for(int i=newStepPos; i<t.trace.size(); i++) {
			postSteps.add(t.trace.get(newStepPos));
			t.trace.remove(newStepPos);
		}
		
		// Execute the partial trace:
		// TODO check if these parameters are correct
		t.exec(engine.CUT, engine.pool, engine.allClassINVs, t.diverging, false, ReportersPool.NULLreporter);
		
		// Save the pool size to update the REFs later:
		int poolSize = engine.pool.get_objectCount();
		
		// Generate a new step, execute and add it:
		TraceStep newStep = engine.seqGenerator.META_mkTestStep(t);
		if(newStep != null) {
			//System.out.println("DEBUG newStep: "+newStep);
			// TODO check if these parameters are correct
			newStep.exec(engine.CUT,
					engine.pool,
					engine.pool.get(t.indexOfTargetObj),
					t.trace.size() + 1,
					engine.allClassINVs);
			t.trace.add(newStep);
		}
		
		// Now update the REFs in the the post steps and add them again:
		int refDiff = engine.pool.get_objectCount() - poolSize;
		for(TraceStep s : postSteps) {
			// TODO update REFs
			//System.out.println("DEBUG postStep might need REF fixing?: "+s);
		}
		t.trace.addAll(postSteps);
	}
	
	/**
	 * Possibly changes the parameters of single method call.
	 */
	private void changeParams(Trace t) {
		// TODO tweak probability
		if(t.trace.size() <= 0 || rng.nextFloat() > 0.04) {
			return;
		}
		
		BaseEngine engine = prepareEngine();
		
		TraceStep s = t.trace.get(rng.nextInt(t.trace.size()));
		if(s instanceof CALL_METHOD) {
			for(MkValStep param : ((CALL_METHOD)s).params) {
				if(param instanceof CONST) {
					// For now only change the CONST of a CALL_METHOD:
					//System.out.print("DEBUG changing "+param+" to ");
					param = engine.META_mkObject(((CONST)param).val.getClass(), 0, false);
					//System.out.println(param);
				}
			}
		}
	}
	
	/**
	 * Configures a BaseEngine using the original arguments passed to T2.
	 */
	private BaseEngine prepareEngine() {
		BaseEngineToolPlug toolPlug = new BaseEngineToolPlug();
		try {
			toolPlug.configure(t2Args);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return toolPlug.getBaseEngine();
		// TODO configure the engine to allow more steps and things like that?
	}
}