///
///     \file  minimal.C
///    \brief  
///   
///   <+DETAILED+>
///   
///  \author  Chinmay Borwankar (), 
///   
///   \internal
///        Created:  03/11/2021
///       Revision:  none
///       Compiler:  gcc
///   Organization:  Astrophysical Sciences Division, Bhabha Atomic Research Centre
///      Copyright:  
///   
///   This source code is released for free distribution under the terms of the
///   GNU General Public License as published by the Free Software Foundation.
/// 

	GTI
GTICreator :: ExtractGlobalGTI(TChain *ch, const char *DataType,Int_t& currentSpell) 
{
	TDirectory *savedir = gDirectory ;
	GTI gti ;
  if(!ch)
    return gti ;
	TString fDataType = DataType ;
	Int_t nsetofcuts ;
	TObjArray *objarr ;
	TCut gcut ;
	if(!ch) {
		Warning("ExtractGlobalGTI","Empty chain") ;
		gti.SetBit(kInvalid) ;
		return gti ;
	}

  // Modify the Cut based on the data type
	if(fDataType.EqualTo("Routine",TString::kIgnoreCase) ) {
		objarr =dynamic_cast<TObjArray*>(fRoutineGlobalCuts.At(currentSpell)) ;
		if(objarr) {
		Int_t ncuts = objarr -> GetEntries() ;
		for ( int i = 0 ; i < ncuts ; ++i ) 
			gcut = gcut && (((CutDescriptor*)objarr -> At(i)) -> fCutStr.GetString().Data()) ;
		}
	}


	else if(fDataType.EqualTo("Critical",TString::kIgnoreCase) ) {
		objarr =dynamic_cast<TObjArray*>(fCriticalGlobalCuts.At(currentSpell)) ;
		if(objarr) {
		Int_t ncuts = objarr -> GetEntries() ;
		for ( int i = 0 ; i < ncuts ; ++i ) 
			gcut = gcut && (((CutDescriptor*)objarr -> At(i)) -> fCutStr.GetString().Data()) ;
		}
	}
	
	else if(fDataType.EqualTo("Wms",TString::kIgnoreCase) ) {
		objarr =dynamic_cast<TObjArray*>(fWmsCuts.At(currentSpell)) ;
		if(objarr) {
		Int_t ncuts = objarr -> GetEntries() ;
		for ( int i = 0 ; i < ncuts; ++i ) 
			gcut = gcut && (((CutDescriptor*)objarr -> At(i)) -> fCutStr.GetString().Data()) ;
		}
	}

	else if(fDataType.EqualTo("Skms",TString::kIgnoreCase) ) {
		objarr =dynamic_cast<TObjArray*>(fSkmsCuts.At(currentSpell)) ;
		if(objarr) {
		Int_t ncuts = objarr -> GetEntries() ;
		for ( int i = 0 ; i < ncuts  ; ++i ) 
			gcut = gcut && (((CutDescriptor*)objarr -> At(i)) -> fCutStr.GetString().Data()) ;
		}
	}

	else if(fDataType.EqualTo("Tcu",TString::kIgnoreCase)) {
		objarr =dynamic_cast<TObjArray*>(fTcuCuts.At(currentSpell)) ;
		if(objarr) {
		Int_t ncuts = objarr -> GetEntries() ;
		for ( int i = 0 ; i <= ncuts  ; ++i ) 
			gcut = gcut && (((CutDescriptor*)objarr -> At(i)) -> fCutStr.GetString().Data()) ;
		}
	}

	else if(fDataType.EqualTo("Event",TString::kIgnoreCase)) {
		objarr =dynamic_cast<TObjArray*>(fTcuCuts.At(currentSpell)) ;
		if(objarr) {
		Int_t ncuts = objarr -> GetEntries() ;
		for ( int i = 0 ; i <= ncuts  ; ++i ) 
			gcut = gcut && (((CutDescriptor*)objarr -> At(i)) -> fCutStr.GetString().Data()) ;
		}
	}

	else {
		Error("ExtractGlobalGTI","Invalid data type") ;
		gti.SetBit(kInvalidObject) ;
		return gti ;
	}

	TBranch *br_sec  , *br_min , *br_hour , *br_mday , *br_mon , *br_year , *br_musec  ;
	Short_t tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year ;
  Int_t stat_sec,stat_min,stat_hour, stat_mday, stat_mon,stat_year, stat_musec ;
	Int_t musec = 0;

	if(
    ((stat_sec = ch -> SetBranchAddress("tm_sec",&tm_sec,&br_sec)) < 0) ||
		((stat_min = ch -> SetBranchAddress("tm_min",&tm_min,&br_min)) < 0) ||
		((stat_hour = ch -> SetBranchAddress("tm_hour",&tm_hour,&br_hour)) < 0) ||
		((stat_mday = ch -> SetBranchAddress("tm_mday",&tm_mday,&br_mday) ) < 0) ||
		((stat_mon = ch -> SetBranchAddress("tm_mon",&tm_mon,&br_mon)) < 0) ||
		((stat_year = ch -> SetBranchAddress("tm_year",&tm_year,&br_year)<0 ))
/*       !(br_sec = ch -> GetBranch("tm_sec")) ||
 * 		!(br_min = ch -> GetBranch("tm_min")) ||
 * 		!(br_hour = ch -> GetBranch("tm_hour")) ||
 * 		!(br_mday = ch -> GetBranch("tm_mday")) ||
 * 		!(br_mon = ch -> GetBranch("tm_mon")) ||
 * 		!(br_year = ch -> GetBranch("tm_year"))
 */
			) {
			Error("ExtractGlobalGTI","Could not find time branches");
      Error("ExtractGlobalGTI","Status are : %d %d %d %d %d %d ",stat_sec,stat_min,stat_hour,
          stat_mday,stat_mon,stat_year) ;
			gti.Clear() ;
			gti.SetBit(kInvalidObject) ;
			return gti ;
	}
/* 	else {
 * 		ch -> SetBranchAddress("tm_sec",&tm_sec,&br_sec) ;
 * 		ch -> SetBranchAddress("tm_min",&tm_min,&br_min) ;
 * 		ch -> SetBranchAddress("tm_hour",&tm_hour,&br_hour) ;
 * 		ch -> SetBranchAddress("tm_mday",&tm_mday,&br_mday) ;
 * 		ch -> SetBranchAddress("tm_mon",&tm_mon,&br_mon) ;
 * 		ch -> SetBranchAddress("tm_year",&tm_year,&br_year) ;
 * 	} 
 */

	if(fDataType.EqualTo("Event",TString::kIgnoreCase)) {
		if(	(ch -> SetBranchAddress("Musec",&musec,&br_musec))
//        !(br_musec = ch -> GetBranch("Musec"))
        ) {
			Error("ExtractGlobalGTI","Could not find Micro seconds branch for event data");
			gti.Clear() ;
			gti.SetBit(kInvalidObject) ;
			return gti ;
		}
//		else {
//			ch -> SetBranchAddress("Musec",&musec,&br_musec) ;
//		}
	}

  //Create the TEntryList for processing
  int draw_status ;
  TString entrylistname = TString::Format(">>elist_%s",fDataType.Data()) ;
  
	if((draw_status = ch -> Draw(entrylistname.Data(),gcut,"entrylist")) < 0) {
		Error("ExtractGlobalGTI","Entrylist could not be created") ;
		gti.SetBit(kInvalidObject) ;
		return gti ;
	}
	if(draw_status == 0) {
		Error("ExtractGlobalGTI","Empty entrylist for data type %s",fDataType.Data()) ;
		gti.SetBit(kInvalidObject) ;
		return gti ;
	}

  entrylistname = entrylistname(2,entrylistname.Length()) ;
	TEntryList *enl = (TEntryList*)(gDirectory -> Get(entrylistname.Data())) ;
  Info("ExtractGlobalGTI","Is the chain owner of entrylist %s ? %s",
      enl->GetName(),enl -> TestBit(kCanDelete) ? "Yes":"No") ;
	if(enl) {
    enl -> Print() ;
    ch -> SetEntryList(enl) ;
//    enl -> SetBit(kCanDelete,false) ;
  }
  Info("ExtractGlobalGTI","Is the chain owner of entrylist %s ? %s",
      ch->GetEntryList()->GetName(),ch -> GetEntryList() -> TestBit(kCanDelete) ? "Yes":"No") ;
//============== INTERESTING THING IS CHAIN IS NOT THE OWNER OF THE TENTRYLIST ==============
//============== ACCORDING TO OUTPUT I GET ==================================================


//  ch-> ResetBranchAddresses() ;

  // Beyond this point process the tentrylist
  // Rest of the part extracts the good time intervals (GTI) of the data
  Long64_t var1 ;
	Long64_t cur_met_start = 1, cur_met_stop = -1 ;
	Long64_t cur_entry , prev_entry = -2 ;
	Long64_t next_chain_entry = 1 , cur_chain_entry = 0 ;
	Long64_t listEntries = enl -> GetN() ;
	Long64_t localEntry, treeEntry, nextEntry, entry ;
	Int_t treeNum ;

	for ( entry = 0 ; entry < listEntries ; ++entry ) {

	//Find first occurence of consecutive chain entries in the entrylist since current value of 'entry'
		while ( entry < listEntries ) {
			treeEntry = enl -> GetEntryAndTree(entry,treeNum) ;
			cur_chain_entry = treeEntry + ch -> GetTreeOffset()[treeNum] ;
			if((entry+1) >= listEntries)
				break ;
			treeEntry = enl -> GetEntryAndTree(entry + 1,treeNum) ;
			next_chain_entry = treeEntry + ch -> GetTreeOffset()[treeNum] ; 
			if(next_chain_entry > (cur_chain_entry + 1)) 
				++entry ;
			else if(next_chain_entry == (cur_chain_entry + 1)) {
				if(ChangeTI(ch,treeNum) > 0) 
					++entry ;
				else 
					break ;
			}
			else {
				Error("ExtractGlobalGTIFor","Asynchronous TChain") ;
				gti.Clear() ;
				gti.SetBit(kInvalidObject) ;
				return gti ;
			}
		}
//	The time corresponding to cur_chain_entry is the start_met of the 
//	upcoming interval in the gti list
		localEntry = ch -> LoadTree(cur_chain_entry) ;
		//br -> GetEntry(localEntry) ;
		br_sec -> GetEntry(localEntry) ;
		br_min -> GetEntry(localEntry) ;
		br_hour -> GetEntry(localEntry) ;
		br_mday -> GetEntry(localEntry) ;
		br_mon -> GetEntry(localEntry) ;
		br_year -> GetEntry(localEntry) ;
		if(fDataType.EqualTo("Event",TString::kIgnoreCase))
			br_musec -> GetEntry(localEntry) ;
		//cur_met_start = var1 ;
		cur_met_start = GTI :: ConvertToMet(tm_year+2000,tm_mon,tm_mday,tm_hour,
				tm_min,tm_sec,musec) ;
//	From this point at least 2 entries in entrylist are consecutive
//	Find all such entries and append the corresponding time interval
//	to gti
		while ( entry < listEntries ) {
			treeEntry = enl -> GetEntryAndTree(entry,treeNum) ;
			cur_chain_entry = treeEntry + ch -> GetTreeOffset()[treeNum] ;
			if((entry+1) >= listEntries)
				break ;
			treeEntry = enl -> GetEntryAndTree(entry + 1,treeNum) ;
			next_chain_entry = treeEntry + ch -> GetTreeOffset()[treeNum] ; 
			if(ChangeTI(ch,treeNum) > 0) {
			// If directories (spells of observation) have changed 
			// between cur_chain_entry and next_chain_entry then 
			// make appropriate adjustment to GTI
				localEntry = ch -> LoadTree(cur_chain_entry) ;
				//ch -> GetEntry(localEntry) ;
				br_sec -> GetEntry(localEntry) ;
				br_min -> GetEntry(localEntry) ;
				br_hour -> GetEntry(localEntry) ;
				br_mday -> GetEntry(localEntry) ;
				br_mon -> GetEntry(localEntry) ;
				br_year -> GetEntry(localEntry) ;
				if(fDataType.EqualTo("Event",TString::kIgnoreCase))
					br_musec -> GetEntry(localEntry) ;
				//cur_met_stop = var1 ;
				cur_met_stop = GTI :: ConvertToMet(tm_year+2000,tm_mon,tm_mday,tm_hour,
				tm_min,tm_sec,musec) ;
				gti.AppendTimeInterval(cur_met_start,cur_met_stop,true) ;
				break ;

//				localEntry = ch -> LoadTree(next_chain_entry) ;
//				br -> GetEntry(localEntry) ;
//				cur_met_start = var1 ;
			}

			if(next_chain_entry == (cur_chain_entry + 1)) 
				++entry ;
			else if(next_chain_entry > (cur_chain_entry + 1)) {
				localEntry = ch -> LoadTree(cur_chain_entry) ;
				//br -> GetEntry(localEntry) ;
				br_sec -> GetEntry(localEntry) ;
				br_min -> GetEntry(localEntry) ;
				br_hour -> GetEntry(localEntry) ;
				br_mday -> GetEntry(localEntry) ;
				br_mon -> GetEntry(localEntry) ;
				br_year -> GetEntry(localEntry) ;
				if(fDataType.EqualTo("Event",TString::kIgnoreCase))
					br_musec -> GetEntry(localEntry) ;
//				cur_met_stop = var1 ;
				cur_met_stop = GTI :: ConvertToMet(tm_year+2000,tm_mon,tm_mday,tm_hour,
				tm_min,tm_sec,musec) ;

				gti.AppendTimeInterval(cur_met_start,cur_met_stop) ;
				break ;
			}
			else {
				Error("ExtractGlobalGTIFor","Asynchronous TChain") ;
				gti.Clear() ;
				gti.SetBit(kInvalidObject) ;
				return gti ;
			}
		}

//	To take care of the case where last time interval ends on the 
//	last entry in the entrylist
		if(entry == (listEntries - 1)) {
			localEntry = ch -> LoadTree(cur_chain_entry) ;
//			br -> GetEntry(localEntry) ;
			br_sec -> GetEntry(localEntry) ;
			br_min -> GetEntry(localEntry) ;
			br_hour -> GetEntry(localEntry) ;
			br_mday -> GetEntry(localEntry) ;
			br_mon -> GetEntry(localEntry) ;
			br_year -> GetEntry(localEntry) ;
			if(fDataType.EqualTo("Event",TString::kIgnoreCase))
				br_musec -> GetEntry(localEntry) ;
//			cur_met_stop = var1 ;
			cur_met_stop = GTI :: ConvertToMet(tm_year+2000,tm_mon,tm_mday,tm_hour,
				tm_min,tm_sec,musec) ;

			gti.AppendTimeInterval(cur_met_start,cur_met_stop) ;
		}
	} // END of for loop
 
  // ================ IF WE DONT KEEP THIS LINE, CODE CODE CRASHES AT THE END ================
  // ================ WHEN THE INPUT TCHAIN IS DELETED BY A DESTRUCTOR =======================
  ch -> SetEntryList(0) ;
  gti.SetBit(kInvalidObject,false) ;
	return gti ;
}