#include "TFile.h"
#include <vector>
#include <TGraph.h>
#include "TNtuple.h"
#include <TROOT.h>
#include <TApplication.h>
#include<iostream>
#include <unistd.h>
using namespace std;
bool fexists(const char *filename);
void loop();

Int_t run;
std::vector<std::vector<double> > alleventpmtids;
Int_t indexarray[40000];
TFile* eventfile;

void mainmacro(){
	//fill indexarray, for making up a mock TGraph
	for(int i=0;i<40000;i++){indexarray[i]=i;}
	
	//call the main loop a few times. first time, create the tree. others, append.
	for(Int_t loopcall=0;loopcall<3;loopcall++){
	
		//set the stuff that's going into the tree:
		// an int
		run=loopcall;
		// a vector branch
		alleventpmtids.clear();
		for(int outerfiller=0;outerfiller<run+2;outerfiller++){
			std::vector<double> avec;
			avec.push_back(5);
			for(double innerfiller=0;innerfiller<4;innerfiller++){
				double someval = innerfiller;
				//avec.push_back(someval);
			}
			alleventpmtids.push_back(avec);
		}
		// a TGraph will be created in-situ
		
		loop();
	
}

}


void loop(){
	//declare local variables of the loop
	TGraph* vetotrace;
	Int_t runid=0;
	Int_t eventid=0;
	Int_t eventtrigger=0;
	std::vector<double> eventpmtids;
	vetotrace = new TGraph(40000,indexarray,indexarray);
	// get pointers for setting branch addresses if the tree exists
	Int_t* runidpointer = &runid;
	Int_t* eventidpointer = &eventid;
	Int_t* eventtriggerpointer = &eventtrigger;
	std::vector<double>* eventpmtidspointer = &eventpmtids;
	
	// check if the tree exists
	TTree* eventtree;
	bool existss = fexists("/annie/app/users/moflaher/ANNIEreco/newest_code/testfile.root");
	if(!existss){
		// tree doesn't exist: make it, and create branches
		cout<<"eventtree doesn't exist. making it"<<endl;
		eventfile = new TFile("testfile.root","RECREATE");
		eventtree = new TTree("eventtree","eventtree");
		
		eventtree->Branch("runid",&runid);
		eventtree->Branch("eventid",&eventid);
		eventtree->Branch("eventtrigger",&eventtrigger);
		eventtree->Branch("eventpmtids",&eventpmtids);
		eventtree->Branch("vetotrace",vetotrace);
		
	} else {
		// tree exists; get it, and set branch addresses
		cout<<"eventtree exists, using it."<<endl;
		eventfile = TFile::Open("testfile.root","UPDATE");
		eventtree = (TTree*)eventfile->Get("eventtree");
		
		eventtree->SetBranchAddress("runid",&runidpointer);
		eventtree->SetBranchAddress("eventid",&eventidpointer);
		eventtree->SetBranchAddress("eventtrigger",&eventtriggerpointer);
		eventtree->SetBranchAddress("eventpmtids",&eventpmtidspointer);
		eventtree->SetBranchAddress("vetotrace",&vetotrace);
		
	}
	
	gROOT->cd();
	
	// fill the tree with new entries found in this call
	for(int loopnum=0; loopnum<5; loopnum++){
		*eventidpointer=0;
		*runidpointer=run;
		for(Int_t anevent=0; anevent<alleventpmtids.size(); anevent++){
			*eventidpointer = (*eventidpointer)+1;
			*eventtriggerpointer=loopnum;
			*eventpmtidspointer=alleventpmtids.at(anevent);
			*vetotrace = TGraph(40000,indexarray,indexarray);
			eventtree->Fill();
		}
	
	}
	
	eventfile->cd();
	eventtree->Write("eventtree",TObject::kOverwrite);
	eventtree->ResetBranchAddresses();
	eventfile->Close();
	delete eventfile;


}   // end loop()

bool fexists(const char *filename)
{
  int ok = access(filename, F_OK);
  return (ok!=-1);
}