#include "cometEventLoop.hxx"
#include "TSystem.h"
#include "ICheckOutput.hxx"
#include "ICheckPrimaries.hxx"
#include "ICheckTrackerFirst.hxx"
#include "ICOMETInput.hxx"

using namespace COMET;

void usage(void) {
    std::cout
    <<"Usage: SimG4_CheckRooTrackerIO.exe [options] <oaEvent_file> <RooTracker_file> \n"
      " This checks for consistency between the G4Hits in the oaEvent file and the \n"
      " entries in the RooTracker file.  It is implied that monitor hits were created \n"
      " while the RooTracker file was writing. \n\n"
      " Argument ordering: This executable assumes the first file will be the oaEvent file!\n"
      " Options: \n"
      "     -i         Compare track IDs and event IDs to make sure the persistence works\n"
      "     -t <test>  Name the type of test to run.  Valid names are:\n" 
      "                  \"output\" = Check RooTracker output (default)\n"
      "                  \"input\" = Check RooTracker input\n"
      "                  \"first\" = Check RooTracker \"first\" type\n"
      << std::endl;
}

enum TestType{
    kInput = 0,
    kOutput = 1,
    kFirst = 2
};

int main(int argc, char **argv) {
    // Get the default options
    bool forceIndex = false;
    std::string aTest;
    TestType thisTest = kOutput;
    // Input file names
    ICOMETInput* oaFile;
    IRooTrackerFile* rtFile;
    // Name of files
    std::vector<std::string> allFiles;

    // Set the options
    int c;
    while ((c = getopt(argc, argv, "it:h")) != -1)
        switch (c){
            // List of files from an input file list
            case 'i':
                forceIndex = true;
                break;
            // List of files from an input file list
            case 't':
                aTest = optarg;
                if      (aTest == "input")  thisTest = kInput;
                else if (aTest == "output") thisTest = kOutput;
                else if (aTest == "first")  thisTest = kFirst;
                else {
                    COMETLog("Invalid test name! Check valid names:");
                    usage();
                }
                break;
            case 'h':
                usage();
                return 0;
            // Let getopt deal with the rest
            case '?':
                return 1;
            default:
                abort();
        }

    //Configure COMETLog levels from input config file
    TString configPath = "${PWD}/cometlog.config";
    gSystem->ExpandPathName(configPath);
    COMET::ICOMETLog::Configure(configPath.Data());

    // Prepare the all input files
    for(int i = optind;i<argc; ++i) allFiles.push_back(argv[i]);

    // Check the length of the input files
    if (allFiles.size() != 2) {
        COMETError("Too many files listed! Expecting one input oaEvent file"
                   " followed by one input RooTracker file.");
        usage();
        return 1;
    }

    // Check all the inputs
    IVStrideEventAndRT* aChecker;
    switch(thisTest){
        case kOutput:
            aChecker = new ICheckOutput(forceIndex);
            break;
        case kInput:
            aChecker = new ICheckPrimaries(forceIndex);
            break;
        case kFirst:
            aChecker = new ICheckTrackerFirst();
            break;
        default:
            COMETLog("Invalid test name! Check valid names:");
            usage();
            break;
    }

    // Try to open the first file as the oaEvent file
    ICOMETInput* inputOA;
    std::string inputOAName = allFiles[0];
    try {
        inputOA = new ICOMETInput(inputOAName.c_str());
        COMETLog("Added " << inputOAName << " as an input oaEvent file");
    }
    // Catch the error for now
    catch(const ERooTracker& e){
        COMETLog("Bad input oaEvent file: " << inputOAName.c_str());
        usage();
        return 2;
    }

    // Try to open the second file as an RT file
    IRooTrackerFile* inputRT;
    std::string inputRTName = allFiles[1];
    try {
        inputRT = &*IRooTrackerFile::Open(inputRTName.c_str(), "READ");
        COMETLog("Added " << inputRTName.c_str() << " as an input RooTracker file");
    }
    // Catch the error for now
    catch(const ERooTracker& e){
        COMETLog("Bad input RooTracker file: " << inputRTName.c_str());
        usage();
        return 3;
    }

    // Loop through all events
    int idx = 0;
    int returnVal = 0;
    int failedEvts = 0;
    for (ICOMETEvent* event = inputOA->FirstEvent();
            !inputOA->EndOfFile();
            event = inputOA->NextEvent()){
        if (!(*aChecker)(*event, inputRT, idx)) {
            returnVal = 4;
            ++failedEvts;
            COMETNamedDebug("TestRooTracker", "Event " << idx << " failed");
            return 1;
        } else COMETNamedDebug("TestRooTracker", "Event " << idx << " passed");
        ++idx;
    }

    COMETLog("Number of events processed: " << idx << 
             "\nNumber of failed events: " << failedEvts);

    return returnVal;
}