package objects;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.math.*;

import com.sun.org.apache.bcel.internal.Constants;

import utilities.*;

public class Agent {
	boolean deceiver = false;
	private double[][] train_story;
	private double[][] testTrue_story;
	private double[][] testFalse_story;
	private double[][] shift_story;
	private double[][] random_story;
	private double[][] wrong_story;
	private double[][] change_story;
	private double[][] true_story;
	private double[][][] rv_dependency;
	private double[][] rv_correlation;
	Graph priorknowledge;
	//String bkb_name;
	String name;
	public int goal_state;
	public int goal_handle;
	boolean storyinited = false;
	String graph_name;
	double binary_threshold;
	
	double uncertaintyThreshold;
	double irrelevancyThreshold;
	int[] commonality;
	int[] uncommonality;
	String contribution_f;
	
	public Agent(boolean deceiver, String graph_n, String name) {
		this.deceiver = deceiver;
		priorknowledge = new Graph();
		System.err.println("reading "+graph_n);
		priorknowledge.readNetFile(graph_n);
		this.graph_name = graph_n;
		this.name = name;
		
		//bkb_name = BKB_engine.loadBN(graph_n);
		//initStories(runs);
	}
	
	/*public void setBKBName(String name){
		bkb_name = name;
	}*/
	
	public void setUncertaintyThreshold(double value) {
		uncertaintyThreshold = value;
	}
	
	public void setIrrelevancyThreshold(double value) {
		irrelevancyThreshold = value;
	}
	
	public void setCommonality(int[] value) {
		commonality = value.clone();
	}
	
	public void setUncommonality(int[] value) {
		uncommonality = value.clone();
	}
	
	public void setContributionFilesName(String name) {
		contribution_f = name;
	}
	
	public String getName() {
		return name;
	}
	
	public boolean isDeceiver() {
		if (this.deceiver) return true;
		else return false;
	}
	
	public void initStories(int repeat, String goal) {
		
		int states = priorknowledge.getNumberOfStates();
		train_story = new double[states][repeat];
		testTrue_story = new double[states][repeat];
		testFalse_story = new double[states][repeat];
		if (this.deceiver) {
			shift_story = new double[states][repeat];
			true_story = new double[states][repeat];
			random_story = new double[states][repeat];
			wrong_story = new double[states][repeat];
			change_story = new double[states][repeat];
			rv_dependency = new double[states][states][4];
		}
		int handle = priorknowledge.getNetwork().getFirstNode();
		int st = 0;
		while (handle!=constant.DSL_OUT_OF_RANGE) {
			if (priorknowledge.getRvName(handle).trim().equals(goal.trim())) {
				this.goal_state = st;
				this.goal_handle = handle;
				break;
			}
			st=st+priorknowledge.getNumberOfStates(handle);
			handle = priorknowledge.getNetwork().getNextNode(handle);
		}
		storyinited=true;
	}
	
	public void retrieveDeceiverValues(double[][] story, String file, Evidence[] evi, int agent) {
		try{
			
			FileInputStream input2 = new FileInputStream(file);
			DataInputStream in2 = new DataInputStream(input2);
			BufferedReader br2 = new BufferedReader(new InputStreamReader(in2));
			String strLine2;
			int idx=0;
			while((strLine2=br2.readLine())!=null&&idx<agent+1) {
				if (idx==agent) {
					String[] tmp2 = strLine2.split("\t");
					
					if (tmp2.length!=priorknowledge.getNumberOfNodes()) {
					//if (tmp.length!=g.getNumberOfNodes() || tmp2.length!=g.getNumberOfNodes()) {
						System.err.println("input data "+idx+" don't have the correct column "+"model="+priorknowledge.getNumberOfNodes()+" document="+tmp2.length);
						return;
					}
					
					int handle = priorknowledge.getNetwork().getFirstNode();
					
					int st = 0;
					while (handle!=constant.DSL_OUT_OF_RANGE) {
						
						if (utility.isEvidence(handle, evi)>=0) {
							story[st][idx]=-1;
							story[st+1][idx]=-1;	
						} else {
							//System.out.println("in................"+handle+", "+st+", "+idx);
							int value=Integer.valueOf(tmp2[utility.getIdx(priorknowledge.getRvName(handle))]);
							//System.out.println("value="+value);
							if (value==0) {					
								story[st][idx]=1;
								story[st+1][idx]=0;	
								
							} else if (value==1) {
								story[st][idx]=0;
								story[st+1][idx]=1;
							} else {
								story[st][idx]=0.5;
								story[st+1][idx]=0.5;	
							}
						}
						st=st+2;
						handle = priorknowledge.getNetwork().getNextNode(handle);
						//System.out.println(handle+", "+st);
						//observation[idx][i] = Integer.valueOf(tmp[i]);
					}
				}
				idx++;
			}
		} catch(Exception e) {
			e.printStackTrace();
			System.exit(-1);
			//System.out.println(e);
			//this.strBuf.append(e+"\n");
		}
	}
	
	public void retrieveDeceiverTrueValues(String truefile, Evidence[] evi, int agent) {
		retrieveDeceiverValues(true_story, truefile, evi, agent);
		System.out.println("print true story...................................");
		double[][] sorted = utility.sortOutputRv(getGraph(), true_story);
		utility.print2DArray(sorted, true);
	}
	
	public void retrieveDeceiverShiftValues(String falsefile, Evidence[] evi, int agent) {
		retrieveDeceiverValues(shift_story, falsefile, evi, agent);
		System.out.println("print shift story...................................");
		double[][] sorted = utility.sortOutputRv(getGraph(), shift_story);
		utility.print2DArray(sorted, true);
	}
	
	
	public void inferTrainValues(Evidence[] evi, int repeat) {
		
		inferValues(train_story, evi, repeat, true, constant.random_upper, constant.random_lower);
	//	inferValues(train_story, evi, repeat, null, constant.random_upper/2.0, constant.random_lower/2.0);
	}
	
	public void inferTestTrueValues(Evidence[] evi, int repeat) {
		inferValues(testTrue_story, evi, repeat, true, constant.random_upper, constant.random_lower);
		
	}
	
	public void inferTestFalseValues(Evidence[] evi, int repeat) {
		inferValues(testFalse_story, evi, repeat, true, constant.random_upper, constant.random_lower);
		
	}
	
	public void inferWrongValues(int evi_floor, int evi_ceiling , int repeat) {
		/*for (int i=0; i<evi.length; i++) {
			if (evi[i].gethandle()<0) break;
			evi[i].setstate(1-evi[i].getstate());
		}*/
		
		Evidence[] wrong_evi = utility.getRandomEvidence(evi_floor, evi_ceiling, this.priorknowledge, this.goal_handle);
		inferValues(wrong_story, wrong_evi, repeat, false, constant.random_upper, constant.random_lower);
		
	}
	
	public void inferRandomValues(Evidence[] evi, int repeat) {
		double[] values = new double[random_story.length];
		for (int i=0; i<this.testTrue_story.length; i=i+2) {
			//for (int j=0; j<this.testTrue_story[i].length; j++) {
				if (testTrue_story[i][repeat]>=0){// && i!=this.goal_state) {
					double rand = utilities.RandomNumber.getRandomNumber(constant.random_random_lower, constant.random_random_upper);//Math.random()*(constant.random_upper- constant.random_lower)+constant.random_lower;
					values[i] = testTrue_story[i][repeat]+rand;
					values[i+1] = testTrue_story[i+1][repeat]-rand;
					/*if (values[i]>1) values[i] = 1;
					else if (values[i]<0) values[i] = 0;
					
					if (values[i+1]>1) values[i+1] = 1;
					else if (values[i+1]<0) values[i+1] =0;
					*/
					if (testTrue_story[i][repeat]+rand>1) {values[i] = 1;values[i+1] = 0;}
					else if (testTrue_story[i][repeat]+rand<0) {values[i] = 0;values[i+1] = 1;}
					else if (rand>=0.5) {values[i] = 0.5; values[i+1] = 0.5;}
					else {values[i] = testTrue_story[i][repeat]; values[i+1] = testTrue_story[i+1][repeat];}
				} 
				else {
					values[i+1] = testTrue_story[i+1][repeat];
					values[i] = testTrue_story[i][repeat];
				} //yuki
				
					
			//}
		}
		
//		double[] polarities = utility.convert2polarities2 (this, values, goal_handle, irrelevancyThreshold, evi);
	//	double[] polarities = utility.convert2polarities (evi, this.uncertaintyThreshold, this.commonality, this.uncommonality, values, this.goal_handle, 
	//			this.irrelevancyThreshold, this.name.substring(this.name.indexOf("_")+1)+"_"+contribution_f, this.priorknowledge);
		for (int i=0; i<random_story.length; i++) {
			random_story[i][repeat] = values[i];//polarities[i];
		}
		//convert2Binary(random_story, values, repeat, constant.IMPLICIT_UNCERTAIN);
		
	}
	
	public void inferChangeValues(Evidence[] evi, int repeat) {
		
		CPTPerturber pert = new CPTPerturber(priorknowledge.getNetwork(), null);
		pert.setRangeOfRandom(constant.change_random_lower, constant.change_random_upper);
		pert.perturb();
		priorknowledge.saveNetFile(this.name+"_changed.net");
		inferValues(change_story, evi, repeat, false, constant.random_upper, constant.random_lower);
		priorknowledge.readNetFile(this.graph_name);
	}
	
	
	
	public void beliefUpdateTrain(Evidence[] evi, int repeat) {
		beliefUpdate(train_story, evi, repeat);
	}
	
	public Evidence[] setOtherNodesAsEvidence(int thishandle, int[][] evi_reference) {
		Evidence[] evi = new Evidence[priorknowledge.getNumberOfNodes()];
		for (int i=0; i<evi_reference.length; i++) {
			evi[i] = new Evidence();
			if (thishandle==evi_reference[i][0]) continue;
			evi[i].sethandle(evi_reference[i][0]);
			evi[i].setstate(evi_reference[i][1]);
		}
		return evi;
	}
	
	
	public void beliefUpdate(double[][] result, Evidence[] evi, int repeat) {
		
		//double[] exact = new double[result.length];
		priorknowledge.clearEvidence();
		for (int i=0; i<evi.length; i++) {
			priorknowledge.setEvidence(evi[i].gethandle(), evi[i].getstate());
		}
		priorknowledge.beliefUpdate();
		
		int st = 0;
		int handle = priorknowledge.getNetwork().getFirstNode();
		while (handle!=constant.DSL_OUT_OF_RANGE) {
			double[] value = priorknowledge.getNetwork().getNodeValue(handle);
			for (int i=0; i<value.length; i++) {
				result[st++][repeat] = value[i];
			}
			System.out.print(priorknowledge.getRvName(handle)+"=0\t"+priorknowledge.getRvName(handle)+"=1\t");
			handle = priorknowledge.getNetwork().getNextNode(handle);
			
		}
		System.out.println();
	
		System.out.println("exact story..............................");
		
		for (int i=0; i<result.length; i++) {
			System.out.print(result[i][repeat]+"\t"); //yuki
		}
		System.out.println();
		
	}
	
	/**
	 * noise is for random error
	 * @param result
	 * @param evi
	 * @param repeat
	 * @param addnoise
	 * @param noise_upper
	 * @param noise_lower
	 */
	public void inferValues(double[][] result, Evidence[] evi, int repeat, boolean addnoise, double noise_upper, double noise_lower) {
		
		int[][] answers = doBeliefRevision(evi);
		//System.out.println("belief revision answers.....................");
		//utility.print2DArray(answers);
		
		double[] exact = new double[result.length];
		//double[] noise_exact = new double[result.length];
		
		double[] post = new double[result.length];
	/*	priorknowledge.clearEvidence();
		for (int i=0; i<evi.length; i++) {
			if (evi==null) System.out.println("evi is null");
			else System.out.println("evi "+evi[i].gethandle()+"="+evi[i].getstate());
			priorknowledge.setEvidence(evi[i].gethandle(), evi[i].getstate());
		}*/
		int st = 0;
		int handle = priorknowledge.getNetwork().getFirstNode();
		while (handle!=constant.DSL_OUT_OF_RANGE) {
			int evi_idx = utility.isEvidence(handle, evi);
			if (evi_idx>=0) {
				exact[st+evi[evi_idx].getstate()] = -1;
				exact[st+(1-evi[evi_idx].getstate())] = -1;
				
				//post[st+evi[evi_idx].getstate()] = 1;
				//post[st+1-evi[evi_idx].getstate()] = 0;
				//noise_exact[st+evi[evi_idx].getstate()] = -1;
				//noise_exact[st+(1-evi[evi_idx].getstate())] = -1;
			} else {
			
				//Evidence[] update_evi = setOtherNodesAsEvidence(handle, answers);
				for (int i=0; i<answers.length; i++) {
					if (handle==answers[i][0]) {
						exact[st] = 1-answers[i][1];
						exact[st+1] = answers[i][1];
						break;
					}
					
				}
			}	
				priorknowledge.clearEvidence();
				for (int i=0; i<answers.length; i++) {
					if (handle==answers[i][0]) continue;
					priorknowledge.setEvidence(answers[i][0], answers[i][1]);
				}
				priorknowledge.beliefUpdate();
				double[] value = priorknowledge.getNetwork().getNodeValue(handle);
				//double sum_noise=0;
				for (int i=0; i<value.length; i++) {
					post[st+i] = value[i];
				}
				
		/*		priorknowledge.clearEvidence();
				for (int i=0; i<answers.length; i++) {
					if (handle==answers[i][0]) continue;
					priorknowledge.setEvidence(answers[i][0], answers[i][1]);
				}
				priorknowledge.beliefUpdate();
				double[] value = priorknowledge.getNetwork().getNodeValue(handle);
				double sum_noise=0;
				for (int i=0; i<value.length; i++) {
					exact[st+i] = value[i];
					if (i<value.length-1) {
						noise_exact[st+i] = value[i]+RandomNumber.getRandomNumber(noise_upper, noise_lower);
						if (noise_exact[st+i]>1) noise_exact[st+i]=0.99;
						else if (noise_exact[st+i]<0) noise_exact[st+i]=0.01;
						sum_noise+=noise_exact[st+i];
					} else {
						noise_exact[st+i] = 1-sum_noise;
					}
				}*/ //yuki
			//}
			st+=2;//value.length;
			handle = priorknowledge.getNetwork().getNextNode(handle);
		}
		
		/*priorknowledge.beliefUpdate();
		
		int st = 0;
		int handle = priorknowledge.getNetwork().getFirstNode();
		while (handle!=constant.DSL_OUT_OF_RANGE) {
			double[] value = priorknowledge.getNetwork().getNodeValue(handle);
			
			for (int i=0; i<value.length; i++)
				exact[st+i] = value[i];
			st+=value.length;
			handle = priorknowledge.getNetwork().getNextNode(handle);
		}*/
		System.out.println("exact story..............................");
		utility.printArray(exact, true);
		System.out.println("stored posterior probs..............................");
		utility.printArray(post, true);
		/*for (int i=0; i<exact.length; i++)
			result[i][repeat]=exact[i]; //yuki
		*/
		System.out.println("irrelevancyThreshold = "+irrelevancyThreshold);
		
		//convert2Binary(result, exact, repeat, constant.IMPLICIT_UNCERTAIN); //yuki
		if (addnoise) {
		//	System.out.println("noise exact story..............................");
		//	utility.printArray(noise_exact, true);
			//convert2Binary(noise_result, noise_exact, repeat, constant.IMPLICIT_UNCERTAIN);
			
			double[] polarities = utility.convert2polarities3 (this, exact, goal_handle, irrelevancyThreshold, evi, noise_upper, noise_lower, post);
			//double[] polarities = utility.convert2polarities2 (this, exact, goal_handle, irrelevancyThreshold, evi, noise_upper, noise_lower, post);
		/*	polarities = utility.convert2polarities (evi, this.uncertaintyThreshold, 
					this.commonality, this.uncommonality, noise_exact, goal_handle, 
					this.irrelevancyThreshold, this.name.substring(this.name.indexOf("_")+1)+"_"+contribution_f, getGraph());*/
			for (int i=0; i<result.length; i++) {
				result[i][repeat] = polarities[i];
			}
		} else {
			//double[] polarities = utility.convert2polarities2 (this, exact, goal_handle, irrelevancyThreshold, evi, post);
			double[] polarities = utility.convert2polarities3 (this, exact, goal_handle, irrelevancyThreshold, evi, post);
			/*double[] polarities = utility.convert2polarities (evi, this.uncertaintyThreshold, 
					this.commonality, this.uncommonality, exact, goal_handle, 
					this.irrelevancyThreshold, this.name.substring(this.name.indexOf("_")+1)+"_"+contribution_f, getGraph());*/
			for (int i=0; i<result.length; i++) {
				result[i][repeat] = polarities[i];
			}
		}
		
	}
	
	public int[][] doBeliefRevision(Evidence[] evi) {
		
		int count=0;
		for (int i=0; i<evi.length; i++) {
			if (evi[i].gethandle()>=0) {
				count++;
				
			}
		}
		String[] evi_name = new String[count];
		String[] evi_state = new String[count];
		int idx=0;
		for (int i=0; i<evi.length; i++) {
			if (evi[i].gethandle()>=0) {
				evi_name[idx] = priorknowledge.getRvId(evi[i].gethandle());
				evi_state[idx] = priorknowledge.getStateId(evi[i].gethandle(), evi[i].getstate());
				idx++;
			}
		}
		//return BKB_engine.inferBKB(this.priorknowledge, this.bkb_name, evi_name, evi_state);
		return utilities.MPE_engine.doMPE(this.priorknowledge, this.graph_name, evi_name, evi_state);
	}
	
	public void convert2Binary(double[][] result, double[] exact_result, int repeat, int mode) {
			
			for (int i=0; i<exact_result.length; i=i+2) {
				if (exact_result[i]==0||exact_result[i]==1||exact_result[i]==-1) {
					result[i][repeat] = exact_result[i];
					result[i+1][repeat] = exact_result[i+1];
					continue;
				}
				if (mode==constant.IMPLICIT_UNCERTAIN) {
					if (i==goal_state) {
						if (this.binary_threshold==0 && (exact_result[i]<constant.BINARY_THRESHOLD_GOAL&&exact_result[i]>1-constant.BINARY_THRESHOLD_GOAL) ||
								this.binary_threshold!=0 && (exact_result[i]<binary_threshold&&exact_result[i]>1-binary_threshold)) {
							result[i][repeat] = 0.5;
							result[i+1][repeat] = 0.5;
						} else {
							
								result[i][repeat] = Math.floor(exact_result[i]/0.50001);
								result[i+1][repeat] = Math.floor(exact_result[i+1]/0.50001);
							
						}
					} else {
						if (this.binary_threshold==0 && (exact_result[i]<constant.BINARY_THRESHOLD&&exact_result[i]>1-constant.BINARY_THRESHOLD) ||
								this.binary_threshold!=0 && (exact_result[i]<binary_threshold&&exact_result[i]>1-binary_threshold)) {
							result[i][repeat] = 0.5;
							result[i+1][repeat] = 0.5;
						} else {
							
								result[i][repeat] = Math.floor(exact_result[i]/0.50001);
								result[i+1][repeat] = Math.floor(exact_result[i+1]/0.50001);
							
						}
					}
				} else if (mode==constant.IMPLICIT_IRRELEVENT) {
					if (exact_result[i]==0.5) {
						result[i][repeat] = 0.5;
						result[i+1][repeat] = 0.5;
					} else {
						result[i][repeat] = Math.floor(exact_result[i]/0.50001);
						result[i+1][repeat] = Math.floor(exact_result[i+1]/0.50001);
					}
				} else if (mode==constant.IMPLICIT_COMMONSENSE) {
					
				}
			}
		
	}
	
	public void calculateDependency() {
		for (int i=0; i<this.train_story.length; i++) {
			//System.out.println("state "+i);
			for (int j=0; j<this.train_story.length; j++) {
				//System.out.println("neighbor "+j);
				double depend = calculateIndividualDependency (new int[]{i,j}, new int[]{0,0});
				this.rv_dependency[i][j][0] = depend;
				depend = calculateIndividualDependency (new int[]{i,j}, new int[]{0,1});
				this.rv_dependency[i][j][1] = depend;
				depend = calculateIndividualDependency (new int[]{i,j}, new int[]{1,0});
				this.rv_dependency[i][j][2] = depend;
				depend = calculateIndividualDependency (new int[]{i,j}, new int[]{1,1});
				this.rv_dependency[i][j][3] = depend;
			}
		}
		
	/*	for (int i=0; i<this.train_story.length; i++) {
			//System.out.println("state "+i);
			for (int j=i+2; j<this.train_story.length; j++) {
				this.rv_dependency[i][j][0] = this.rv_dependency[j][i][0];
			}
		}*/
		
	}
	
	public double calculateIndividualDependency (int[] indices, int[] values) {
		int up = count(indices, values, this.train_story);
		int down = count(new int[]{indices[indices.length-1]}, new int[]{values[values.length-1]}, this.train_story);
		double cond = ((double)up/(double)this.train_story[0].length)/((double)down/(double)this.train_story[0].length);
		if (down==0) cond = 0;
		int post_up = count(new int[]{indices[0]}, new int[]{values[0]}, this.train_story);
		if (indices[0]==indices[1]) System.err.println("dependency between "+indices[0]+" and "+indices[1]+" is "+up+", "+down+", "+post_up);
		//int post_down = count(new int[]{indices[0]}, new int[]{1-values[0]}, this.train_story)+post_up;
		//double post = (double)post_up/(double)post_down;
		//System.out.println("up="+up+"; down="+down+"; post_up="+post_up+"; post_down="+post_down);
		//if (post_down==0 || post==0) return 0;
		if (post_up==0) return 0;
		return cond/((double)post_up/(double)this.train_story[0].length);
	}
	
	public int count (int[] indices, int[] values, double[][] data) {
		int count = 0;
		if (indices.length!=values.length) 
			System.err.println("----------------------------In Agent.calculateDependency: indices and values don't have same length!!!");
		for (int i=0; i<data[0].length; i++) {
			boolean check = true;
			for (int j=0; j<indices.length; j++) {
				if (data[indices[j]][i]!=values[j]) {
					check = false; break;
				}
			}
			if (check) count++;
		}
		
		return count;
	}
	
	public double[][] getRvDependency(int rv) {
		return this.rv_dependency[rv];
	}
	
	public double[][][] getRvDependency() {
		return this.rv_dependency;
	}
	
	public void setRvCorr(double[][] in) {
		this.rv_correlation = new double[in.length][in[0].length];
		for (int i=0; i<in.length; i++) {
			for (int j=0; j<in[i].length; j++) {
				this.rv_correlation[i][j] = in[i][j];
			}
		}
	}
	
	public double[][] getRvCorr() {
		return this.rv_correlation;
	}
	
	public void setExplicitThreshold(double value) {
		binary_threshold = value;
	}
	
	public double[][] getTrainValues() {
		return train_story;
	}
	
	public double[][] getTestTrueValues() {
		return testTrue_story;
	}
	
	public double[][] getTestFalseValues() {
		return testFalse_story;
	}
	
	public double[][] getShiftValues() {
		return shift_story;
	}
	
	public double[][] getTrueValues() {
		return true_story;
	}
	
	public double[][] getRandomValues() {
		return random_story;
	}
	
	public double[][] getWrongValues() {
		return wrong_story;
	}
	
	public double[][] getChangeValues() {
		return change_story;
	}
	
	public Graph getGraph(){
		return priorknowledge;
	}
	
	
}