/// This is a modified version of the COMET event loop.
/// This event loops implements the following features:
///   1) It takes a list of 'control sample' classes which select certain events:
///      by default the program will select all control samples.
///      But the user can also specify which control sample (and control sample file names)
///      from the command line; it is expected that this functionality will be used by IcedustControl.
///      Do 'oaControlSample_CreateControlSample.exe -h' to see the list of available control samples.
///   2) For each 'control sample' class a separate ROOT output file is created.
///   3) Each selected event has the recon, hits and digits removed before being 
///      written to file.
#include <iostream>
#include <cometEventLoop.hxx>
#include <ICOMETLog.hxx>
#include <iostream>
#include <sstream>
#include <limits>
#include <memory>
#include <unistd.h>
#include <csignal>
#include <cmath>

#include <TROOT.h>

#include "EoaCore.hxx"
#include "IDatum.hxx"

#include "ICOMETEvent.hxx"
#include "IMidasFile.hxx"
#include "ICOMETInput.hxx"
#include "ICOMETOutput.hxx"
#include "IOADatabase.hxx"
#include "IHandleHack.hxx"
#include "ICOMETLog.hxx"
#include "cometEventLoop.hxx"
#include "IAlignmentId.hxx"

#include <IControlSampleBase.hxx>
#include <ITpcTrackSandMuonControlSample.hxx>
#include <IBasketTrackSandMuonControlSample.hxx>
#include <IFgdTrackSandMuonControlSample.hxx>
#include <IP0DTrackSandMuonControlSample.hxx>
#include <IEmptyBeamSpillControlSample.hxx>
#include <IFgdStoppingCosmicControlSample.hxx>
#include <IFgdStoppingProtonControlSample.hxx>
#include <IFgdCollinearCosmicControlSample.hxx>
#include <IDsECalElectronControlSample.hxx>
#include <IBarrelECalElectronControlSample.hxx>
#include <IDsECalProtonControlSample.hxx>
#include <IECalPionControlSample.hxx>
#include <IECalPairProducedElectronControlSample.hxx>
#include <IPrescaleControlSample.hxx>

void controlprogramusage(std::string programName){

        std::cout << "usage: " << programName 
                  << " [options] [input-file] ..." 
                  << std::endl
                  << std::endl;
        std::cout << " This program will create a number of output ROOT files.\n"
                  << " Each file will contain only events that passed a set of cuts\n"
                  << " specified in the program.  Only raw information will be saved; no fits/hits/digits." << std::endl;
        std::cout << "Options:" << std::endl;
        
        std::cout << "    -m                MIDAS input file"
                  << std::endl;
        std::cout << "    -r                COMET ROOT file"
                  << std::endl;

        std::cout << "    -n <cnt>          Only read <cnt> events";
        std::cout << std::endl;

        std::cout << "    -s <cnt>          Skip <cnt> events"
                  << std::endl;
        
        std::cout << "    -S <output stem>        Will replace 'ControlSample' with <output stem> in file name.\n"
                  << "                            If any control sample are explicitly selected using -O option, then -S is disabled."
                  << std::endl;

        std::cout << "    -O <control sample>=<control filename>  where <control sample> can be: " << std::endl;

        std::cout << "              bsksmu : Basket Sand Muon Sample " << std::endl;
        std::cout << "              tpcsmu : TPC Sand Muon Sample " << std::endl;
        std::cout << "              fgdsmu : FGD Sand Muon Sample " << std::endl;
        std::cout << "              p0dsmu : P0D Sand Muon Sample " << std::endl;
        std::cout << "              empspl : Emty Spill Sample "<< std::endl;
        std::cout << "              fgdstp : FGD Stopping Cosmic Sample "<< std::endl;
        std::cout << "              fgdpro : FGD Stopping Proton Sample "<< std::endl;
        std::cout << "              fgdcol : FGD Collinear Cosmic Sample "<< std::endl;
        std::cout << "              dsecel : DsECal Electron Sample "<< std::endl;
        std::cout << "              brecel : Barrel ECal Electron Sample "<< std::endl;

        std::cout << "              dsecpr : DsECal Proton Sample "<< std::endl;
        std::cout << "              ecalpi : ECal Pion Sample "<< std::endl;
        std::cout << "              pairel : ECal Pair Produced Electron Sample "<< std::endl;
        std::cout << "              presca : Prescale sample " << std::endl;

        std::cout << "\n    -k                This option will suppress the deletion of hits/reco/digits (which is usually done by default) "
                  << std::endl;

        std::cout << "    -t [bpTPEFecC]    Only accept these triggers"
                  << std::endl
                  << "                        b  Beam triggers"
                  << std::endl
                  << "                        p  Pedestal/noise triggers"
                  << std::endl
                  << "                        T  TPC laser triggers"
                  << std::endl
                  << "                        P P0D light injection triggers"
                  << std::endl
                  << "                        E  ECal LED triggers"
                  << std::endl
                  << "                        F  FGD LED triggers"
                  << std::endl
                  << "                        e  Electronics calib triggers"
                  << std::endl
                  << "                        c  TFB cosmic ray triggers"
                  << std::endl
                  << "                        C  FGD cosmic ray triggers"
                  << std::endl;

        std::cout << std::endl;
        

}


using namespace COMET;
int cometEventLoop2(int argc, char** argv) {

    int readCount = 0;
    int skipCount = 0;
    std::string programName = argv[0];
    char *configName = NULL;
    std::vector<ICOMETOutput*> outputFiles;
    bool fOutputInitialized = false;
    std::string outputStem = "ControlSample";

    /// Define whether we will erase digits and Reco info.
    bool eraseHitsReco = true;

    /// Flag for whether we are specifying control samples
    /// from command line (for IcedustControl)
    bool useCommandLineCtrl = false;

    // This is the list of control samples that we want to save.
    std::vector<IControlSampleBase* > list_samples;
    std::vector<IControlSampleBase*>::iterator list_iter;

    // If this is not zero, then only accept triggers matched in this mask.
    unsigned int validTriggersMask = 0;
    signal(SIGSEGV, SIG_DFL);

    // Set up the logging code.
    ICOMETLog::Configure(configName);
    ICOMETLog::SetLogLevel(ICOMETLog::LogLevel);
    ICOMETLog::SetDebugLevel(ICOMETLog::WarnLevel);
   

    enum {
        kRootFile,
        kMIDASFile
    } fileType = kRootFile;

    // Process the options.
    for (;;) {
        int c = getopt(argc, argv, "c:dHkmn:O:rs:t:");
        if (c<0) break;
        switch (c) {
        case 'H':
        {
            // Debug the handles.
            EnableHandleRegistry(true);
            break;
        }
        case 'm': 
        {
            fileType = kMIDASFile;
            break;
        }
        case 'n':
        {
            std::istringstream tmp(optarg);
            tmp >> readCount;
            break;
        }
        case 'r':
        {
            fileType = kRootFile;
            break;
        }
        case 's':
        {
            std::istringstream tmp(optarg);
            tmp >> skipCount;
            break;
        }
        case 'S':
        {
    outputStem.clear();
    std::stringstream tmp(optarg);
    tmp >> outputStem;
    break;
        }
        case 'O':
        { 
            std::string option = optarg;
            std::string value = "";
            // If the option is "<option>=<value>", split this into two
            // strings "<option>" and "<value>"
            std::string::size_type equals = option.find_first_of("=");
            if (equals != std::string::npos) {
                value = option.substr(equals+1,std::string::npos);
                option = option.substr(0,equals);
            }

            bool found_correct_type = false;

            // Go through the list of all available control samples.
            // The second command line option should be the filename.
            if(value.size() < 1 ){
              std::cerr << "Have zero length string for value of option " << option
                        << ". Exiting. " << std::endl;
              controlprogramusage(programName);
              exit(0);
            }

            // TPC sand muon control
            if(option == "tpcsmu"){
              list_samples.push_back(new ITpcTrackSandMuonControlSample());
              found_correct_type = true;
            }
            if(option == "bsksmu"){
              list_samples.push_back(new IBasketTrackSandMuonControlSample());
              found_correct_type = true;
            }
            if(option == "fgdsmu"){
              list_samples.push_back(new IFgdTrackSandMuonControlSample());
              found_correct_type = true;
            }
            if(option == "p0dsmu"){
              list_samples.push_back(new IP0DTrackSandMuonControlSample());              
              found_correct_type = true;
            }
            if(option == "empspl"){
              list_samples.push_back(new IEmptyBeamSpillControlSample());
              found_correct_type = true;
            }
            if(option == "fgdstp"){
              list_samples.push_back(new IFgdStoppingCosmicControlSample());  
              found_correct_type = true;
            }
            if(option == "fgdpro"){
              list_samples.push_back(new IFgdStoppingProtonControlSample());  
              found_correct_type = true;
            }
            if(option == "fgdcol"){
              list_samples.push_back(new IFgdCollinearCosmicControlSample());
              found_correct_type = true;
            }
            if(option == "dsecel"){
              list_samples.push_back(new IDsECalElectronControlSample());
              found_correct_type = true;
            }
            if(option == "brecel"){
              list_samples.push_back(new IBarrelECalElectronControlSample());
              found_correct_type = true;
            }
      if(option == "proton"){
              list_samples.push_back(new IDsECalProtonControlSample());
              found_correct_type = true;
            }
      if(option == "ecalpi"){
              list_samples.push_back(new IECalPionControlSample());
              found_correct_type = true;
            }
            if(option == "pairel"){
              list_samples.push_back(new IECalPairProducedElectronControlSample());
              found_correct_type = true;
            }
            if(option == "presca"){
              list_samples.push_back(new IPrescaleControlSample());
              found_correct_type = true;
            }
            
            if (!found_correct_type) {
              std::cerr << "ERROR: Illegal user option: -O" << option << std::endl;              
              controlprogramusage(programName);
              exit(0);
            }

            // If we found a known type, let's make sure to save the filename for it.
            std::cout << "Setting file for " << list_samples.size()-1 << " " << value << std::endl;
            list_samples[list_samples.size()-1]->SetFileName(value);

            // For the moment disable the histogram files, since we haven't set the 
            // filename correctly.
            list_samples[list_samples.size()-1]->SetMakeHistoFile(false);

            // Keep track of fact we are using command line arguments to define control samples.
            useCommandLineCtrl = true;

            break;
        }        
        case 'k':
        {
          eraseHitsReco = false;
    break;
        }
        case 't':
        {
            std::cout << "Only following triggers will be accepted:";
            for (char *trig = optarg; *trig !=0 ; ++trig) {
                switch (*trig) {
                case 'b':
                    std::cout << " beam-spill";
                    validTriggersMask |= COMET::Trigger::kBeamSpill;
                    break;
                case 'p':
                    std::cout << " pedestal";
                    validTriggersMask |= COMET::Trigger::kPedestal;
                    break;
                case 'T':
                    std::cout << " TPC-laser";
                    validTriggersMask |= COMET::Trigger::kTPCLaser;
                    break;
                case 'P':
                    std::cout << " P0D-LED";
                    validTriggersMask |= COMET::Trigger::kP0DLED;
                    break;
                case 'E':
                    std::cout << " ECal-LED";
                    validTriggersMask |= COMET::Trigger::kECalLED;
                    break;
                case 'F':
                    std::cout << " FGD-LED";
                    validTriggersMask |= COMET::Trigger::kFGDLED;
                    break;
                case 'e':
                    std::cout << " FEE-calibration";
                    validTriggersMask |= COMET::Trigger::kFEECalib;
                    break;
                case 'c':
                    std::cout << " TFB-cosmic";
                    validTriggersMask |= COMET::Trigger::kTFBCosmic;
                    break;
                case 'C':
                    std::cout << " FGD-cosmic";
                    validTriggersMask |= COMET::Trigger::kFGDCosmic;
                    break;
                default:
                    std::cout << std::endl
                              << "Invalid trigger type (" << *trig << ")"
                              << std::endl;

                }
            }
            std::cout << std::endl;
            break;
        }
        default:
          std::cerr << "Incorrect command line option:"  << std::endl;;
          controlprogramusage(programName);
          exit(0);
        }
    }
    

    // Add all control samples if we haven't explicitly specified from command line.
    if(!useCommandLineCtrl){

      ITpcTrackSandMuonControlSample*   tpcTrackSandMuon   = new ITpcTrackSandMuonControlSample();
      IBasketTrackSandMuonControlSample*     basketSandMuon     = new IBasketTrackSandMuonControlSample();
      IFgdTrackSandMuonControlSample*   fgdTrackSandMuon   = new IFgdTrackSandMuonControlSample();
      IP0DTrackSandMuonControlSample*   p0dTrackSandMuon   = new IP0DTrackSandMuonControlSample();
      IEmptyBeamSpillControlSample*     emptyBeamSpill     = new IEmptyBeamSpillControlSample();
      IFgdStoppingCosmicControlSample*  fgdStoppingCosmic  = new IFgdStoppingCosmicControlSample();    
      IFgdStoppingProtonControlSample*  fgdStoppingProton  = new IFgdStoppingProtonControlSample();    
      IFgdCollinearCosmicControlSample* fgdCollinearCosmic = new IFgdCollinearCosmicControlSample();
      IDsECalElectronControlSample*     dsECalElectron     = new IDsECalElectronControlSample();
      IBarrelECalElectronControlSample* brECalElectron     = new IBarrelECalElectronControlSample();
      IDsECalProtonControlSample*     dsECalProton     = new IDsECalProtonControlSample();
      IECalPionControlSample*     ECalPion     = new IECalPionControlSample();
      IECalPairProducedElectronControlSample*     ECalPairProducedElectron     = new IECalPairProducedElectronControlSample();
    
      IPrescaleControlSample*           prescale           = new IPrescaleControlSample();
      

      if(tpcTrackSandMuon->GetEnable())  list_samples.push_back(tpcTrackSandMuon);
      if(basketSandMuon->GetEnable())    list_samples.push_back(basketSandMuon);
      if(fgdTrackSandMuon->GetEnable())  list_samples.push_back(fgdTrackSandMuon);
      if(p0dTrackSandMuon->GetEnable())  list_samples.push_back(p0dTrackSandMuon);
      if(emptyBeamSpill->GetEnable())    list_samples.push_back(emptyBeamSpill);
      if(fgdStoppingCosmic->GetEnable()) list_samples.push_back(fgdStoppingCosmic);
      if(fgdStoppingProton->GetEnable()) list_samples.push_back(fgdStoppingProton);
      if(fgdCollinearCosmic->GetEnable())list_samples.push_back(fgdCollinearCosmic);
      if(dsECalElectron->GetEnable())    list_samples.push_back(dsECalElectron);
      if(brECalElectron->GetEnable())    list_samples.push_back(brECalElectron);
      if(dsECalProton->GetEnable())    list_samples.push_back(dsECalProton);
      if(ECalPion->GetEnable())    list_samples.push_back(ECalPion);
      if(ECalPairProducedElectron->GetEnable())    list_samples.push_back(ECalPairProducedElectron);

      if(prescale->GetEnable())          list_samples.push_back(prescale);
      
    }

    std::cout << "Number of different samples sets: " << list_samples.size() << std::endl;
    for(list_iter  = list_samples.begin(); list_iter != list_samples.end(); list_iter++){
      std::cout << Form("Enabled %s with Prescale %d", 
      (*list_iter)->GetSampleName().c_str(), (*list_iter)->GetPrescale()) << std::endl;;
    }    

    if(eraseHitsReco)
      std::cout << "Program will be erasing reco information, hits and digits (for real data) from output files" << std::endl; 
    else
      std::cout << "Program will NOT be erasing reco information, hits and digits (for real data) from output files" << std::endl; 
      
    // Keep track of how many events we write for each file.
    std::vector<int> totalWritten(list_samples.size(),0);

    // Check that there is an input file to open.
    if (argc<=optind) {
        std::cerr << "ERROR: No input file" << std::endl << std::endl;
    }
    
    if (!outputFiles.empty()) outputFiles.front()->cd();

    
    // If readcount is zero, that means read the entire file.
    if (readCount<1) readCount = std::numeric_limits<int>::max();
    

    int totalRead = 0;
    double nextOutput = 10;
    while (optind<argc) {
        // Check to see if we need to read more events.
        if (readCount<=totalRead) break;
        
        // Open input the file
        std::string fileName = argv[optind++];
        int lastEventId = -1;
        int lastRunId = -1;
        try {
            std::auto_ptr<COMET::IVInputFile> input;
            switch (fileType) {
            case kRootFile:{
                TFile* file = TFile::Open(fileName.c_str(),"OLD");
                input.reset(new COMET::ICOMETInput(file));
                break;
            }
            case kMIDASFile:
            {
                COMET::IMidasFile* midas = new COMET::IMidasFile();
                midas->Open(fileName.c_str());
                input.reset(midas);
                break;
            }
            default:
                std::cout << "ERROR: Unknown file type" << std::endl;
            }
            
            if (!input->IsOpen()) {
                std::cout << "ERROR: File not found " << fileName << std::endl;
                continue;
            }
            
            if (!outputFiles.empty()) outputFiles.front()->cd();

            
            // Read the file.
            for (std::auto_ptr<ICOMETEvent> event(input->FirstEvent());
                 !input->EndOfFile();
                 event.reset(input->NextEvent())) {


                if (skipCount>0) {
                    --skipCount;
                    continue;
                }
                
                if (validTriggersMask != 0 
                    && (event->GetHeader().GetTriggerWord()
                        == COMET::ICOMETEvent::Header::Invalid)
                    && event->GetHeader().IsData()) {
                    static int messageShown = 3;
                    if (messageShown>0) {
                        COMETError("Attempting to apply trigger mask"
                                  << " to data with invalid trigger word");
                        -- messageShown;
                    }
                }

                // Only filter if a trigger bit mask was provided, the event
                // is data (not a message, run begin or end), and has a valid
                // trigger word (not MC unless the trigger is being
                // simulated).

                if (validTriggersMask != 0
                    && event->GetHeader().IsData()
                    && (event->GetHeader().GetTriggerWord()
                        != COMET::ICOMETEvent::Header::Invalid)
                    && 0 == (event->GetHeader().GetTriggerBits() 
                             & validTriggersMask)) {
                    COMETVerbose("Skip event with trigger mask of "
                                 << std::hex 
                                 << event->GetHeader().GetTriggerBits());
                    continue;
                }
                    
                ++totalRead;
                lastEventId = event->GetEventId();
                lastRunId = event->GetRunId();
                
                // We open the list of output files once we get to the first event.
                // We do this so that we would have access to the run number.
                if(!fOutputInitialized){
                  // Open the list of output files.  The output file names are based on
                  // names from the control samples, unless specified on command line.
                  for(unsigned int i = 0; i < list_samples.size(); i++){
                    char name[200];                   
                    ICOMETOutput* output = 0;
                    if(useCommandLineCtrl){
                      std::cout << "Creating output file: " 
                                << list_samples[i]->GetFileName().c_str() << std::endl; 
                      output = new ICOMETOutput(list_samples[i]->GetFileName().c_str(),"NEW");
                    }else{
                      sprintf(name,"%s.run%08i.%s.root",list_samples[i]->GetSampleName().c_str(),event->GetRunId(),outputStem.c_str());
                      std::cout << "Creating output file: " << name << std::endl; 
                      output = new ICOMETOutput(name,"NEW");
                    }
                    if (!output->IsOpen()) {
                      std::cerr << "ERROR: Output file not open" << std::endl;
                      exit(2);
                    }      

                    outputFiles.push_back(output);
        
        // Open the diagnostic histograms if desired )NOT ACTIVE YET)
        if(list_samples[i]->MakeHistoFile()){
          sprintf(name,"%s.run%08i.%s_histo.root",
            list_samples[i]->GetSampleName().c_str(),
            event->GetRunId(),outputStem.c_str());
          list_samples[i]->OpenHistoFile(name);
        }

                  }
                  fOutputInitialized = true;
                }


                // Check for each sample type if we want to save this event.
                std::vector<bool> saveEventSample(list_samples.size(),false);
                bool saveEvent = false;
                  
                try {
                    if (!outputFiles.empty()) outputFiles.front()->cd();
                    for(unsigned int i = 0; i < list_samples.size(); i++){
                      if(list_samples[i]->IsEventSelected(*event)){
                        saveEventSample[i] = true;
                        saveEvent = true;
                      }
                    }
                }
                catch (ENextEventLoopFile& ex) {
                    break;
                }

                // Normally we would save the geometry in the output file.  
                // But we don't want to do that for real data control samples.
                // So we need to figure out here if this is simulated data.
                bool isMC = false;
                COMET::IHandle<COMET::IDataVector> truthinfo = event->Get<COMET::IDataVector>("truth");
                if(truthinfo) isMC = true;


                if(saveEvent){


                  // If we are going to save event, then delete all information in event 
                  // except for raw data (if the correct flag is set).
                  if(eraseHitsReco){
                    
                    
                    // Remove the fits... the order matters...
                    COMET::IHandle<COMET::IDataVector> fits = event->Get<COMET::IDataVector>("fits");
                    if (fits) {
                      event->erase(fits);
                      COMET::IDatum* f = COMET::GetPointer(fits);
                      if (f) delete f;
                      event->AddDatum(new COMET::IDataVector("fits",
                                                          "Fit results from reconstruction"));
                    }
                    
                    // Remove the hits.
                    COMET::IHandle<COMET::IDataVector> hits = event->Get<COMET::IDataVector>("hits");
                    if (hits) {
                      event->erase(hits);
                      COMET::IDatum* h = COMET::GetPointer(hits);
                      if (h) delete h;
                      event->AddDatum(new COMET::IDataVector("hits",
                                                          "Calibrated hit data"));
                    }
                    
                    // Remove the digits.
                    COMET::IHandle<COMET::IDataVector> digits = event->Get<COMET::IDataVector>("digits");
                    if (digits) {
                      event->erase(digits);
                      COMET::IDatum* h = COMET::GetPointer(digits);
                      if (h) delete h;
                      event->AddDatum(new COMET::IDataVector("digits",
                                                          "Uncalibrated digit data"));
                    }

                    if(!isMC){
                      // Reset the alignment ID to zero.
                      COMET::IAlignmentId temp;                  
                      event->SetAlignmentId(temp);
                    }
                  }
                

                  // Now save event to different files.
                  // Save the geometry if looking at simulation or not erasing data. 
                  for(unsigned int i = 0; i < list_samples.size(); i++){
                    if(saveEventSample[i]){
                      outputFiles[i]->WriteEvent(*event);
                      totalWritten[i]++;

                      if(isMC || !eraseHitsReco){
                        try {
                          outputFiles[i]
                            ->WriteGeometry(IOADatabase::Get().Geometry());
                        }
                        catch (ENoGeometry) {
                          COMETSevere("Geometry not saved in output");
                        }
                        catch (EOADatabase) {
                          COMETSevere("Geometry not saved in output");
                        }
                      }
                    }
                  }
                }

                
                event.reset(NULL);
                if (!CleanHandleRegistry()) {
                    DumpHandleRegistry();
                    std::cout << "WARNING: (COMET) Memory Leak in "
                              << std::endl;
                    std::cout << "    File(event,run): " << fileName 
                              << ":(" 
                              << lastEventId 
                              << "," << lastRunId << ")" << std::endl;
                }
                
                if (totalRead>(nextOutput-0.5)) {
                    nextOutput *= std::sqrt(10);
                    if (nextOutput - totalRead > 1000) {
                        nextOutput = totalRead + 1000;
                    }
                    COMETLog("Events Processed: " << totalRead);
                }

                // Check to see if we have read enough events.
                if (readCount<=totalRead) break;
            }
            
            if (!CleanHandleRegistry()) {
                DumpHandleRegistry();
                std::cout << "WARNING: (COMET) Memory Leak after finishing "
                          << std::endl;
                std::cout << "       " << fileName << std::endl;
            }
            
            if (!outputFiles.empty()) outputFiles.front()->cd();

            input->CloseFile();
        }
        catch (std::exception& except) {
            std::cout << "ERROR: (COMET) Uncaught exception in " 
                      << fileName << std::endl;
            std::cout << "      " << except.what() << std::endl;
            if (!CleanHandleRegistry()) {
                DumpHandleRegistry();
                std::cout << "WARNING: (COMET) Memory Leak after finishing "
                          << std::endl;
                std::cout << "       " << fileName << std::endl;
            }
        }
        catch (...) {
            // Don't crash on an error, but try to go to the next file.
            std::cout << "ERROR: (COMET) Uncaught exception in " 
                      << fileName << std::endl;
            if (!CleanHandleRegistry()) {
                DumpHandleRegistry();
                std::cout << "WARNING: (COMET) Memory Leak after finishing "
                          << std::endl;
                std::cout << "       " << fileName << std::endl;
            }
        }
    }
    
    if (!outputFiles.empty()) {
        for (std::vector<COMET::ICOMETOutput*>::iterator file 
                 = outputFiles.begin();
             file != outputFiles.end(); 
             ++ file) {
        }
    }
    else {
    }
    
    std::cout << "Total Events Read: " << totalRead << std::endl;
    if (!outputFiles.empty()) {
        int nn = 0;
        for (std::vector<ICOMETOutput*>::iterator file = outputFiles.begin();
             file != outputFiles.end();
             ++file) {
            (*file)->Close();
            std::cout << "Total Events Written for this file " << totalWritten[nn] << std::endl;
            nn++;
        }
   
  // write out histogram files NOT ACTIVE YET
  for(list_iter  = list_samples.begin(); list_iter != list_samples.end(); list_iter++){
    if((*list_iter)->MakeHistoFile()){
      std::cout << Form("Writing out histogram file for %s\n", (*list_iter)->GetSampleName().c_str());
      (*list_iter)->EndJob();
    }
  }
    }    

    
    return 0;
}





int main(int argc, char **argv) {

  cometEventLoop2(argc,argv);
}