/*--------------------------------------------------*/
// Program for analysing the omega data 
// Author: wl
// Email: wenliang.billlee@gmail.com

#include <iostream>
#include "root_anna_pl.h"


using namespace std;

int main() {


	Initialization();

//	eff_setting = rf->eff_pro1;

//    Analysis *anna = new Analysis();

	File_Output *fo = new File_Output();
	
//	fo->Create_Out_File();

//	anna->file_out_anna = fo->file_out;

	Int_t iii = 0;

	Int_t ii = 0;
	
	for (Int_t i = 0; i < set_runs; i++) {
		

// 		dir_name.Form("%i", i);
// 
// 		fo->file_out->mkdir(dir_name);

		if (kin_setting.polset[i] > 0) {
//  			cout << Dummy_Name(i) << endl;
//  			cout << Target_Name(i) << endl;
// 			cout << List_Name(i) << endl;
//			cout << list_name << endl;



			/*--------------------------------------------------*/
			/// Dummy run setting up
			//
			output_file[iii] = fo->Create_Out_File(Dummy_Name(i));

			output_file_dummy[ii] = fo->Create_Out_File(Dummy_Name(i));

			list_name = list_dir + "list.dummy_" + List_Name(i) + "_plus";
			lists_vec_itt = find (lists_vec.begin(), lists_vec.end(), list_name);

			if(lists_vec_itt == lists_vec.end()) {

				// cout << ":::::: :: " << iii << endl;			

				lists_vec.push_back(list_name);
				rf->Eff_file_loading(list_name);

				num_runs = rf->Get_Num_Runs();
				run_list_vec.push_back(num_runs);
	
				Q2_vec.push_back(List_Name(i));

				/// Mod
				lists_vec_dummy.push_back(list_name);
 				run_list_vec_dummy.push_back(num_runs);

			}

			eff_setting[iii] = rf->eff_pro1;


			anna[iii] = new Analysis(rf->eff_pro1);
			setting_run_list.push_back(vector<int>());

			eff_setting_dummy[ii] = rf->eff_pro1;
//			anna_dummy[ii] = new Analysis(rf->eff_pro1);

			rf->Ntuple_Reset();

			iii++;


			/*--------------------------------------------------*/
			/// Dummy run setting up
			/// Variable Traget_Name(i) says if the file is dummy or target data file
			//

			output_file[iii] = fo->Create_Out_File(Target_Name(i));

			output_file_target[ii] = fo->Create_Out_File(Dummy_Name(i));

			list_name = list_dir + "list.target_" + List_Name(i) + "_plus";
			lists_vec_itt = find (lists_vec.begin(), lists_vec.end(), list_name);

			if(lists_vec_itt == lists_vec.end()) {

				lists_vec.push_back(list_name);
				rf->Eff_file_loading(list_name);

				num_runs = rf->Get_Num_Runs();
				run_list_vec.push_back(num_runs);
				Q2_vec.push_back(List_Name(i));

				/// Mod
				lists_vec_target.push_back(list_name);
 				run_list_vec_target.push_back(num_runs);

			}


			Q2_vec_mod_itt = find(Q2_vec_mod.begin(), Q2_vec_mod.end(), List_Name(i));

			if(Q2_vec_mod_itt == Q2_vec_mod.end()) {
				Q2_vec_mod.push_back(List_Name(i));
			}

			cout << "List name: "<< List_Name(i) <<endl;

			eff_setting[iii] = rf->eff_pro1;

			anna[iii] = new Analysis(rf->eff_pro1);
			setting_run_list.push_back(vector<int>());


			eff_setting_target[ii] = rf->eff_pro1;
//			anna_target[ii] = new Analysis(rf->eff_pro1);



			rf->Ntuple_Reset();

 			cout << Dummy_Name(i) << endl;
 			cout << Target_Name(i) << endl;

			setting_vec.push_back(Dummy_Name(i));
			setting_vec.push_back(Target_Name(i));

			setting_vec_dummy.push_back(Dummy_Name(i));
			setting_vec_target.push_back(Target_Name(i));

			iii++;

			ii++;

		}
			
	}


	cout << " End Loop Size Check:  " << iii << endl;
	
	setting_run_list.resize(iii);

	setting_run_list_dummy.resize(ii);
	setting_run_list_target.resize(ii);

	/*--------------------------------------------------*/
	/// List check out

	Cout_out_lists();


	cout << "/*--------------------------------------------------*/" << endl;
	cout << "/*--------------------------------------------------*/" << endl;
	cout << "/*--------------------------------------------------*/" << endl;



	cout << run_list_vec_dummy.size() << "        " << setting_vec_dummy.size() << endl;
	cout << run_list_vec_dummy[0] << "        " << run_list_vec_dummy[1] << endl;
	cout << run_list_vec.size() << "        " << setting_vec.size() << endl;



// 	/*--------------------------------------------------*/
// 	/// Setting up the setting_run_list for the Dummy runs
// 
// 	for (int i=0;  i < run_list_vec_dummy.size(); i++) {
// 
// 	    for (int ii = 0; ii < run_list_vec_dummy[i]; ii++) { 
// 
// 			int setting_num_tmp;
// 
// 			for (int iii = 0; iii < setting_vec_dummy.size(); iii++) {
// 				setting_num_tmp = Return_Setting_dummy(i, ii, iii);
// 			}
// 
// 			setting_run_list_dummy[setting_num_tmp].push_back(ii);
// 
//    	 	}	
// 	}
// 
// 
// 	/*--------------------------------------------------*/
// 	/// Setting up the setting_run_list for the Target runs
// 
// 	for (int i=0;  i < run_list_vec_target.size(); i++) {
// 
// 	    for (int ii = 0; ii < run_list_vec_target[i]; ii++) { 
// 
// 			int setting_num_tmp;
// 
// 			for (int iii = 0; iii < setting_vec_target.size(); iii++) {
// 				setting_num_tmp = Return_Setting_target(i, ii, iii);
// 			}
// 
// 			setting_run_list_target[setting_num_tmp].push_back(ii);
// 
//    	 	}	
// 	}
// 
// 	Dummy_Analysis();
// 
// 
// 
// 
// 
// 













	cout << endl << endl << endl;


	/*--------------------------------------------------*/
	/// Setting up the setting_run_list for All runs

	for (int i=0;  i < run_list_vec.size(); i++) {


	    for (int ii = 0; ii < run_list_vec[i]; ii++) { 

			int setting_num_tmp;
				
			for (int iii = 0; iii < setting_vec.size(); iii++) {


//				if (run_list_vec[ii] != 0) { 
				
					//cout << setting_vec[i] << "    "<< run_list_vec[ii] << "    " << iii << endl;

				
//		 		cout << Return_Setting(i, ii, iii) << "       " << iii<< endl;

//				cout << "*****************" << endl;
//				cout << i << "     " << ii  << "      " << run_list_vec[i] << "    "  << setting_vec[i] << endl;
//				cout << "*********************************" << endl;


//				cout << i << "    " << ii << "    " << iii << endl;

				setting_num_tmp = Return_Setting(i, ii, iii);

//				cout << i << "   " << ii << " :: " << iii << "    " << setting_num_tmp << endl;

//				cout << "++++++++ " << setting_num_tmp << endl;

			}


			setting_run_list[setting_num_tmp].push_back(ii);

   	 	}	

	}








 
 	for (int i = 0; i < setting_run_list.size(); i++) {

// 		if (i%2 == 0) {
// 			cout << i << "  Target:   " << setting_run_list[i].size()<< endl;
//  		} else {
// 			
// 		}

		for (int ii=0;  ii < setting_run_list[i].size(); ii++) {

			cout << "MMMMMMMMM:  " << i << "    " << ii << "     "<< setting_run_list[i][ii] << endl;

		}

 	}




// 
// //	cout << "sssssssssss" << eff_setting[6].epsset[0] << endl;
// 
// 
// 	for (int i=0;  i < run_list_vec.size() ;i++) {
// 
// 
// //		cout << ""<< i << endl;
// 
// //		if (run_list_vec[i] != 0) { 
// 
// 		    for (int ii = 0; ii < run_list_vec[i]; ii++) { 
// 
// 
// 			//	cout << i << "     " << ii << endl;
// 			    cout << Return_Setting(i, ii) << endl;
// 
// 				setting_run_list[Return_Setting(i, ii)].push_back(ii);
// 				
// 
//    			}
// 
// //		}
// 
// 	}
// 

/*--------------------------------------------------*/
/*--------------------------------------------------*/
/*--------------------------------------------------*/
/*--------------------------------------------------*/

//	int r_itt = 0;


	/*--------------------------------------------------*/
	/// Analyzing data run by run

	for(int i = 0; i < setting_run_list.size(); i++) {

			

		if (setting_run_list[i].size() != 0 ) {

			anna[i]->file_out_anna =  output_file[i];

			for (int ii = 0; ii < setting_run_list[i].size(); ii++) {
	
				// cout << "asdasdasdas " << setting_run_list[i][ii] << endl;

				anna[i]->Testtest(setting_run_list[i][ii]);

// 				cout << "* Real itt: "<< r_itt << "     " << setting_run_list.size() << "    " 
// 					 << setting_run_list[i][ii]<< endl; 
// 
// 				r_itt++;	
 
			}

  			anna[i]->Yield_Out();

		}

	}

	/*--------------------------------------------------*/


	// cout << setting_run_list[0][0] << "    " << setting_run_list[0][1] << endl;




//     for (Int_t ii = 0; ii < num_runs; ii++) { 
//	   		anna->Testtest(ii);
//     }










//		if ( kin_setting.polset[i] > 0) {

		

// 			for (int itar = 0; itar < 2 ;itar++) {
// 
// 				cout << kin_setting.polset[i] << "    " << kin_setting.Q2set[i] << endl;
// 
// 			}
// 
// 		}
// 
 	
// 




//     for (Int_t ii = 0; ii < num_runs; ii++) { 
//		anna->Testtest(ii);
//     }
// 
//



	return 0;

}


/*--------------------------------------------------*/
/*--------------------------------------------------*/
// Initialization 
//

void Initialization() {

	rf = new ReadFile;

	kin_setting = rf->kin_pro;
//	eff_setting = rf->eff_pro;
	cen_setting = rf->cen_pro;

//	num_runs = rf->Get_Num_Runs();

	set_runs = rf->Get_Set_Runs();

	dummy_tar = rf->Get_Dummy(); 

 	output_file = new TFile*[set_runs];
 	anna 		= new Analysis*[set_runs];
 	eff_setting = new ReadFile::eff_pro[set_runs];


	/*--------------------------------------------------*/
	/// Mod

	
 	output_file_dummy  = new TFile*[set_runs];
 	output_file_target = new TFile*[set_runs];

// 	anna_dummy 	       = new Analysis*[set_runs];
// 	anna_target        = new Analysis*[set_runs];

 	eff_setting_dummy  = new ReadFile::eff_pro[set_runs];
 	eff_setting_target = new ReadFile::eff_pro[set_runs];


	cout << "Set Runs !!!  : " << set_runs << endl;

	list_dir 			= "lists/";
	
}




/*--------------------------------------------------*/
/*--------------------------------------------------*/

TString Dummy_Name(int num_itt) {

	TString dir_str;

	if (int(kin_setting.thpqset[num_itt]*1000) == 0) {

		dir_str.Form("yields.pl_%i_%i_0000.dummy", int(kin_setting.Q2set[num_itt]*100), int(kin_setting.epsset[num_itt]*100));	

	} else {

		dir_str.Form("yields.pl_%i_%i_%i.dummy", int(kin_setting.Q2set[num_itt]*100), int(kin_setting.epsset[num_itt]*100), int(kin_setting.thpqset[num_itt]*1000));	

	}

	return dir_str;

}




/*--------------------------------------------------*/
/*--------------------------------------------------*/

TString Target_Name(int num_itt) {

	TString dir_str;

	if (int(kin_setting.thpqset[num_itt]*1000) == 0) {

		dir_str.Form("yields.pl_%i_%i_0000.target", int(kin_setting.Q2set[num_itt]*100), int(kin_setting.epsset[num_itt]*100));	

	} else {

		dir_str.Form("yields.pl_%i_%i_%i.target", int(kin_setting.Q2set[num_itt]*100), int(kin_setting.epsset[num_itt]*100), int(kin_setting.thpqset[num_itt]*1000));	

	}

	return dir_str;

}


/*--------------------------------------------------*/
/*--------------------------------------------------*/

TString List_Name(int num_itt) {

	TString dir_str;

	dir_str.Form("%i_%i", int(kin_setting.Q2set[num_itt]*100), int(kin_setting.epsset[num_itt]*100));	

	return dir_str;

}



/*--------------------------------------------------*/
/*--------------------------------------------------*/
/// Return Setting Number for Dummy Runs
int Return_Setting_dummy(int list_itt, int run_itt, int set_itt) {

	Int_t iii = 0;
	
 	TString run_setting_name; 

	if (int(eff_setting_dummy[set_itt].thpqset[run_itt]*1000) == 0) {

		run_setting_name.Form( "yields.pl_" + Q2_vec_mod[list_itt] + "_0000.dummy", int(eff_setting_dummy[set_itt].thpqset[run_itt]*1000)); 

	} else {

		run_setting_name.Form( "yields.pl_" + Q2_vec_mod[list_itt] + "_%i.dummy", int(eff_setting_dummy[set_itt].thpqset[run_itt]*1000));

	}
	
	if (setting_vec_dummy[set_itt] == run_setting_name) {
		cout << setting_vec_dummy[set_itt] << "  " << list_itt << "   " << run_itt  << "  " << set_itt << endl;
		setting_num = set_itt;
	}

	return setting_num;

}


/*--------------------------------------------------*/
/*--------------------------------------------------*/
/// Return Setting Number for Target Runs

int Return_Setting_target(int list_itt, int run_itt, int set_itt) {

	Int_t iii = 0;
	
 	TString run_setting_name; 

	if (int(eff_setting_target[set_itt].thpqset[run_itt]*1000) == 0) {

		run_setting_name.Form( "yields.pl_" + Q2_vec_mod[list_itt] + "_0000.target", int(eff_setting_target[set_itt].thpqset[run_itt]*1000)); 

	} else {

		run_setting_name.Form( "yields.pl_" + Q2_vec_mod[list_itt] + "_%i.target", int(eff_setting_target[set_itt].thpqset[run_itt]*1000));

	}
	
	if (setting_vec_target[set_itt] == run_setting_name) {
		cout << setting_vec_target[set_itt] << "  " << list_itt << "   " << run_itt  << "  " << set_itt << endl;
		setting_num = set_itt;
	}

	return setting_num;

}



/*--------------------------------------------------*/
/*--------------------------------------------------*/

int Return_Setting(int list_itt, int run_itt, int set_itt) {




	// cout << ")))))))))"<< file_itt << "              "<<  eff_setting[6].epsset[0] << endl;



	Int_t iii = 0;
	
 	TString run_setting_name; 
 

	if (int(eff_setting[set_itt].thpqset[run_itt]*1000) == 0) {

		run_setting_name.Form( "yields.pl_" + Q2_vec[list_itt] + "_0000.dummy", int(eff_setting[set_itt].thpqset[run_itt]*1000)); 

	} else {

		run_setting_name.Form( "yields.pl_" + Q2_vec[list_itt] + "_%i.dummy", int(eff_setting[set_itt].thpqset[run_itt]*1000));

	}

	




	// cout << setting_vec[set_itt] << "  " << run_setting_name << endl;
	

	if (setting_vec[set_itt] == run_setting_name) {
		cout << setting_vec[set_itt] << "  " << list_itt << "   " << run_itt  << "  " << set_itt << endl;
		setting_num = set_itt;
	}

	return setting_num;








// // 	cout << "AAAAAAAAAAAAAAAAAA  " << eff_setting[file_itt].epsset[run_itt]*100 << endl;
// // 	cout << "AAAAAAAAAAAAAAAAAA  " << eff_setting[file_itt].thpqset[run_itt]*1000 << endl;
// 
//  	for (Int_t i = 0; i < set_runs; i++) {
// // 
// 		if (kin_setting.polset[i] > 0) {
// // 
// // int(eff_setting[file_itt].	[run_itt]*100) == int(kin_setting.epsset[i]*100)
// 
// 
// 
// //  			if ( int(eff_setting[file_itt].epsset[run_itt]*100) == int(kin_setting.epsset[i]*100)
// //  			 && int(eff_setting[file_itt].thpqset[run_itt]*1000) == int(kin_setting.thpqset[i]*1000)) {
// // 
// // 
// // 				string temp_str;
// // 
// // 				temp_str = lists_vec[file_itt];
// // 
// // 			 	if (temp_str.find("dummy") != string::npos) {
// // 			 		dummy_tar = true;
// // 			 	} else {
// // 					dummy_tar = false;
// // 				}
// // 
// // 				if(dummy_tar == true) {
// // 					setting_num = iii;
// // 				} else {
// // 					setting_num = iii + 1;
// // 				}
// // 				 
// //  			}
// // 
// 
// // 			iii = iii + 2;
// 		
// 			TString run_setting_name; 
// 
// 			run_setting_name.Form( "%i______%i", int(eff_setting[file_itt].epsset[run_itt]*100), int(eff_setting[file_itt].thpqset[run_itt]*1000));
// 
// //			cout << run_setting_name << endl;
// 			
// 
// 
//  		}
//  
//  	}	





	
//  	for (Int_t i = 0; i < setting_vec.size(); i++) {
// 
// 		// cout << set_runs << "              " << setting_vec.size() << endl;
// 		// cout << int(eff_setting[i].epsset[run_itt]*100) << "    " 
// 		// 	 << eff_setting[i].thpqset[run_itt]*1000 << endl;
// 		
// 		TString run_setting_name; 
// 
// 		run_setting_name.Form( "yields.pl_%i_%i_%i.dummy", int(kin_setting.Q2set[i]*100), int(eff_setting[i].epsset[run_itt]*100), int(eff_setting[i].thpqset[run_itt]*1000));
// 
// 		
// 		// cout << run_setting_name << endl;
// 	
// 		if (run_setting_name == setting_vec[i]) {
// 
// 			cout << run_setting_name << endl;
// 			
// 		}
// 
// 	}
// 


}
















void Cout_out_lists() {


	

	cout << endl;
	cout << endl;
	cout << endl;

	/*--------------------------------------------------*/
	/// cout check on the lists 

 	for (int a=0; a < Q2_vec.size(); a++) {
		cout << "Q2 value:  " << a << "    " << Q2_vec[a] << endl;
	}

	cout << endl;

 	for (int a=0; a < Q2_vec_mod.size(); a++) {
		cout << "Q2 value mod:  " << a << "    " << Q2_vec_mod[a] << endl;
	}

	cout << endl;

 	for (int a=0; a < lists_vec.size(); a++) {
		cout << "Run list:  " << a << "    " << lists_vec[a] << endl;
	}

	cout << endl;

 	for (int a=0; a < lists_vec_target.size(); a++) {
		cout << "Target run list:  " << a << "    " << lists_vec_target[a] << endl;
	}

	cout << endl;

 	for (int a=0; a < lists_vec_dummy.size(); a++) {
		cout << "Dummy run list:  " << a << "    " << lists_vec_dummy[a] << endl;
	}

	cout << endl;

 	for (int a=0; a < setting_vec.size(); a++) {
		cout << "Setting list:  " << a << "    " << setting_vec[a] << endl;
	}

	cout << endl;

 	for (int a=0; a < setting_vec_target.size(); a++) {
		cout << "Target Setting list:  " << a << "    " << setting_vec_target[a] << endl;
	}

	cout << endl;

 	for (int a=0; a < setting_vec_dummy.size(); a++) {
		cout << "Dummy Setting list:  " << a << "    " << setting_vec_dummy[a] << endl;
	}

	cout << endl;

 	for (int a=0; a < run_list_vec.size(); a++) {
		cout << "Run list vec:  " << a << "    " << run_list_vec[a] << endl;
	}

	cout << endl;


	for (int a=0; a < run_list_vec_target.size(); a++) {
		cout << "Run list target vec:  " << a << "    " << run_list_vec_target[a] << endl;
	}

	cout << endl;

	for (int a=0; a < run_list_vec_dummy.size(); a++) {
		cout << "Run list dummy vec:  " << a << "    " << run_list_vec_dummy[a] << endl;
	}

	cout << endl;



}



void Dummy_Analysis() {

	/*--------------------------------------------------*/
	/// Analyzing data run by run for the Dummy Runs

	for(int i = 0; i < setting_run_list_dummy.size(); i++) {

		if (setting_run_list_dummy[i].size() != 0 ) {

			anna_dummy[i]->file_out_anna =  output_file_dummy[i];

			for (int ii = 0; ii < setting_run_list_dummy[i].size(); ii++) {
	
				anna_dummy[i]->Testtest(setting_run_list_dummy[i][ii]);

			}

  			anna_dummy[i]->Yield_Out();

		}

	}

	/*--------------------------------------------------*/

}