#include <iostream>
#include <sstream>
#include <limits>
#include <memory>
#include <unistd.h>
#include <csignal>
#include <cmath>
#include <string>
#include <vector>
#include <utility>
#include <map>

#include <TROOT.h>

#include "EoaCore.hxx"

#include "ICOMETEvent.hxx"
#include "IMidasFile.hxx"
#include "ICOMETInput.hxx"
#include "ICOMETOutput.hxx"
#include "IOADatabase.hxx"
#include "IHandleHack.hxx"
#include "ICOMETLog.hxx"
#include "IMemoryUsage.hxx"
#include "IProfileData.hxx"
#include "IEventLoopStride.hxx"
#include "IInputFileList.hxx"
#include "cometEventLoop.hxx"
#include "IFieldManager.hxx"
#include "IUniformField.hxx"

namespace {
    void cometEventLoopUsage(std::string programName, 
            COMET::ICOMETEventLoopFunction& userCode,
            int readCount) {
        std::cout << "usage: " << programName 
            << " [options] [input-file] ..." 
            << std::endl
            << std::endl;

        std::cout << "Options:" << std::endl;

        std::cout << "    -o <file>         Set the name of an output file."
            << std::endl
            << "                        Multiple output files can"
            << " be provided."
            << std::endl;

        std::cout << "    -a                Read all events";
        if (readCount<1) std::cout << " [Default]";
        std::cout << std::endl;
        std::cout << "    -b [<file>,c,u,n]  Set the field maps load from specified file, current input file, uniforme field with 1 Testla at Z direction, or no field";
        std::cout << "                       NOTICE: if this option is not given and field manager is not set elsewhere, then any access to fieldmap will lead to exception throw.";
        std::cout << std::endl;

        std::cout << "    -c <file>         Set the logging config file name"
            << std::endl;

        std::cout << "    -d                Increase the debug level"
            << std::endl;

        std::cout << "    -D <name>=[error,severe,warn,debug,trace]"
            << std::endl
            << "                      Change the named debug level"
            << std::endl;

        std::cout << "    -f <event>        Look for an event number"
            << std::endl;

        std::cout << "    -f <run>,<event>  Look for a run and event number"
            << std::endl;

        std::cout << "    -F <ordering [arg]>   Change the order of the input files, one of: "
            <<COMET::IInputFileList::GetOptionString()
            << std::endl;
        std::cout << "    -G <file>         Force a geometry file"
            << std::endl;

        std::cout << "    -g                Don't save geometry in output"
            << std::endl;

        std::cout << "    -H                Debug IHandle (slow)"
            << std::endl;

        std::cout << "    -I <file>         Text file containing a list of input files.  Each line be of one of the forms: \n"
            "                         filename [file-type] \n"
            "                         filename [file-type] [list-name]\n"
            "                         filename [file-type] [list-index]\n"
            "                      where file-type is optional, but must be either 'midas' or 'root' depending on \n"
            "                      whether the data is directly from MIDAS or is an oaEvent file, respectively.  \n"
            "                      If not given, the value 'root' is assumed and list-name/index cannot be used.\n"
            "                      If given, list-name/index can also be provided, which denotes which IEntryList will \n"
            "                      be used when looping over this file."
            << std::endl;
        std::cout << "    -B                Abort (throw error) if file cannot be read"
            << std::endl;
        std::cout << "    -R <num_retries>  Number of times attempts to open a file before skipping it or aborting.\n"
            "                      Useful for accessing xrootd files, which can fail on first attempt."
            << std::endl;
        std::cout << "    -m                MIDAS input file"
            << std::endl;

        std::cout << "    -n <cnt>          Only read <cnt> events";
        if (readCount>0) std::cout << "  [Default: " << readCount << "]";
        std::cout << std::endl;

        std::cout << "    -q                Decrease the verbosity"
            << std::endl;

        std::cout << "    -r                COMET ROOT file"
            << std::endl;

        std::cout << "    -s <cnt>          Skip <cnt> events"
            << std::endl;
        std::cout << "    -S <primes|random|[0-9]+>  Stride through events (loop over events out of order). Options:\n"
            "                                    primes = use the smallest prime number guaranteed to stride through all events in the input file.\n"
            "                                    random = Step through the events in a random order.\n"
            "                                    [0-9]+ = An integer which fixes the number of events to skip over.\n"
            << std::endl;

        std::cout << "    -t [bpTPEFecC]  Only accept these triggers"
                     " [WARNING: THIS OPTION IS NOT YET VALID FOR COMET AND WILL BE IGNORED] "
 //           << 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 << "    -u                Log the memory and CPU usage"
            << std::endl;

        std::cout << "    -U                Print the memory and CPU usage"
            << std::endl;

        std::cout << "    -v                Increase the verbosity"
            << std::endl;

        std::cout << "    -V <name>=[quiet,log,info,verbose]"
            << std::endl
            << "                      Change the named log level"
            << std::endl;

        std::cout << "    -O <opt>[=<val>]  Set an option for the user code"
            << std::endl;

        std::cout << std::endl;

        userCode.Usage();
        std::exit(1);
    }
};

int COMET::cometEventLoop(int argc, char** argv,
        COMET::ICOMETEventLoopFunction& userCode, 
        int defaultReadCount) {
    if (defaultReadCount<0) defaultReadCount = 0;
    int readCount = defaultReadCount;
    int debugLevel = 0;
    std::map<std::string, COMET::ICOMETLog::ErrorPriority> namedDebugLevel;
    int logLevel = -1; // Will choose default logging level...
    std::map<std::string, COMET::ICOMETLog::LogPriority> namedLogLevel;
    std::string programName = argv[0];
    char *configName = NULL;
    std::vector<std::string> outputNames;
    std::vector<ICOMETOutput*> outputFiles;
    std::string file_order;
    bool preventSavedGeometry = false;
    std::string geometryFile = "";
    std::string fieldMapOption = "";
    int targetRun = -1;
    int targetEvent = -1;
    int exitStatus = 0;
    std::string strideOption=""; // No stride
    IMemoryUsage memoryUsage;
    bool printMemoryUsage = false;
    COMET::IInputFileList input_files;

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

    enum FileType_t{
        kRootFile,
        kMIDASFile
    } fileType = kRootFile;

    // Process the options.
    for (;;) {
        int c = getopt(argc, argv, "ab:c:dD:f:F:G:gHI:BR:mn:o:O:qrs:S:t:uvV:");
        if (c<0) break;
        switch (c) {
            case 'a':
                {
                    // readcount of zero means read the entire file.
                    readCount = 0;
                    break;
                }
            case 'b':
                {
                    // Specify the way to initialize magnetic field
                    fieldMapOption = optarg;
                    break;
                }
            case 'c':
                {
                    configName = strdup(optarg);
                    break;
                }
            case 'd':
                {
                    // increase the debugging level.
                    ++debugLevel;
                    break;
                }
            case 'D':
                {
                    // Set the debug level for a named trace.
                    std::string arg(optarg);
                    std::size_t sep = arg.find("=");
                    if (sep != std::string::npos) {
                        std::string name = arg.substr(0,sep);
                        std::string levelName = arg.substr(sep+1);
                        switch (levelName[0]) {
                            case 'e': case 'E':
                                namedDebugLevel[name.c_str()] = COMET::ICOMETLog::ErrorLevel;
                                break;
                            case 's': case 'S':
                                namedDebugLevel[name.c_str()] = COMET::ICOMETLog::SevereLevel;
                                break;
                            case 'w': case 'W':
                                namedDebugLevel[name.c_str()] = COMET::ICOMETLog::WarnLevel;
                                break;
                            case 'd': case 'D':
                                namedDebugLevel[name.c_str()] = COMET::ICOMETLog::DebugLevel;
                                break;
                            case 't': case 'T':
                                namedDebugLevel[name.c_str()] = COMET::ICOMETLog::TraceLevel;
                                break;
                            default:
                                cometEventLoopUsage(programName,userCode,defaultReadCount);
                        }
                    }
                    break;
                }
            case 'f':
                {
                    // Look for a particular run and event number in the file.
                    std::string arg(optarg);
                    if (arg.find(',')!=std::string::npos) {
                        std::istringstream input(arg);
                        char c;
                        input >> targetRun;
                        input >> c;
                        input >> targetEvent;
                    }
                    else {
                        std::istringstream input(arg);
                        input >> targetEvent;
                    }
                    break;
                }
            case 'F':
                {
                    // Set the file ordering
                    file_order = optarg;
                    break;
                }
            case 'G':
                {
                    // Force a particular geometry file.
                    geometryFile = optarg;
                    break;
                }
            case 'g':
                {
                    // prevent the geometry from being saved.
                    preventSavedGeometry = true;
                    break;
                }
            case 'H':
                {
                    // Debug the handles.
                    EnableHandleRegistry(true);
                    break;
                }
            case 'I':
                {
                    if(!input_files.ReadListFromFile(optarg)){
                        COMETError("Problem obtaining input list from file.");
                        return 1;
                    }
                    break;
                }
            case 'B':
                {
                    // Change from the default behaviour to fail on bad files
                    input_files.SetSkipBadFiles(false);
                    break;
                }
            case 'R':
                {
                    // Set the number of times a file will be opened
                    std::istringstream tmp(optarg);
                    int nRetries = 0;
                    tmp >> nRetries;
                    input_files.SetOpenRetries(nRetries);
                    break;
                }
            case 'm':
                {
                    fileType = kMIDASFile;
                    break;
                }
            case 'n':
                {
                    std::istringstream tmp(optarg);
                    tmp >> readCount;
                    break;
                }
            case 'o':
                {
                    outputNames.push_back(optarg);
                    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);
                    }
                    if (!userCode.SetOption(option,value)) {
                        std::cerr << "ERROR: Illegal user option: " << option;
                        if (value != "") std::cerr << "   Value: " << value;
                        std::cerr << std::endl;
                        cometEventLoopUsage(programName,userCode,defaultReadCount);
                    }
                    break;
                }
            case 'q':
                {
                    // decrease the verbosity level.
                    if (logLevel>0) --logLevel;
                    else logLevel = 0;
                    break;
                }
            case 'r':
                {
                    fileType = kRootFile;
                    break;
                }
            case 's':
                {
                    std::istringstream tmp(optarg);
                    int skipCount = 0;
                    tmp >> skipCount;
                    COMETError("skipCount: "<<skipCount);
                    input_files.SetFirstEvent(skipCount);
                    break;
                }
            case 'S':
                {
                    // set the Stride/shuffle for the file(s)
                    strideOption=optarg;
                    break;
                }
            case 't':
                {
                    COMETNamedLog("EventLoopOptions","Warning: -t option is not supported for COMET at this time and will be ignored");
                    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;
                                cometEventLoopUsage(programName,userCode,defaultReadCount);
                        }
                    }
                    std::cout << std::endl;
                    break;
                }
            case 'u':
                {
                    // Enable logging of memory usage
                    memoryUsage.Enable();
                    break;
                }
            case 'U':
                {
                    // Enable logging of memory usage
                    printMemoryUsage = true;
                    break;
                }
            case 'v':
                {
                    // increase the verbosity level.
                    if (logLevel>0) ++logLevel;
                    else logLevel = 2;
                    break;
                }
            case 'V':
                {
                    // Set the debug level for a named trace.
                    std::string arg(optarg);
                    std::size_t sep = arg.find("=");
                    if (sep != std::string::npos) {
                        std::string name = arg.substr(0,sep);
                        std::string levelName = arg.substr(sep+1);
                        switch (levelName[0]) {
                            case 'q': case 'Q':
                                namedLogLevel[name.c_str()] = COMET::ICOMETLog::QuietLevel;
                                break;
                            case 'l': case 'L':
                                namedLogLevel[name.c_str()] = COMET::ICOMETLog::LogLevel;
                                break;
                            case 'i': case 'I':
                                namedLogLevel[name.c_str()] = COMET::ICOMETLog::InfoLevel;
                                break;
                            case 'v': case 'V':
                                namedLogLevel[name.c_str()] = COMET::ICOMETLog::VerboseLevel;
                                break;
                            default:
                                cometEventLoopUsage(programName,userCode,defaultReadCount);
                        }
                    }
                    break;
                }
            default:
                cometEventLoopUsage(programName,userCode,defaultReadCount);
        }
    }

    // Set up the logging code.
    ICOMETLog::Configure(configName);

    if (logLevel == 0) {
        ICOMETLog::SetLogLevel(ICOMETLog::QuietLevel);
    }
    else if (logLevel == 1) {
        ICOMETLog::SetLogLevel(ICOMETLog::LogLevel);
        COMETLog("Set log level to LogLevel");
    }
    else if (logLevel == 2) {
        ICOMETLog::SetLogLevel(ICOMETLog::InfoLevel);
        COMETInfo("Set log level to InfoLevel");
    }
    else if (logLevel >= 3) {
        ICOMETLog::SetLogLevel(ICOMETLog::VerboseLevel);
        COMETVerbose("Set log level to VerboseLevel");
    }

    for (std::map<std::string,COMET::ICOMETLog::LogPriority>::iterator i 
            = namedLogLevel.begin();
            i != namedLogLevel.end();
            ++i) {
        COMET::ICOMETLog::SetLogLevel(i->first.c_str(), i->second);
    }

    if (debugLevel == 1) {
        ICOMETLog::SetDebugLevel(ICOMETLog::WarnLevel);
        COMETWarn("Set debug level to WarnLevel");
    }
    else if (debugLevel == 2) {
        ICOMETLog::SetDebugLevel(ICOMETLog::DebugLevel);
        COMETDebug("Set debug level to DebugLevel");
    }
    else if (debugLevel >= 2) {
        ICOMETLog::SetDebugLevel(ICOMETLog::TraceLevel);
        COMETTrace("Set debug level to TraceLevel");
    }

    for (std::map<std::string,COMET::ICOMETLog::ErrorPriority>::iterator i 
            = namedDebugLevel.begin();
            i != namedDebugLevel.end();
            ++i) {
        COMET::ICOMETLog::SetDebugLevel(i->first.c_str(), i->second);
    }

    // Prepare the input files
    for(int i = optind;i<argc; ++i) {
        switch(fileType){
            case kRootFile:  input_files.AddRootFile( argv[i]); break;
            case kMIDASFile: input_files.AddMidasFile(argv[i]); break;
        }
    }
    // Check that there is at least one input file to open.
    if (input_files.GetNumberOfFiles()<1) {
        std::cerr << "ERROR: No input file" << std::endl << std::endl;
        cometEventLoopUsage(programName,userCode,defaultReadCount);
    }
    if(!input_files.ProcessFileOrder(file_order)){
        std::cerr<<"Problem ordering input files."<<std::endl<<std::endl;
        cometEventLoopUsage(programName,userCode,defaultReadCount);
        return 1;
    }
    if(input_files.GetNumberOfFiles()>10){
        COMETLog("Input file list contiains "<<input_files.GetNumberOfFiles()<<" files");
    }else{
        input_files.PrintFileList();
    }

    // Make the EventLoopStride (to be able to cycle events out of order)
    COMET::IEventLoopStride* strider=NULL;
    if(strideOption!=""){
        strider=COMET::BuildEventLoopStride(strideOption);
        if(!strider){
            std::cerr << "ERROR: Illegal stride request: " << strideOption;
            std::cerr << std::endl;
            cometEventLoopUsage(programName,userCode,defaultReadCount);
        }
    }
    input_files.SetEventLoopStride(strider);

    // Check that the user code got all the necessary options
    if (!userCode.CheckOptions()){
        std::cerr<< "Missing necessary options.  Please check the correct usage (-h)"<<std::endl;
        exit(2);
    }

    if (!outputNames.empty()) {
        for (std::vector<std::string>::iterator n = outputNames.begin();
                n != outputNames.end();
                ++n) {
            ICOMETOutput* output = new ICOMETOutput((*n).c_str(),"NEW");
            if (!output->IsOpen()) {
                std::cerr << "ERROR: Output file not open" << std::endl;
                exit(2);
            }
            outputFiles.push_back(output);
        }
    }

    if (!outputFiles.empty()) outputFiles.front()->cd();
    userCode.Initialize();

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

    if (geometryFile != "") {
        IOADatabase::Get().SetGeometryOverride(geometryFile);
    }

    if (fieldMapOption == 'u') {
        // uniformed magnetic field with Bx = 1Tesla at any region
        IUniformField* uniField = new IUniformField();
        uniField->setMagneticField(TVector3(1.*unit::tesla,0.,0.));
        uniField->setElectricField(TVector3(0.,0.,0.));
    }else if((fieldMapOption != 'c') && (!fieldMapOption.empty())) {
        // load user specified field map
        if(!COMET::IFieldManager::Import(fieldMapOption.c_str())){
            cometEventLoopUsage(programName,userCode,defaultReadCount);
        }
    }
    else if (fieldMapOption == 'n'){
        COMET::IFieldManager::GetObject()->SetNoField();
    }

    int totalRead = 0;
    int totalWritten = 0;
    double nextOutput = 10;
    std::string fileName = "not set";
    int lastEventId = -1;
    int lastRunId = -1;
    try {
        for ( std::auto_ptr<ICOMETEvent> event(input_files.FirstEvent());
                !input_files.EndOfFile();
                event.reset(input_files.NextEvent())
            ){
            // Update the geometry if needed
            if (geometryFile == "") COMET::IOADatabase::Get().UpdateGeometry(); // only update when geometry is not overriden

            // Update the field map from the current input file
            if (fieldMapOption == 'c') {
                COMET::IFieldManager::GetObject()->UpdateField();
            }

            if (input_files.JustChangedFile()){
                if (!outputFiles.empty()) outputFiles.front()->cd();
                userCode.EndFile(input_files.GetLastFile());
                input_files.CloseLastFile();

                COMET::IVInputFile& input=*input_files.GetCurrentFile();
                fileName=input.GetFilename();

                if (!outputFiles.empty()) outputFiles.front()->cd();
                userCode.BeginFile(&input);
            }

            if (targetRun>=0 && event->GetRunId()<targetRun) continue;
            else targetRun = -1;

            if (targetEvent>=0 && event->GetEventId()<targetEvent) continue;
            else targetEvent = -1;

            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();
            memoryUsage.LogMemory();
            // Print the memory usage to the terminal if needed
            if (printMemoryUsage){
                IProfileData mem_info = IProfileData("after_processing_event");
                mem_info.ls();
            }

            int saveEvent = -1;
            try {
                if (!outputFiles.empty()) outputFiles.front()->cd();
                saveEvent = userCode.Process(*event,outputFiles.size());
            }
            catch (ENextEventLoopFile& ex) {
                break;
            }

            if (!preventSavedGeometry) {
                int geomFile = std::max(0,saveEvent);
                // Check if the geometry should be saved.
                if (0 <= saveEvent
                        && saveEvent < (int) outputFiles.size()) {
                    // Save the geometry
                    try {
                        outputFiles[geomFile]
                            ->WriteGeometry(IOADatabase::Get().UpdateGeometry());
                    }
                    catch (ENoGeometry) {
                        COMETSevere("Geometry not saved in output");
                    }
                    catch (ECOMETOutputWriteFailed) {
                        COMETSevere("Geometry not saved in output");
                    }
                    catch (EOADatabase) {
                        COMETSevere("Geometry not saved in output");
                    }

                    // Save the EM field
                    try {
                        outputFiles[geomFile]
                            ->WriteEMField(IOADatabase::Get().EMFieldDescription());
                    }
                    catch (ENoEMFieldDescription) {
                        COMETSevere("EM Field description not saved in output");
                    }
                    catch (ECOMETOutputWriteFailed) {
                        COMETSevere("EM Field description not saved in output");
                    }
                    catch (EOADatabase) {
                        COMETSevere("EM Field description not saved in output");
                    }
                }
            }

            if (0 <= saveEvent && saveEvent < (int) outputFiles.size()) {
                outputFiles[saveEvent]->WriteEvent(*event);
                ++totalWritten;
            }

            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);
            }

            if (!CleanHandleRegistry()) {
                DumpHandleRegistry();
                std::cout << "WARNING: (COMET) Memory Leak after finishing "
                    << std::endl;
                std::cout << "       " << fileName << std::endl;
            }

            // Check to see if we need to read more events.
            if (readCount<=totalRead) break;

        } //end of main event-loop for block

        // Close the final file that would have been missed in the above loop
        if (!outputFiles.empty()) outputFiles.front()->cd();
        userCode.EndFile(input_files.GetLastFile());
        input_files.CloseLastFile();
    }
    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;
        }
        exitStatus = 3;
    }
    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;
        }
        exitStatus = 4;
    } //end of main try..catch block

    if (!outputFiles.empty()) {
        for (std::vector<COMET::ICOMETOutput*>::iterator file 
                = outputFiles.begin();
                file != outputFiles.end(); 
                ++ file) {
            userCode.Finalize(*file);
            memoryUsage.Write(*file);
        }
    }
    else {
        userCode.Finalize((COMET::ICOMETOutput*) NULL);
        memoryUsage.Write((COMET::ICOMETOutput*) NULL);
    }

    std::cout << "Total Events Read: " << totalRead << std::endl;
    if (!outputFiles.empty()) {
        std::cout << "Total Events Written: " << totalWritten << std::endl;
        for (std::vector<ICOMETOutput*>::iterator file = outputFiles.begin();
                file != outputFiles.end();
                ++file) {
            (*file)->Close();
        }
    }

    if (exitStatus > 0) {
        COMETError("Terminating with non-zero exit status.");
        std::exit(exitStatus);
    }

    return 0;
}