package fr.lifl.stc.stan.implicitFlow.execution;

import java.util.HashMap;

import org.apache.bcel.generic.Select;
import org.apache.bcel.generic.BranchInstruction;
import org.apache.bcel.generic.ExceptionThrower;
import org.apache.bcel.generic.Instruction;
import org.apache.bcel.generic.InstructionHandle;

import fr.lifl.stc.stan.analyser.MethodAnalyzer;
import fr.lifl.stc.stan.implicitFlow.ImplicitDependences;
import fr.lifl.stc.stan.implicitFlow.data.BooleanExpression;
import fr.lifl.stc.stan.implicitFlow.data.BooleanVariable;
import fr.lifl.stc.stan.implicitFlow.execution.InstructionTypeIF;

/**
 * 
 * @author dorina
 *
 */

public class InterpreterIF {
	
	MethodAnalyzer analyzer;
	
	MethodInfoIF meth;
	
	BooleanVariable[] conditions;
	
	ImplicitDependences deps;
	
	/**
	 * 
	 * @param analyzer
	 */
	public InterpreterIF(MethodAnalyzer analyzer) {
		this.analyzer = analyzer;
		
		meth = analyzer.getMethodInfoIF();
		
		conditions = meth.getConditions();
		
		deps = analyzer.getImplicitDeps();
	}
	
	/**
	 * 
	 * @param line
	 * @return
	 */
	public BooleanVariable getCondition(int line){
		for(int i = 0; i < conditions.length; i++)
			if(conditions[i].getLine() == line)
				return conditions[i];
		System.err.println("line "+line+" is not a conditional bytecode!");
		return null;
	}
	
	/**
	 * 
	 * @param line
	 * @param switch_ind
	 * @return
	 */
	public BooleanVariable getCondition(int line, int switch_ind){
		for(int i = 0; i < conditions.length; i++)
			if(conditions[i].getLine() == line && conditions[i].getSwitchInd() == switch_ind)
				return conditions[i];
		System.err.println("line "+line+" is not a conditional bytecode!");
		return null;
	}
	
	/**
	 * 
	 * @return
	 */
	public InstructionHandle getStart() {
		return meth.firstInstruction();
	}
	
	/**
	 * 
	 * @param ih
	 * @return
	 */
	public HashMap<InstructionHandle, BooleanExpression> getNextInstructions(InstructionHandle ih) {
		HashMap<InstructionHandle,BooleanExpression> list;
		BranchInstruction branch;
		InstructionTypeIF type;
		Instruction inst = ih.getInstruction();
		
		list = new HashMap<InstructionHandle,BooleanExpression>();
		type = InstructionTypeIF.getType(inst);        
		
		if (type == InstructionTypeIF.CONDITIONAL_INSTRUCTION)
		{
			branch = (BranchInstruction) (inst);
			list.put(branch.getTarget(), new BooleanExpression(getCondition(ih.getPosition())));
			list.put(ih.getNext(), new BooleanExpression( getCondition(ih.getPosition()).getNegation()));
		} 	
		else if (type == InstructionTypeIF.TABLESWITCH_INSTRUCTION) {
			InstructionHandle targets[];
			targets = ((Select) (inst)).getTargets();
			
			BooleanExpression default_expression = new BooleanExpression();
			BooleanVariable tmp;
			for (int i = 0; i <targets.length ; i++) {
				tmp = this.getCondition(ih.getPosition(),i);
				list.put(targets[i], new BooleanExpression(tmp));
				default_expression.or(new BooleanExpression(tmp.getNegation()), false);
			}
			
			list.put(((Select) inst).getTarget(), default_expression);
		} 
		else if (type == InstructionTypeIF.LOOKUPSWITCH_INSTRUCTION) {
			InstructionHandle targets[];
			targets = ((Select) (inst)).getTargets();
			
			BooleanExpression b; 
			BooleanExpression tmp[] =  new BooleanExpression[targets.length+1];
			for (int i = 0; i <targets.length ; i++) 
				tmp[i] = new BooleanExpression(this.getCondition(ih.getPosition(),i));
			tmp[targets.length] = new BooleanExpression(BooleanVariable.condition_true);
			for (int i = 0; i <targets.length ; i++) {
				b = new BooleanExpression(this.getCondition(ih.getPosition(),i).getNegation());
				for(int j = i+1; j < targets.length+1; j++)
					tmp[j].and(b, false);
			}
			
			for (int i = 0; i <targets.length ; i++)
				list.put(targets[i], tmp[i]);
			list.put(((Select) inst).getTarget(), tmp[targets.length]);
		}
		
		else if (type == InstructionTypeIF.GOTO_INSTRUCTION) {
			branch = (BranchInstruction) (inst);
			list.put(branch.getTarget(), BooleanExpression.expression_true);
		}
		else if (type == InstructionTypeIF.JSR_INSTRUCTION) {
			branch = (BranchInstruction) (inst);
			list.put(branch.getTarget(), BooleanExpression.expression_true);
		} else if (type == InstructionTypeIF.RET_INSTRUCTION) {
			//FIXME
			/*
			 RET r = (RET)inst;
			 JvmType[] pc = (JvmType[])o.content();
			 for(int i = 0; i < pc.length; i++) {
			 Address a = (Address)pc[i];
			 System.out.println("-----------RERRRRRRT i = "+i+"  type = "+pc[i].getJvmType()+"  address = "+a.getPc());
			 list.add(meth.getInstruction(a.getPc()));
			 }
			 */
			
			/* 	Address[] pc = (Address[])o.content();
			 for(int i = 0; i < pc.length; i++) {
			 list.add(meth.getInstruction(pc[i].getPc()));
			 }
			 */
		} 
		else if (type == InstructionTypeIF.THROW_INSTRUCTION) {
			InstructionHandle[] except = meth.getRealExceptionHandlers(ih);
			for(int i = 0; i < except.length; i++) {
				list.put(except[i], BooleanExpression.expression_true);
			}
			
		}
		else  if (type == InstructionTypeIF.RETURN_INSTRUCTION) 
			;	
		else  if (type == InstructionTypeIF.NORMAL_INSTRUCTION) 
			list.put(ih.getNext(), BooleanExpression.expression_true);		
		
		return list;
	}
	
	
	/**
	 * 
	 * @param ih
	 * @return
	 */
	public HashMap<InstructionHandle, BooleanExpression> getNextExceptionHandlers(InstructionHandle ih) {
		HashMap<InstructionHandle,BooleanExpression> list = new HashMap<InstructionHandle,BooleanExpression>();
		
		if(ih.getInstruction() instanceof ExceptionThrower 
				//|| ih.getInstruction() instanceof ATHROW
		) {
			InstructionHandle ihs[] = meth.getRealExceptionHandlers(ih);
			for(int i = 0; i < ihs.length; i++) {
				//FIXME add 
				list.put(ihs[i], BooleanExpression.expression_true);
			}
		}
		return list;
	}
	
	
	/**
	 * computes the new f(current);
	 * f(next) = f(next) + b * f(current)
	 */
	public boolean abstractExecutionStep(InstructionHandle current, InstructionHandle next, BooleanExpression b) {
		
		boolean modif = false;
		int nextPos = next.getPosition();
		BooleanExpression old = deps.getBooleanExpression(nextPos);
		
		BooleanExpression tmp = new BooleanExpression(deps.getBooleanExpression(current.getPosition()));
		
		tmp.and(b, false);
		
		//BooleanExpression old = deps.getBooleanExpression(nextPos);
		tmp.or(old, false);
		
		if( !(old.isFalse() && (b.isTrue() || b.size()==1))) 
		{
			tmp.simplify();
		}
		
		if(tmp.greaterThan(old)){
			modif = true;
			deps.set(nextPos, tmp);
		}
		
		return modif;
	}
	
	
	
}