/// \file
/// \ingroup tutorial_proofntuple
///
/// Selector to fill a simple ntuple
///
/// \macro_code
///
/// \author Gerardo Ganis (gerardo.ganis@cern.ch)

#ifndef SelGetSplitData_h
#define SelGetSplitData_h

#include <TSelector.h>
#include <TBranch.h>
#include <TChain.h>
#include <TTree.h>
#include <TFile.h>
#include <TString.h>
#include <TObjString.h>
#include <TObjArray.h>
#include <TProofOutputFile.h>

class SelGetSplitData : public TSelector {
public :
   TTree          *fChain;   //!pointer to the analyzed TTree or TChain

   // Specific members
   TTree          *fOutTree ;                   //!<!  

   TBranch		  **fBranches ;                 //!<! 

   Float_t		  *fFloatVars ;
   Double_t		  *fDoubleVars ;
   Int_t		  *fIntVars ;
   UInt_t		  *fUIntVars ;
   Short_t		  *fShortVars ;
   UShort_t		  *fUShortVars ;

   Float_t		  *fOutFloatVars ;
   Double_t		  *fOutDoubleVars ;
   Int_t		  *fOutIntVars ;
   UInt_t		  *fOutUIntVars ;
   Short_t		  *fOutShortVars ;
   UShort_t		  *fOutUShortVars ;

   Int_t fNFloats ;
   Int_t fNDoubles ;
   Int_t fNInts ;
   Int_t fNUInts ;
   Int_t fNShorts ;
   Int_t fNUShorts ;

   Int_t fNVars ;
   TString fDataLeavesString ;
   Bool_t kCreateDataSet ;
   TString OutputFileName ;
   TFile *fFile ;
   TProofOutputFile *fProofFile ;



   Bool_t kMembersInitiated ;

   SelGetSplitData(TTree * /* tree */ = 0 ) : fChain(0), fOutTree(0), fBranches(0), fFloatVars(0), fDoubleVars(0),
					fIntVars(0),fUIntVars(0),fShortVars(0),fUShortVars(0),kMembersInitiated(false){ }
   virtual ~SelGetSplitData();
   virtual Int_t   Version() const { return 2; }
   virtual void    Begin(TTree *tree);
   virtual void    SlaveBegin(TTree *tree);
   virtual void    Init(TTree *tree);
   virtual Bool_t  Notify();
   virtual Bool_t  Process(Long64_t entry);
   virtual void    SetOption(const char *option) { fOption = option; }
   virtual void    SetObject(TObject *obj) { fObject = obj; }
   virtual void    SetInputList(TList *input) { fInput = input; }
   virtual TList  *GetOutputList() const { return fOutput; }
   virtual void    SlaveTerminate();
   virtual void    Terminate();

   void InitMembers(const Char_t * dataleaves_str) ;


   ClassDef(SelGetSplitData,0);
};

#endif

#ifdef SelGetSplitData_cxx
void SelGetSplitData::Init(TTree *tree)
{
   // The Init() function is called when the selector needs to initialize
   // a new tree or chain. Typically here the branch addresses and branch
   // pointers of the tree will be set.
   // It is normally not necessary to make changes to the generated
   // code, but the routine can be extended by the user if needed.
   // Init() will be called many times when running on PROOF
   // (once per file to be processed).

   // Set branch addresses and branch pointers
   if (!tree) return;
   fChain = tree;
   fChain->SetMakeClass(1);

	// Set the branch addresses now 
	TString token, subtoken_branch, subtoken_type ;

	Ssiz_t from = 0 ;
	Int_t iF = 0, iD = 0, iI = 0, ii = 0, iS = 0, is = 0 ;
	Int_t fCurrentBranch = 0 ;

	TObjArray *str_arr ;
	TObjString *objStr1, *objStr2 ;

	while ( fDataLeavesString.Tokenize(token,from,":") ) {
		str_arr = token.Tokenize("/") ;
		if(!str_arr) {
			Error("InitMembers","Bad Leaf decsriptor \"%s\"\n",token.Data()) ;
			Abort("") ;
		}
		else {
			objStr1 = (TObjString*)(str_arr->At(0)) ;
			objStr2 = (TObjString*)(str_arr->At(1)) ;
			if(!objStr1 || !objStr2) {
				Error("InitMembers","Bad Leaf decsriptor \"%s\"\n",token.Data()) ;
				Abort("") ;
			}

			else {
				subtoken_branch = objStr1 -> GetString() ;
				subtoken_type = objStr2 -> GetString() ;

				if(subtoken_type.CompareTo("D")) {
					fChain -> SetBranchAddress(subtoken_branch.Data(),&fDoubleVars[iD],&fBranches[fCurrentBranch]) ;
					++iD ;
				}

				else if(subtoken_type.CompareTo("F")) {
					fChain -> SetBranchAddress(subtoken_branch.Data(),&fFloatVars[iF],&fBranches[fCurrentBranch]) ;
					++iF ;
				}

				else if(subtoken_type.CompareTo("I")) {
					fChain -> SetBranchAddress(subtoken_branch.Data(),&fIntVars[iI],&fBranches[fCurrentBranch]) ;
					++iI ;
				}
				
				else if(subtoken_type.CompareTo("i")) {
					fChain -> SetBranchAddress(subtoken_branch.Data(),&fUIntVars[ii],&fBranches[fCurrentBranch]) ;
					++ii ;
				}
				
				else if(subtoken_type.CompareTo("S")) {
					fChain -> SetBranchAddress(subtoken_branch.Data(),&fShortVars[iS],&fBranches[fCurrentBranch]) ;
					++iS ;
				}
				
				else if(subtoken_type.CompareTo("s")) {
					fChain -> SetBranchAddress(subtoken_branch.Data(),&fUShortVars[is],&fBranches[fCurrentBranch]) ;
					++is ;
				}

				else {
					Error("InitMembers","Invalid branch type '%s'\n",subtoken_type.Data()) ;
					Abort("") ;
				}

				++fCurrentBranch ;
				
			}

		}
	}
   
}

Bool_t SelGetSplitData::Notify()
{
   // The Notify() function is called when a new file is opened. This
   // can be either for a new TTree in a TChain or when when a new TTree
   // is started when using PROOF. It is normally not necessary to make changes
   // to the generated code, but the routine can be extended by the
   // user if needed. The return value is currently not used.

   return kTRUE;
}
#endif