#include <BKB_API.h>
#include <BKB_graphComponents.h>
//#include <multimap.h>
//#include <utility.h>
//#include <std>


//#include <bayesianKnowledgeBase.h>

#define DIAG_LVL 0


BKB_API::BKB_API()
{
	
	bkb = new bayesianKnowledgeBase();
	//checkConsistency = true;
	//cout << "bkb constructing: " << bkb;
	//gw = new BKB_gateway(bkb);
	next_evi = 0;
	num_evidence = 0;
	
	evidence = NULL;
	
	next_mevi = 0;
	num_marg_evidence = 0;
	
	marg_evidence = NULL;
	
	
	revision = NULL;//BKBR_revising(bkb -> getGateWay(), num_evidence, evidence, num_marg_evidence, marg_evidence, DIAG_LVL, cout);;
	
	current_answer = 1;
	
	doBeliefPrediction = true;
	
	//node_list.insert ( pair<int,int>(50,100) );
	
	//    cout << "There are " << (int)node_list.count(50);
	  

	
	}
BKB_API::BKB_API(long n_evi, long n_mevi, long n_tevi)
{
	BKB_API();
	//bkb = new bayesianKnowledgeBase();
	//gw = new BKB_gateway(bkb);
	//next_evi = 0;
	resetEvidence(n_evi, n_mevi, n_tevi);
	//num_evidence = n_evi;
	//if (num_evidence<=0)
	//	evidence = NULL;
	//else
	//	evidence = new BKBR_evidence[num_evidence];
	//next_mevi = 0;
	//num_marg_evidence = n_mevi;
	//if (num_marg_evidence<=0)
	//	marg_evidence = NULL;
	//else
	//	marg_evidence = new BKBR_marginalEvidence[num_marg_evidence];
	
	//revision = NULL;
	
	}

BKB_API::~BKB_API()
{
	
	
	}

void BKB_API::saveBKB(char* filename)
{
	bkb -> save(filename);
}

BKB_handle BKB_API::newRV(char* rvname)
{
	BKB_handle component = bkb -> newComponent(rvname);
	
	return component;
						
}

bool BKB_API::renameRV(char* rvname, char* newname)
{
	BKB_handle handle1 = bkb -> getComponentHandle(rvname);
	return bkb -> renameComponent(handle1, newname);
}

BKB_handle BKB_API::newState(char* rvname, char* statename)
{
	BKB_handle handle1;
	//BKB_handle handle2;
	//BKB_handle handle3;
	//BKB_handle inode_handle;
	handle1 = bkb -> getComponentHandle(rvname);
	//handle3 = bkb -> newState(handle1, statename);						
	//handle2 = bkb -> getComponentINode(handle1, statename);	
		
	
	//cout << "State: " << handle3 << "\n";
	//cout << "INode: " << handle2 << "\n";
	BKB_handle inode = bkb -> newState(handle1, statename);		
	//if (checkConsistency) 
	doConsistencyCheck();
	return inode;

}

bool BKB_API::renameState(char* rvname, char* statename, char* newstate)
{
	//BKB_handle								rv_handle;
	BKB_handle								inode_handle;
					
	//rv_handle = (*bkb).getComponentHandle(rvname);
							
	inode_handle = getINodeHandle(rvname, statename);//(*bkb).getComponentINode(rv_handle, statename);
	return bkb -> renameINodeState(inode_handle, newstate);
}

void BKB_API::deleteINode(char* rvname, char* statename)
{
	//BKB_handle								rv_handle;
	BKB_handle								inode_handle;
						
	//rv_handle = (*bkb).getComponentHandle(rvname);
								
	inode_handle = getINodeHandle(rvname, statename);//(*bkb).getComponentINode(rv_handle, statename);
	long parentNum = bkb -> getNumberParents(inode_handle);
	
	for (long i=0; i<parentNum; i++)
	{
		BKB_handle s_handle =bkb -> getParent(inode_handle, i);
		bkb -> deleteSNode(s_handle);
	}
	
	
	bkb -> deleteINode(inode_handle);
	//if (checkConsistency) 
	doConsistencyCheck();
	/*while (bkb -> kb.getNumberIncomingArcs(inode_handle) > 0) {
			arc_handle = kb.getIncomingArc(inode_handle, 0);
			deleteArc(arc_handle);
			}*/
}

BKB_handle BKB_API::newRelation(long pr_num, char** prname, char** prstate, char* chname, char* chstate, double prob)
{
	long i;
	//long pr_num = prname.length;
	
	//BKB_handle handle1;
	BKB_handle handle2;
	BKB_handle handle3;
	//BKB_handle handle4;
	BKB_handle handle5;
	
	//handle1 = bkb -> getComponentHandle(chname); //random variable
	handle2 = getINodeHandle(chname, chstate);//bkb -> getComponentINode(handle1, chstate); //inode
	handle3 = bkb -> newSNode(new BKB_S_node(prob)); //snode
	bkb -> addArc(handle3, handle2);
	
	if (pr_num>0) {
		for (i=0; i<pr_num; i++) {
			//handle4 = bkb -> getComponentHandle(prname[i]);
			handle5 = getINodeHandle(prname[i],prstate[i]); //bkb -> getComponentINode(handle4, prstate[i]);
			bkb -> addArc(handle5, handle3);
		}
	}
	//cout << prob <<" SHOULD BE @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ "<<bkb->getSNodeProbability(handle3)<<"\n";
	//if (checkConsistency) 
	doConsistencyCheck();
	return handle3;
}

void BKB_API::resetProbability(BKB_handle snode_handle, double prob)
{
	bkb -> setSNodeProbability(snode_handle, prob);
	//if (checkConsistency) 
	doConsistencyCheck();
}

void BKB_API::deleteRelation(BKB_handle snode_handle)
{
	bkb -> deleteSNode(snode_handle);
	//if (checkConsistency) 
	doConsistencyCheck();
	saveBKB("b_out07.bkb");
}

char* BKB_API::getINodeName(BKB_handle inode_handle)
{
	BKB_handle component_handle = bkb -> getINodeComponentHandle(inode_handle);
	return bkb -> getComponentName(component_handle);
}

BKB_handle BKB_API::getINodeHandle(char* rvname, char* statename)
{
	BKB_handle component_handle = bkb -> getComponentHandle(rvname);
	return bkb -> getComponentINode(component_handle, statename);
}




void BKB_API::loadBKB(char* filename)
{
	//cout << "BKB: " << bkb;
	//cout << "in api load\n";
	bkb -> load(filename, false);
	//if (checkConsistency) 
	doConsistencyCheck();
}

void BKB_API::resetEvidence(long n_evi, long n_mevi, long n_tevi)
{
	//cout << "in api reset evidence\n ";
	//delete evidence;
	//delete marg_evidence;
	//cout << "deleted ol evidence\n ";
	num_evidence = n_evi;
	//cout << num_evidence << "/";
	evidence = new BKBR_evidence[num_evidence];

	num_marg_evidence = n_mevi;
	//cout << num_marg_evidence << "\n";
	marg_evidence = new BKBR_marginalEvidence[num_marg_evidence];
	
	num_temp_evidence = n_tevi;
	//cout << num_temp_evidence << "/";
	temp_evidence = new BKBR_temporalEvidence[num_temp_evidence];
	
	next_evi = 0;
	next_mevi = 0;
	next_tevi = 0;
	

}

bool BKB_API::checkEviRedundancy(BKB_handle rv_handle)
{
	for (int i=0; i<next_evi; i++)
	{
		if (evidence[i].getRVHandle()==rv_handle) 
		{
		//	cout<< "EVIDENCE ERROR\n";
			return false;
		}
	}
	return true;
}

Evidence_status BKB_API::setEvidence(long rv_idx, char* state_str)
{
	if (next_evi>=num_evidence) return Evidence_overload;
		
		char*									s;
		char*									t;
		
		BKB_handle								rv_handle;
		BKB_handle								inode_handle;
		
		rv_handle = (*bkb).getComponentHandle(rv_idx);
		//s = (*bkb).getComponentName(rv_handle);
		//cout << s << ": ";
		if (!checkEviRedundancy(rv_handle)) return Evidence_exist;
		
		evidence[next_evi].setRVHandle(rv_handle);
				
		//inode_handle = (*bkb).getComponentINode(rv_handle, state_str);
		//t = (*bkb).getINodeState(inode_handle);
		//cout << t << "\n";
		evidence[next_evi].setState(state_str);
			
		next_evi++;
		return Evidence_valid;
	
}

Evidence_status BKB_API::setEvidence(char* rv_str, char* state_str)
{
	if (next_evi>=num_evidence) return Evidence_overload;
			
			char*									s;
			char*									t;
			
			BKB_handle								rv_handle;
			BKB_handle								inode_handle;
			
			rv_handle = (*bkb).getComponentHandle(rv_str);
			//s = (*bkb).getComponentName(rv_handle);
			//cout << s << ": ";
			if (!checkEviRedundancy(rv_handle)) return Evidence_exist;
			evidence[next_evi].setRVHandle(rv_handle);
					
			//inode_handle = (*bkb).getComponentINode(rv_handle, state_str);
			//t = (*bkb).getINodeState(inode_handle);
			//cout << t << "\n";
			evidence[next_evi].setState(state_str);
				
			next_evi++;
			return Evidence_valid;
}

Evidence_status BKB_API::setEvidence(char* rv_str, long state_idx)
{
	if (next_evi>=num_evidence) return Evidence_overload;
				
				char*									s;
				char*									t;
				
				BKB_handle								rv_handle;
				BKB_handle								inode_handle;
				
				rv_handle = (*bkb).getComponentHandle(rv_str);
				//s = (*bkb).getComponentName(rv_handle);
				//cout << s << ": ";
				if (!checkEviRedundancy(rv_handle)) return Evidence_exist;
				evidence[next_evi].setRVHandle(rv_handle);
						
				inode_handle = (*bkb).getComponentINode(rv_handle, state_idx);
				t = (*bkb).getINodeState(inode_handle);
				//cout << t << "\n";
				evidence[next_evi].setState(t);
					
				next_evi++;
				return Evidence_valid;
}

Evidence_status BKB_API::setEvidence(long rv_idx, long state_idx)
{
	//cout << "in api set evidence\n";
	if (next_evi>=num_evidence) return Evidence_overload;
	//long									i;
	//long									j;
	//long 									evidence_index;
	//long									state_index;
	char*									s;
	char*									t;
	//BKBR_evidence* 							evidence;
	BKB_handle								rv_handle;
	BKB_handle								inode_handle;
	

		
		//for (i=0; i<*num_evidence; i++) {
			//for (j=0; j<bkb.getNumberComponents(); j++) {
			//	s = bkb.getComponentName(bkb.getComponentHandle(j));
			//	cout << j << " : " << s << endl;
			//	}
			//cout << "Set evidence #" << i+1 << ": ";
			//cin >> evidence_index;
			rv_handle = (*bkb).getComponentHandle(rv_idx);
			//s = (*bkb).getComponentName(rv_handle);
			//cout << s << ": ";
			if (!checkEviRedundancy(rv_handle)) return Evidence_exist;
			evidence[next_evi].setRVHandle(rv_handle);
			//for (j=0; j<bkb.getComponentNumberINodes(rv_handle); j++) {
			//	inode_handle = bkb.getComponentINode(rv_handle, j);
			//	t = bkb.getINodeState(inode_handle);
			//	cout << j << " : " << t << endl;
			//	}
			//s = bkb.getComponentName(rv_handle);
			//cout << "Clamp evidence " << s << " state: ";
			//cin >> state_index;
			inode_handle = (*bkb).getComponentINode(rv_handle, state_idx);
			t = (*bkb).getINodeState(inode_handle);
			//cout << t << "\n";
			evidence[next_evi].setState(t);
			//}
		//return (evidence);
	next_evi++;
	return Evidence_valid;
}

Evidence_status BKB_API::setTemporalEvidence(long rv_idx, long state_idx, long start, long end, long duration)
{
	//cout << "in api set temporal evidence\n";
	if (next_tevi>=num_temp_evidence) return Evidence_overload;
	
	char*									s;
	char*									t;
	
	BKB_handle								rv_handle;
	BKB_handle								inode_handle;
	
			rv_handle = (*bkb).getComponentHandle(rv_idx);
			s = (*bkb).getComponentName(rv_handle);
			//cout << s << ": ";
			temp_evidence[next_tevi].setRVHandle(rv_handle);
		
			inode_handle = (*bkb).getComponentINode(rv_handle, state_idx);
			t = (*bkb).getINodeState(inode_handle);
			//cout << t << "\n";
			temp_evidence[next_tevi].setState(t);
			
			if (start>=0) 
			{
				if (! temp_evidence[next_tevi].setStart(start)) cout << "\t\tUnable to set." << endl;
			}
			if (end>=0) 
			{
				if (! temp_evidence[next_tevi].setEnd(end)) cout << "\t\tUnable to set." << endl;
			}
			if (duration>=0) 
			{
				if (! temp_evidence[next_tevi].setDuration(duration)) cout << "\t\tUnable to set." << endl;
			}
			
		
			next_tevi++;
			return Evidence_valid;
}

Evidence_status BKB_API::setTemporalEvidence(char* rv_str, char* state_str, long start, long end, long duration)
{
	//cout << "in api set temporal evidence\n";
	if (next_tevi>=num_temp_evidence) return Evidence_overload;
	
	//char*									s;
	char*									t;
	
	BKB_handle								rv_handle;
	//BKB_handle								inode_handle;
	
			rv_handle = (*bkb).getComponentHandle(rv_str);
			//s = (*bkb).getComponentName(rv_handle);
			//cout << s << ": ";
			temp_evidence[next_tevi].setRVHandle(rv_handle);
		
			//inode_handle = (*bkb).getComponentINode(rv_handle, state_str);
			//t = (*bkb).getINodeState(inode_handle);
			//cout << t << "\n";
			temp_evidence[next_tevi].setState(state_str);
			
			if (start>=0) 
			{
				if (! temp_evidence[next_tevi].setStart(start)) cout << "\t\tUnable to set." << endl;
			}
			if (end>=0) 
			{
				if (! temp_evidence[next_tevi].setEnd(end)) cout << "\t\tUnable to set." << endl;
			}
			if (duration>=0) 
			{
				if (! temp_evidence[next_tevi].setDuration(duration)) cout << "\t\tUnable to set." << endl;
			}
			
		
			next_tevi++;
			return Evidence_valid;
}

Evidence_status BKB_API::setMarginalEvidence(long rv_idx, long state_idx, double prob)
{
		char*									s;
		char*									t;
		BKB_handle								rv_handle;
		BKB_handle								inode_handle;
		
		//cout << "in api set marginal evidence\n";
		if (next_mevi>=num_marg_evidence) return Evidence_overload;
		
			rv_handle = (*bkb).getComponentHandle(rv_idx);
			//s = (*bkb).getComponentName(rv_handle);
			//cout << s << ": ";
			marg_evidence[next_mevi].setRVHandle(rv_handle);
			
			inode_handle = (*bkb).getComponentINode(rv_handle, state_idx);
			t = (*bkb).getINodeState(inode_handle);
			//cout << t << "\n";
			marg_evidence[next_mevi].setState(t);
			marg_evidence[next_mevi].setMarginal(prob);
		
			next_mevi++;
			return Evidence_valid;
}

Evidence_status BKB_API::setMarginalEvidence(long rv_idx, char* state_str, double prob)
{
			char*									s;
			char*									t;
			BKB_handle								rv_handle;
			BKB_handle								inode_handle;
			
			//cout << "in api set marginal evidence\n";
			if (next_mevi>=num_marg_evidence) return Evidence_overload;
			
				rv_handle = (*bkb).getComponentHandle(rv_idx);
				//s = (*bkb).getComponentName(rv_handle);
				//cout << s << ": ";
				marg_evidence[next_mevi].setRVHandle(rv_handle);
				
				//inode_handle = (*bkb).getComponentINode(rv_handle, state_str);
				//t = (*bkb).getINodeState(inode_handle);
				//cout << t << "\n";
				marg_evidence[next_mevi].setState(state_str);
				marg_evidence[next_mevi].setMarginal(prob);
			
				next_mevi++;
				return Evidence_valid;
}

Evidence_status BKB_API::setMarginalEvidence(char* rv_str, char* state_str, double prob)
{
				char*									s;
				char*									t;
				BKB_handle								rv_handle;
				BKB_handle								inode_handle;
				
				//cout << "in api set marginal evidence\n";
				if (next_mevi>=num_marg_evidence) return Evidence_overload;
				
					rv_handle = (*bkb).getComponentHandle(rv_str);
					//s = (*bkb).getComponentName(rv_handle);
					//cout << s << ": ";
					marg_evidence[next_mevi].setRVHandle(rv_handle);
					
					//inode_handle = (*bkb).getComponentINode(rv_handle, state_str);
					//t = (*bkb).getINodeState(inode_handle);
					//cout << t << "\n";
					marg_evidence[next_mevi].setState(state_str);
					marg_evidence[next_mevi].setMarginal(prob);
				
					next_mevi++;
					return Evidence_valid;
}

Evidence_status BKB_API::setMarginalEvidence(char* rv_str, long state_idx, double prob)
{
				char*									s;
				char*									t;
				BKB_handle								rv_handle;
				BKB_handle								inode_handle;
				
				//cout << "in api set marginal evidence\n";
				if (next_mevi>=num_marg_evidence) return Evidence_overload;
				
					rv_handle = (*bkb).getComponentHandle(rv_str);
					//s = (*bkb).getComponentName(rv_handle);
					//cout << s << ": ";
					marg_evidence[next_mevi].setRVHandle(rv_handle);
					
					inode_handle = (*bkb).getComponentINode(rv_handle, state_idx);
					t = (*bkb).getINodeState(inode_handle);
					//cout << t << "\n";
					marg_evidence[next_mevi].setState(t);
					marg_evidence[next_mevi].setMarginal(prob);
				
					next_mevi++;
					return Evidence_valid;
}

void BKB_API::checkEviConsistency()
{
	if (next_evi<num_evidence)
	{
		//cout << "next_evi<num_evidence caught: "<<(num_evidence-next_evi)<< "\n";
		BKBR_evidence* tmp_evi = new BKBR_evidence[next_evi];
		for (int i=0; i<next_evi; i++) 
		{
			tmp_evi[i].setRVHandle(evidence[i].getRVHandle());
			tmp_evi[i].setState(evidence[i].getState());
		}
		num_evidence = next_evi;
		
		evidence = tmp_evi;
		
	}
	
	if (next_mevi<num_marg_evidence)
		{
		//cout << "next_mevi<num_marg_evidence: "<<(num_marg_evidence-next_mevi)<< "\n";
			BKBR_marginalEvidence* tmp_margevi = new BKBR_marginalEvidence[next_mevi];
			for (int i=0; i<next_mevi; i++) 
			{
				tmp_margevi[i].setRVHandle(marg_evidence[i].getRVHandle());
				tmp_margevi[i].setState(marg_evidence[i].getState());
				tmp_margevi[i].setMarginal(marg_evidence[i].getMarginal());
				
			}
			num_marg_evidence = next_mevi;
			marg_evidence = tmp_margevi;
			
		}
	
	
	if (next_tevi<num_temp_evidence)
		{
		//cout << "next_tevi<temp_evidence: "<<(num_temp_evidence-next_tevi)<< "\n";
			BKBR_temporalEvidence* tmp_temevi = new BKBR_temporalEvidence[next_tevi];
			for (int i=0; i<next_tevi; i++) 
			{
				tmp_temevi[i].setRVHandle(temp_evidence[i].getRVHandle());
				tmp_temevi[i].setState(temp_evidence[i].getState());
				if (temp_evidence[i].isStartSet()) tmp_temevi[i].setStart(temp_evidence[i].getStart());
				if (temp_evidence[i].isEndSet()) tmp_temevi[i].setEnd(temp_evidence[i].getEnd());
				if (temp_evidence[i].isDurationSet()) tmp_temevi[i].setDuration(temp_evidence[i].getDuration());
			}
			num_temp_evidence = next_tevi;
			temp_evidence = tmp_temevi;
			
		}
}

BKB_handle* BKB_API::getComponentsHandle()
{
	long num_components = bkb -> getNumberComponents();
	BKB_handle* 			components = new BKB_handle[num_components];
					for (int i=0; i<num_components; i++) {
						components[i] = bkb -> getComponentHandle(i);
					}
					return components;
}

char* BKB_API::getComponentName(BKB_handle handle)
{
	return bkb->getComponentName(handle);
}

long BKB_API::getComponentNumber()
{
	return bkb->getNumberComponents();
}


void BKB_API::beliefRevision()
{
	checkEviConsistency();
	//revision = BKBR_revising(gw, num_evidence, evidence, num_marg_evidence,
	//			marg_evidence, DIAG_LVL, cout);
	
	//cout << "DOING BELIEF REVISION\n";
	
	//BKB_handle* target_components = new BKB_handle[0];
	
	/*doRevision = new BKBR_beliefRevision(bkb -> getGateWay(), num_evidence, evidence,
				num_marg_evidence, marg_evidence, num_temp_evidence,
				temp_evidence, (long)0, target_components,
				DIAG_LVL, cout);*/
	long target_num = bkb -> getNumberComponents();
	BKB_handle* 			target_components = new BKB_handle[target_num];
				for (int i=0; i<target_num; i++) {
					target_components[i] = bkb -> getComponentHandle(i);
				}
	doRevision = new BKBR_beliefRevision(bkb -> getGateWay(), num_evidence, evidence,
					num_marg_evidence, marg_evidence, num_temp_evidence,
					temp_evidence, target_num, target_components,
					DIAG_LVL, cout);
	doRevision -> disableTemporalConstraints();
	//cout << "Is going to do REVISION\n";
	if (doRevision -> findNextAnswer())
	{
		//cout << "doing REVISION\n";
		doRevision -> moveToLastAnswer(); // Get most recent answer.
		revision = doRevision -> getAnswer();
	}// else 
	//{	
	//	cout << "NO ANSWER\n";
	//	revision = doRevision -> getAnswer();
	//}
	//return revision;
	predicted = false;
//	beliefPrediction();
}


bool BKB_API::moveToNextAnswer()
{
	
	
	//if (!predicted)
	//{
		if (doRevision -> findNextAnswer())
		{
			doRevision -> moveToLastAnswer(); // Get most recent answer.
			delete revision;
			revision = doRevision -> getAnswer();
			//beliefPrediction();
			return true;
		} else
		{
		
			return false;
		}
/*	} else
	{
			MATH_PACK worldProb;
			long bestWorld = -1;
			MATH_PACK next_bestProb = 0;
			//BKBR_revision* bestRevision = NULL;
			
			for (long i=0; i<total; i++)
			{
				for (long j=0; j<size; j++)
				{
					//cout<<"here is "<<j<<endl;
					long dividor=1;
					for (long k=j+1; k<size; k++)
					{
						//cout<<"here2 is "<<k<<endl;
						dividor=dividor*prv_statenum[k];
					}
					//cout<<i/dividor<<endl;
					prv_curstate[j] = (int)(i/dividor)%prv_statenum[j];
					cout<<prv_curstate[j]<<" ";
				}
				cout<<endl;
				long num_tmp_evidence = num_evidence+size;
				BKBR_evidence* tmp_evi = new BKBR_evidence[num_tmp_evidence];
				for (int j=0; j<num_evidence; j++) 
				{
					tmp_evi[j].setRVHandle(evidence[j].getRVHandle());
					
					tmp_evi[j].setState(evidence[j].getState());
					cout<<"SET Evidence: "<<bkb->getComponentName(evidence[j].getRVHandle())<<"="<<evidence[j].getState()<<endl;
				}
				cout<<"-----------------------NEW EVIDENCE---------------\n";
				for (int j=0; j<size; j++)
				{
					tmp_evi[j+num_evidence].setRVHandle(prv_idx[j]);
					BKB_handle inode_handle = (*bkb).getComponentINode(prv_idx[j], prv_curstate[j]);
					char* t = (*bkb).getINodeState(inode_handle);
					tmp_evi[j+num_evidence].setState(t);
					cout<<"SET Evidence: "<<bkb->getComponentName(prv_idx[j])<<"="<<t<<endl;
				}
			
				BKB_handle* target_components = new BKB_handle[0];
					
				tmp_doRevision = new BKBR_beliefRevision(bkb -> getGateWay(), num_tmp_evidence, tmp_evi,
								num_marg_evidence, marg_evidence, num_temp_evidence,
								temp_evidence, (long)0, target_components,
								DIAG_LVL, cout);
				cout << "Is doing REVISION\n";
				int run = 0;
				while (tmp_doRevision -> findNextAnswer())
				{
					run++;
					predicted = true;
					cout << "find answer for evidence set "<<i<<endl;
					tmp_doRevision -> moveToLastAnswer(); // Get most recent answer.
					tmp_revision = tmp_doRevision -> getAnswer();
					if (tmp_revision!=NULL)
					{
						worldProb = tmp_revision -> getProbability();
						cout<<"World "<<i<<": "<<worldProb<<endl;
						if (worldProb<bestProbability && worldProb>next_bestProb)
						{
							bestWorld = i;
							cout<<"Best world is "<<i<<" run "<<run<<endl;
							next_bestProb = worldProb;
							revision = tmp_revision;
						}
					}
				}// else 
			}
			if (bestWorld>-1)
			{
				bestProbability = next_bestProb;
				return true;
			} else
			{
				return false;
			}
		
	}*/

}

/*void BKB_API::beliefPrediction()
{
	if (!doBeliefPrediction) return;
	if (revision==NULL) 
	{
		cout<<"NO REVISION\n";
		return;
	}
	
	vector<int> rv_toPredict;
	long rv_num = bkb -> getNumberComponents();
	for (long i=0; i<rv_num; i++)
	{
		if (revision -> getAssignment(i) == -1)
		{
			cout<<i<<" has no assignment\n";
			rv_toPredict.push_back(bkb -> getComponentHandle(i));
		}
	}
	
	size = (int)rv_toPredict.size();
	if (size==0) return;
	prv_idx = new long[size];
	prv_statenum = new long[size];
	prv_curstate = new long[size];
	total = 1;
	for (long i=0; i<size; i++)
	{
		prv_idx[i] = rv_toPredict.back();
		cout<<"rv "<<i<<": "<<bkb->getComponentName(prv_idx[i])<<endl;
		rv_toPredict.pop_back();
		//BKB_handle rv_handle = bkb -> getComponentHandle(prv_idx[i]);
		prv_statenum[i] = bkb -> getComponentNumberINodes(prv_idx[i]);
		cout<<"statenum "<<i<<": "<<prv_statenum[i]<<endl;
		total = total*prv_statenum[i];
		//prv_curstate[i] = 0;
	}
	cout<<"total: "<<total<<endl;
	
	//MATH_PACK* worldProbs = new MATH_PACK[total];
	MATH_PACK worldProb;
	long bestWolrd = -1;
	bestProbability = 0;
	//BKBR_revision* bestRevision = NULL;
	
	for (long i=0; i<total; i++)
	{
		for (long j=0; j<size; j++)
		{
			//cout<<"here is "<<j<<endl;
			long dividor=1;
			for (long k=j+1; k<size; k++)
			{
				//cout<<"here2 is "<<k<<endl;
				dividor=dividor*prv_statenum[k];
			}
			//cout<<i/dividor<<endl;
			prv_curstate[j] = (int)(i/dividor)%prv_statenum[j];
			cout<<prv_curstate[j]<<" ";
		}
		cout<<endl;
		long num_tmp_evidence = num_evidence+size;
		BKBR_evidence* tmp_evi = new BKBR_evidence[num_tmp_evidence];
		for (int j=0; j<num_evidence; j++) 
		{
			tmp_evi[j].setRVHandle(evidence[j].getRVHandle());
			
			tmp_evi[j].setState(evidence[j].getState());
			cout<<"SET Evidence: "<<bkb->getComponentName(evidence[j].getRVHandle())<<"="<<evidence[j].getState()<<endl;
		}
		cout<<"-----------------------NEW EVIDENCE---------------\n";
		for (int j=0; j<size; j++)
		{
			tmp_evi[j+num_evidence].setRVHandle(prv_idx[j]);
			BKB_handle inode_handle = (*bkb).getComponentINode(prv_idx[j], prv_curstate[j]);
			char* t = (*bkb).getINodeState(inode_handle);
			tmp_evi[j+num_evidence].setState(t);
			cout<<"SET Evidence: "<<bkb->getComponentName(prv_idx[j])<<"="<<t<<endl;
		}
	
		BKB_handle* target_components = new BKB_handle[0];
			
		tmp_doRevision = new BKBR_beliefRevision(bkb -> getGateWay(), num_tmp_evidence, tmp_evi,
						num_marg_evidence, marg_evidence, num_temp_evidence,
						temp_evidence, (long)0, target_components,
						DIAG_LVL, cout);
		cout << "Is doing REVISION\n";
		if (tmp_doRevision -> findNextAnswer())
		{
			predicted = true;
			cout << "find answer\n";
			tmp_doRevision -> moveToLastAnswer(); // Get most recent answer.
			tmp_revision = tmp_doRevision -> getAnswer();
			if (tmp_revision!=NULL)
			{
				worldProb = tmp_revision -> getProbability();
				cout<<"World "<<i<<": "<<worldProb<<endl;
				if (worldProb>bestProbability)
				{
					bestWolrd = i;
					cout<<"Best world is "<<i<<endl;
					bestProbability = worldProb;
					revision = tmp_revision;
				}
			}
		}// else 
		
		
	}
	/*if (bestWorld>-1)
	{
		
	}*/
//}

MATH_PACK BKB_API::getStartTime(long rv_idx)
{
	if (revision==NULL) return -1;
	
	return revision -> getStart(rv_idx);
						
}

MATH_PACK BKB_API::getStartTime(char* rv_str)
{
	if (revision==NULL) return -1;
	
	BKB_handle rv_handle;
	long idx = -1;
	rv_handle = bkb -> getComponentHandle(rv_str);
	idx = bkb -> getComponentIndex(rv_handle);
	if (idx<0) return -1;
	
	return revision -> getStart(idx);
						
}

MATH_PACK BKB_API::getEndTime(long rv_idx)
{
	if (revision==NULL) return -1;
	
	return revision -> getEnd(rv_idx);
						
}

MATH_PACK BKB_API::getEndTime(char* rv_str)
{
	if (revision==NULL) return -1;
	
	BKB_handle rv_handle;
	long idx = -1;
	rv_handle = bkb -> getComponentHandle(rv_str);
	idx = bkb -> getComponentIndex(rv_handle);
	if (idx<0) return -1;
		
	return revision -> getEnd(idx);
						
}

char* BKB_API::getAssignment(long rv_idx)
{
	if (revision==NULL) return "Unknown";
	
	BKB_handle rv_handle;
	BKB_handle inode_handle;
	char* t = NULL;
	
	rv_handle = bkb -> getComponentHandle(rv_idx);
	//s = bkb -> getComponentName(rv_handle);
	if (revision -> getAssignment(rv_idx) == -1) 
	{
	//	cout << "Null";
		return "Unknown";
	}
	
	inode_handle = bkb -> getComponentINode(rv_handle, revision -> getAssignment(rv_idx));
	t = bkb -> getINodeState(inode_handle);
	return t;
}

char* BKB_API::getAssignment(char* rv_str)
{
	if (revision==NULL) return "Unknown";
	
	BKB_handle rv_handle;
	BKB_handle inode_handle;
	char* t = NULL;
	long idx = -1;
		
	rv_handle = bkb -> getComponentHandle(rv_str);
	idx = bkb -> getComponentIndex(rv_handle);
	//cout << idx << "\n";
	if (idx<0) return "Unknown";
		//s = bkb -> getComponentName(rv_handle);
	if (revision -> getAssignment(idx) == -1) return "Unknown";
		
	inode_handle = bkb -> getComponentINode(rv_handle, revision -> getAssignment(idx));
	t = bkb -> getINodeState(inode_handle);
	return t;
}

/*char* BKB_API::getAssignment(long rv_idx, long time)
{
	if (revision==NULL) return "Unknown";
	
	BKB_handle rv_handle;
	BKB_handle inode_handle;
	char* t = NULL;
	
	rv_handle = bkb -> getComponentHandle(rv_idx);
	//s = bkb -> getComponentName(rv_handle);
	if (revision -> getAssignment(rv_idx) == -1) 
	{
	//	cout << "Null";
		return "Unknown";
	}
	
	MATH_PACK st = getStartTime(rv_idx);
	MATH_PACK ed = getEndTime(rv_idx);
	if (ed!=0 && (time<st || time>ed))
	{
		return "Unknown";
	}
	
	inode_handle = bkb -> getComponentINode(rv_handle, revision -> getAssignment(rv_idx));
	
	t = bkb -> getINodeState(inode_handle);
	return t;
}*/

void BKB_API::beliefUpdate()
{
	checkEviConsistency();
	update = BKBR_updating(bkb -> getGateWay(), num_evidence, evidence,
					num_marg_evidence, marg_evidence, DIAG_LVL, cout);
	
	//return revision;
}

MATH_PACK BKB_API::getProbability(long rv_idx, long state_idx)
{

					
	return (update -> getProbability(rv_idx, state_idx));
}

MATH_PACK BKB_API::getProbability(char* rv_str, char* state_str)
{
	BKB_handle rv_handle;
	BKB_handle inode_handle;
	char* t = NULL;
	long j;
	long rv_idx = -1;	
	long state_idx = -1;	
	
	rv_handle = bkb -> getComponentHandle(rv_str);
	rv_idx = bkb -> getComponentIndex(rv_handle);
	//cout << rv_idx << "\n";
	if (rv_idx<0) return NULL;
	
	for (j=0; j<bkb -> getComponentNumberINodes(rv_handle); j++) {
				inode_handle = bkb -> getComponentINode(rv_handle, j);
				t = bkb -> getINodeState(inode_handle);
				if (!strcmp(state_str, t)){
					state_idx = j;
					break;
				}
				
	}
	//cout << state_idx << "\n";
	if (state_idx<0) return NULL;
	//inode_handle = bkb -> getComponentINode(rv_handle, state_str);
		//return (update -> getProbability(i, j));
	return (update -> getProbability(rv_idx, state_idx));
}

MATH_PACK BKB_API::getWorldProbability()
{
	if (revision!=NULL)
		return revision -> getProbability();
	else
		return -1;
	
}

/*bool setSNodeDLS(BKB_handle snode_handle, CCSS_DLS* dls)
{
	return bkb -> setSNodeDLS(snode_handle, dls);
}*/

bool BKB_API::setINode1StartsAfterINode2Starts(long num_snode, BKB_handle* snode_handle, BKB_handle inode1_handle, BKB_handle inode2_handle, MATH_PACK time)
{
	long i;
	bool valid = true;
	for (i=0; i<num_snode; i++)
	{
		valid = valid & bkb -> startsAfter(snode_handle[i], inode1_handle, inode2_handle, time);
	}
	return valid;
}

bool BKB_API::setINode1StartsAfterINode2Starts(BKB_handle inode1_handle, BKB_handle inode2_handle, MATH_PACK time)
{
	long total_parent1;
	long total_child1;
	long total_child2;
	BKB_handle s_handle1;
	BKB_handle s_handle2;
	long i;
	long j;	
	bool valid = true;
	
	long count = 0;
	total_parent1 = bkb -> getNumberParents(inode1_handle);
	total_child1 = bkb -> getNumberChildren(inode1_handle);
	total_child2 = bkb -> getNumberChildren(inode2_handle);
	//cout << "total: " << total_parent1 << "|" << total_child1 << "|" << total_child2 << "\n";
		
	for (i=0; i<total_child2; i++) {

		s_handle2 = bkb -> getChild(inode2_handle, i);
		for (j=0; j<total_parent1; j++) {
			
			s_handle1 = bkb -> getParent(inode1_handle, j);
			if (s_handle1==s_handle2)
			{
				//cout << "Find: " << s_handle1 << "\n";
				bool result = bkb -> startsAfter(s_handle1, inode1_handle, inode2_handle, time);
				count = count+1;
				valid = valid & result;//i=total_parent1;
				
				//cout << "count: " << count << "\n";
				//break;
			}
		}
		for (j=0; j<total_child1; j++) {
					
			s_handle1 = bkb -> getChild(inode1_handle, j);
			if (s_handle1==s_handle2)
			{
				//cout << "Find: " << s_handle1 << "\n";
				bool result = bkb -> startsAfter(s_handle1, inode1_handle, inode2_handle, time);
				count = count+1;
				valid = valid & result;//i=total_parent1;
				//cout << "count: " << count << "\n";
				//break;
			}
		}
	}
	//cout << "Total s-nodes found: " << count << "\n";
	if (count==0)
		return false;
	//if (s_handle1!=s_handle2) 
	//	return false;
	//else
	return valid;//bkb -> startsAfter(s_handle1, inode1_handle, inode2_handle, time);
}

bool BKB_API::setINode1StartsAfterINode2Starts(long rv1_idx, long state1_idx, long rv2_idx, long state2_idx, MATH_PACK time)
{
	
	BKB_handle rv1_handle;
	BKB_handle inode1_handle;
	BKB_handle rv2_handle;
	BKB_handle inode2_handle;
	//BKB_handle s_handle1;
	//BKB_handle s_handle2;
	//bool valid = true;
	
	rv1_handle = (*bkb).getComponentHandle(rv1_idx);
	inode1_handle = (*bkb).getComponentINode(rv1_handle, state1_idx);
	//cout << "inode1: " << inode1_handle << "\n";
	rv2_handle = (*bkb).getComponentHandle(rv2_idx);
	inode2_handle = (*bkb).getComponentINode(rv2_handle, state2_idx);
	//cout << "inode2: " << inode2_handle << "\n";
	
	return setINode1StartsAfterINode2Starts(inode1_handle, inode2_handle, time);
	
	/*total_parent1 = bkb -> getNumberParents(inode1_handle);
	total_child1 = bkb -> getNumberChildren(inode1_handle);
	total_child2 = bkb -> getNumberChildren(inode2_handle);
	cout << "total: " << total_parent1 << "|" << total_child1 << "|" << total_child2 << "\n";
	
	for (i=0; i<total_child2; i++) {

		s_handle2 = bkb -> getChild(inode2_handle, j);
		for (j=0; j<total_parent1; j++) {
			
			s_handle1 = bkb -> getParent(inode1_handle, j);
			if (s_handle1==s_handle2)
			{
				valid = valid & bkb -> startsAfter(s_handle1, inode1_handle, inode2_handle, time);//i=total_parent1;
				//break;
			}
		}
		for (j=0; j<total_child1; j++) {
					
			s_handle1 = bkb -> getChild(inode1_handle, j);
			if (s_handle1==s_handle2)
			{
				valid = valid & bkb -> startsAfter(s_handle1, inode1_handle, inode2_handle, time);//i=total_parent1;
				//break;
			}
		}
	}
	if (s_handle1!=s_handle2) 
		return false;
	else
		return valid;//bkb -> startsAfter(s_handle1, inode1_handle, inode2_handle, time);*/
	
}

bool BKB_API::setINode1StartsAfterINode2Starts(char* rv1_str, char* state1_str, char* rv2_str, char* state2_str, MATH_PACK time)
{
	BKB_handle rv1_handle;
	BKB_handle rv2_handle;
	BKB_handle inode1_handle;
	BKB_handle inode2_handle;
	char* t = NULL;
	long j;
	long rv1_idx = -1;	
	long state1_idx = -1;	
	long rv2_idx = -1;	
	long state2_idx = -1;	
		
	//rv1_handle = bkb -> getComponentHandle(rv1_str);
	//rv1_idx = bkb -> getComponentIndex(rv1_handle);
	//rv2_handle = bkb -> getComponentHandle(rv2_str);
	//rv2_idx = bkb -> getComponentIndex(rv2_handle);
	//cout << rv_idx << "\n";
	//if (rv1_idx<0 || rv2_idx) return false;
		
	//for (j=0; j<bkb -> getComponentNumberINodes(rv1_handle); j++) {
				//inode1_handle = bkb -> getComponentINode(rv1_handle, state1_str);
				inode1_handle = getINodeHandle(rv1_str, state1_str);
				//t = bkb -> getComponentName(rv1_handle);
				//cout << "NAME: " << t << "\n";
				//t = bkb -> getINodeState(inode1_handle);
				//cout << "State: " << t << "\n";
	//			if (!strcmp(state1_str, t)){
	//				state1_idx = j;
	//				break;
	//			}
					
	//}
	
	//for (j=0; j<bkb -> getComponentNumberINodes(rv2_handle); j++) {
				//inode2_handle = bkb -> getComponentINode(rv2_handle, state1_str);
				inode2_handle = getINodeHandle(rv2_str, state2_str);
			//	t = bkb -> getComponentName(rv2_handle);
							//	cout << "NAME: " << t << "\n";
							//	t = bkb -> getINodeState(inode2_handle);
							//	cout << "State: " << t << "\n";
	//			t = bkb -> getINodeState(inode2_handle);
	//			if (!strcmp(state2_str, t)){
	//				state2_idx = j;
	//				break;
	//			}
						
	//}
	//cout << state_idx << "\n";
	//if (state1_idx<0 || state2_idx<0) return false;
	
	return setINode1StartsAfterINode2Starts(inode1_handle, inode2_handle, time);
	
	
	
}


//void										consistencyCheckOn(bkb->consistencyCheckOn())

multimap<BKB_handle, Error_status> BKB_API::getErrorList(){
	return node_list;
}

vector<Error_status> BKB_API::getErrorStatus(BKB_handle node_handle){
	vector<Error_status> nodeError;
	if((int)node_list.count(node_handle)==0)
		return nodeError;
	
	multimap<BKB_handle, Error_status>::iterator it;
	pair<multimap<BKB_handle, Error_status>::iterator,multimap<BKB_handle,Error_status>::iterator> ret;
	
	
	ret = node_list.equal_range(node_handle);
	for (it=ret.first; it!=ret.second; ++it)
	    nodeError.push_back((Error_status)(*it).second);
	return nodeError;
		/*	it = node_list.find(node);
			  if(it != node_list.end()) { // found a name
				  return (Error_status)it->second;
			     // cout << "A=Yes" << ", " << it->second;
			      //cout << endl;
			     // p++;
			    //} //while (p != names.upper_bound(n));
			  } else {return Error_NoError;}*/
}

vector<Error_status> BKB_API::getINodeErrorStatus(long rv_idx, long state_idx){
	BKB_handle rv_handle = (*bkb).getComponentHandle(rv_idx);
	BKB_handle inode_handle = (*bkb).getComponentINode(rv_handle, state_idx);
	
	return getErrorStatus(inode_handle);
}

void BKB_API::printErrorMessage(Error_status errors){
	switch(errors){
	case Error_INodeNoSNode:
		cout << "Error_INodeNoSNode\n";
		break;
	case Error_SNodeNoINode:
		cout << "Error_SNodeNoINode\n";
		break;
	case Error_SNodeSupportsMultipleINodes:
		cout << "Error_SNodeSupportsMultipleINodes\n";
		break;
	case Error_ComponentDependentOnSelf:
		cout << "Error_ComponentDependentOnSelf\n";
		break;
	case Error_INodeCycle:
		cout << "Error_INodeCycle\n";
		break;
	case Error_MutualExclusivityProblem:
		cout << "Error_MutualExclusivityProblem\n";
		break;
	case Error_SNodeBucketSumExceedsOne:
		cout << "Error_SNodeBucketSumExceedsOne\n";
		break;
	case Error_ComponentConflictInSNode:
		cout << "Error_ComponentConflictInSNode\n";
		break;
	}
	return;
}

void BKB_API::printErrorMessage(Evidence_status status){
	switch(status){
		case Evidence_valid:
			cout << "Evidence valid\n";
			break;
		case Evidence_overload:
			cout << "Number of evidence is more than defined.\n";
			break;
		case Evidence_exist:
			cout << "Evidence is already set in the R.V.\n";
			break;
	}
}

void BKB_API::doConsistencyCheck(){
	
	//ofstream out(filename);
	//bkb -> consistencyCheckOn();
	//cout << "BKB consistency check is " << bkb -> constraint_checking << "\n";
	//bkb -> doConsistencyCheck();
	node_list.clear();
	long statusNum = bkb -> getGateWay()->getLengthStatusLine();
	if (statusNum<1)
	{
		//out << "No error\n";
		cout << "@@@@@@@@@@@@@@@@@@@@@@@@@@ NO ERROR\n";
		return;
	}
	char* errorMessage[statusNum];
	
	//cout << "BKB consistency number is " << statusNum << "\n";
	BKB_gateway *gw = bkb -> getGateWay();
	
	
	
	for (long i=0; i<statusNum; i++)
	{
		//out << "error" << i << "\n";
		BKB_sdu *status = gw -> getStatus(i);
	//	cout << "Status " << i << "\n";
		if (status -> getStatusCode()==BKB_null_msg_sdu) 
		{
		//	cout << "Checked: BKB_null_msg_sdu \n";
			//out << "NULL messgae \n";
		} else if (status -> getStatusCode()==BKB_INodeNoSNode) 
		{
			//cout << "Checked:BKB_INodeNoSNode \n";
							//cout << "inode handle: " << ((BKB_sdu_INodeNoSNode*)status) -> getINodeHandle() << "\n";
							BKB_handle inode = ((BKB_sdu_INodeNoSNode*)status) -> getINodeHandle();
							char* inode_name = bkb -> getComponentName(bkb -> getINodeComponentHandle(inode));
							char* inode_state = bkb -> getINodeState(inode);
							//cout << inode_name << "\n";
							//cout << inode_state << "\n";
			//out << "No s-node pointing to i-node: " << inode_name << "=" << inode_state << "\n";
			//node_list[inode] = Error_INodeNoSNode;
			//node_list.insert(multimap<BKB_handle, Error_status>::value_type(inode, Error_INodeNoSNode));
			node_list.insert(std::pair<BKB_handle, Error_status>(inode, Error_INodeNoSNode));

		} else if (status -> getStatusCode()==BKB_SNodeNoINode) 
		{
		//	cout << "Checked:BKB_SNodeNoINode \n";
			//out << "No i-node is pointed by s-node:";
			
			BKB_handle snode = ((BKB_sdu_SNodeNoINode*)status) -> getSNodeHandle();
			MATH_PACK snodes_prob = bkb -> getSNodeProbability(snode);
			//out << snodes_prob << "\n";
			
			node_list.insert(std::pair<BKB_handle, Error_status>(snode, Error_SNodeNoINode));
		} else if (status -> getStatusCode()==BKB_SNodeSupportsMultipleINodes) 
		{
		//	cout << "Checked:BKB_SNodeSupportsMultipleINodes \n";
			//out << "S-node supports multiple i-nodes: ";
			
			BKB_handle snode = ((BKB_sdu_SNodeNoINode*)status) -> getSNodeHandle();
			MATH_PACK snodes_prob = bkb -> getSNodeProbability(snode);
			//out << snodes_prob << "\n";
			
			node_list.insert(std::pair<BKB_handle, Error_status>(snode, Error_SNodeSupportsMultipleINodes));
		} else if (status -> getStatusCode()==BKB_ComponentDependentOnSelf) 
		{
		//	cout << "Checked:BKB_ComponentDependentOnSelf \n";
							
							BKB_handle inode_src = ((BKB_sdu_ComponentDependentOnSelf*)status) -> getINodeSourceHandle();
							char* inode_src_name = bkb -> getComponentName(bkb -> getINodeComponentHandle(inode_src));
							char* inode_src_state = bkb -> getINodeState(inode_src);
							//cout << inode_src_name << "\n";
							//cout << inode_src_state << "\n";
							
							BKB_handle inode_sink = ((BKB_sdu_ComponentDependentOnSelf*)status) -> getINodeSinkHandle();
							char* inode_sink_name = bkb -> getComponentName(bkb -> getINodeComponentHandle(inode_sink));
							char* inode_sink_state = bkb -> getINodeState(inode_sink);
							//cout << inode_sink_name << "\n";
							//cout << inode_sink_state << "\n";
			//out << "Random variable point to itself with different states: " << inode_src_name << "=" << inode_src_state << " points to " << inode_sink_name << "=" << inode_sink_state << "\n";  
		
			BKB_handle snode = ((BKB_sdu_ComponentDependentOnSelf*)status) -> getSNodeHandle();
			node_list.insert(std::pair<BKB_handle, Error_status>(inode_src, Error_ComponentDependentOnSelf));
			node_list.insert(std::pair<BKB_handle, Error_status>(inode_sink, Error_ComponentDependentOnSelf));
			node_list.insert(std::pair<BKB_handle, Error_status>(snode, Error_ComponentDependentOnSelf));
		} else if (status -> getStatusCode()==BKB_INodeCycle) 
		{
		//	cout << "Checked:BKB_INodeCycle \n";
			//out << "I-node cycle: ";				
							long len = ((BKB_sdu_INodeCycle*)status) -> getINodeCycleLength();
							//cout << "length is " << len << "\n";
							char* inodes_name[len];
							char* inodes_state[len];
							for (long j=0; j<len-1; j++)
							{
								BKB_handle inode = ((BKB_sdu_INodeCycle*)status) -> getINodeHandle(j);
								inodes_name[j] = bkb -> getComponentName(bkb -> getINodeComponentHandle(inode));
								inodes_state[j] = bkb -> getINodeState(inode);
								//cout << inodes_name[j] << "\n";
								//cout << inodes_state[j] << "\n";
								//out << inodes_name[j] << "=" << inodes_state[j] << ", ";
								
								node_list.insert(std::pair<BKB_handle, Error_status>(inode, Error_INodeCycle));
								
								//if (j<len-1) {
								BKB_handle snode = ((BKB_sdu_INodeCycle*)status) -> getSNodeHandle(j);
								node_list.insert(std::pair<BKB_handle, Error_status>(snode, Error_INodeCycle));
								//}
								
								/*if (inode==0)
																	cout << "INODE BKB_INODECYCLE ERROR !!!!!!!!!!!!!!!!!!!!!!!!!!!!";
								else if (snode==0)
									cout << "SNODE BKB_INODECYCLE ERROR !!!!!!!!!!!!!!!!!!!!!!!!!!!!";*/
							}
							//out << "form a cycle.\n";
			
		} else if (status -> getStatusCode()==BKB_MutualExclusivityProblem) 
		{
	//		cout << "Checked:BKB_MutualExclusivityProblem\n";
							//cout << "here1\n";
							BKB_handle inode = ((BKB_sdu_MutualExclusivityProblem*)status) -> getINodeHandle();
							//cout << "here2\n";
							char* inode_name = bkb -> getComponentName(bkb -> getINodeComponentHandle(inode));
							//cout << "here3\n";
							char* inode_state = bkb -> getINodeState(inode);
							//cout << inode_name << "\n";
							//cout << inode_state << "\n";
			//out << "Mutual exclusive problem: The parents of " << inode_name << "=" << inode_state << " have a mutual exclusive problem.\n";  
			
			node_list.insert(std::pair<BKB_handle, Error_status>(inode, Error_MutualExclusivityProblem));
			BKB_handle snode1 = ((BKB_sdu_MutualExclusivityProblem*)status) -> getSNodeOneHandle();
			BKB_handle snode2 = ((BKB_sdu_MutualExclusivityProblem*)status) -> getSNodeTwoHandle();
			node_list.insert(std::pair<BKB_handle, Error_status>(snode1, Error_MutualExclusivityProblem));
			node_list.insert(std::pair<BKB_handle, Error_status>(snode2, Error_MutualExclusivityProblem));
							//cout << "here4\n";
		} else if (status -> getStatusCode()==BKB_SNodeBucketSumExceedsOne) 
		{
	//		cout << "Checked:BKB_SNodeBucketSumExceedsOne \n";
			//out << "S-node bucket sum exceeds one: ";
			
			BKB_handle inode = ((BKB_sdu_SNodeBucketSumExceedsOne*)status) -> getComponentHandle();
			char* inode_name = bkb -> getComponentName(inode);
			//cout << inode_name << "\n";
			//out << inode_name << "'s conditional probabilities ";
			
			long len = ((BKB_sdu_SNodeBucketSumExceedsOne*)status) -> getSNodeBucketSize();
			MATH_PACK snodes_prob[len];
										
										for (long j=0; j<len; j++)
										{
											BKB_handle snode = ((BKB_sdu_SNodeBucketSumExceedsOne*)status) -> getSNodeHandle(j);
											snodes_prob[j] = bkb -> getSNodeProbability(snode);
											//cout << snodes_prob[j] << "\n";
											//out << snodes_prob[j] << ", ";
											
											node_list.insert(std::pair<BKB_handle, Error_status>(snode, Error_SNodeBucketSumExceedsOne));
										}
			//out << "sum up more than 1.\n";
		} else if (status -> getStatusCode()==BKB_ComponentConflictInSNode) 
		{
			//cout << "Checked:BKB_ComponentConflictInSNode \n";
			BKB_handle inode1 = ((BKB_sdu_ComponentConflictInSNode*)status) -> getINodeOneHandle();
										char* inode1_name = bkb -> getComponentName(bkb -> getINodeComponentHandle(inode1));
										char* inode1_state = bkb -> getINodeState(inode1);
										//cout << inode1_name << "\n";
										//cout << inode1_state << "\n";
										
										BKB_handle inode2 = ((BKB_sdu_ComponentConflictInSNode*)status) -> getINodeTwoHandle();
										char* inode2_name = bkb -> getComponentName(bkb -> getINodeComponentHandle(inode2));
										char* inode2_state = bkb -> getINodeState(inode2);
										//cout << inode2_name << "\n";
										//cout << inode2_state << "\n";
			//out << "Random variables conflict in s-node: " << inode1_name << "=" << inode1_state << " and " << inode2_name << "=" << inode2_state << " point to the same s-node.\n";
		
			node_list.insert(std::pair<BKB_handle, Error_status>(inode1, Error_ComponentConflictInSNode));
			node_list.insert(std::pair<BKB_handle, Error_status>(inode2, Error_ComponentConflictInSNode));
			BKB_handle snode = ((BKB_sdu_ComponentConflictInSNode*)status) -> getSNodeHandle();
			node_list.insert(std::pair<BKB_handle, Error_status>(snode, Error_ComponentConflictInSNode));
		} else
		{
			//cout << "Checked:Unknown inconsistency error \n";
			//out << "Unknown inconsistency error. \n";
		}

	}
	
	
	
}