//  comet-mc
//
//  $Id: SimG4.cc,v 1.29 2009/08/31 20:07:07 mcgrew Exp $

#include <iostream>
#include <fstream>

#include <csignal>
#include <cstdlib>

#include "ICOMETLog.hxx"

#include "G4RunManager.hh"
#include "G4UImanager.hh"
#include "G4UIterminal.hh"
#include "G4UIcsh.hh"
#include <G4UIExecutive.hh>

#include "COMETCreateRunManager.hh"
#include "COMETPersistencyManager.hh"
#include "COMETRootPersistencyManager.hh"
//#include "COMETUIShell.hh"

#include "COMETPhysicsList.hh"

#ifdef G4VIS_USE
#include <G4VisExecutive.hh>
#endif

void Run(bool force_interactive,bool force_terminal, std::string execute_files, int argc, char** argv){
    G4UIsession* session=NULL;
    G4UIExecutive* exec=NULL;
    if ( !force_interactive && argc > 0) {
        COMETLog("Using batch mode");
        for(int i= 0; i<argc; ++i){
            execute_files+=argv[i];
            execute_files+=" ";
        }
    } else{
        if(force_terminal){
            COMETLog("Using G4UIterminal (c-shell style)");
            G4UIcsh* shell = new G4UIcsh();
            session = new G4UIterminal(shell);
        }else{
            COMETLog("Using G4UIExecutive");
            exec = new G4UIExecutive(argc, argv);
            session=exec->GetSession();
            // check we're valid;
            if(!session){
                COMETError("No valid session type specified or requested type is not installed.");
                return;
            }
            // non-gui sessions don't automatically run the provided macros so we need
            // to force this
            if(!exec->IsGUI() ){
                for(int i= 0; i<argc; ++i){
                    execute_files+=argv[i];
                    execute_files+=" ";
                }
            }
            // no more need for the G4UIExecutive
        }
    }
    // now execute each of the requested scripts (we can't do this before as
    // in interactive mode the list changes depending on if there's a gui or
    // not)
    G4UImanager* UI = G4UImanager::GetUIpointer();
    if(!execute_files.empty()){
        std::string file;
        std::stringstream ss(execute_files);
        while(ss>>file){
            UI->ApplyCommand(("/control/execute "+file).c_str());
        }
    }
    // Run the session if we're interactive
    if(session){
        session->SessionStart();
        delete exec;
    }
}

void Usage(const char* program){
    std::cout<<"usage: "<<program<<" [options] [macro-file [macro-file2 [...]]]\n"
               "\n"
               "Run the Geant4 simulation.\n"
               "Providing a macro-file will set "<<program<<" to run in batch-mode, (see the -i option below).\n"
               "\n"
               "Options: \n"
               "  -h, -?          Show this help \n"
               "  -g              Reduced initialisation to focus on constructing the Geometry. Useful for the debugging geometry.\n"
               "  -p <n_events>   Profile event simulation every n_events for memory and speed. Default is off (n_events = 0).\n"
               "                  Profiling persisted to oaEvent file.\n"
               "  -o <filename>   Set the output filename.  Overrides /db/open macro commands.\n"
               "  -t              Force use of a command-line style UI, over-riding any available GUI (if they've been installed).\n"
               "  -i              Force an interactive session even when macro files are provided.  If they are provided, run them\n"
               "                  first and then return to an interactive command-prompt.\n"
               "  -e <macrofile>  Provide a macro file to be executed, before entering a UI\n"
               "  -l <list name>  Specify the hadronic physics model\n";
    
    COMETPhysicsList::PrintAvailableHadronPhysicsLists("                   ");
}

int main(int argc,char** argv) {
    G4String outputFilename;
    G4String physicsList = "QGSP_BERT_HP"; // Default

    G4int errflg = 0;
    G4int c = 0;
    G4bool force_terminal=false;
    G4bool force_interactive=false;
    G4int profile=0;
    G4String arg;
    char *endptr;
    std::string execute_files;

    while (!errflg && ((c=getopt(argc,argv,"k:e:gl:p:o:tinh?")) != -1)) {
        switch (c) {
            case 'g':
                physicsList = COMETPhysicsList::PListNameForGeomTest();
                break;
            case 'l':
                // Option -g is prioritised.
                if(physicsList != COMETPhysicsList::PListNameForGeomTest())
                  physicsList = optarg;
                break;
            case 'p':
                profile = strtol(optarg, &endptr, 10);
                if (!optarg || *endptr) {
                    G4cout << "Please enter a valid integer for event profiling"
                              " rate" << G4endl;
                    ++errflg;
                };
                break;
            case 'o':
                outputFilename = optarg;
                break;
            case 't': // Don't use a tcsh-style command line interface
                force_terminal=true;
                break;
            case 'i': // make sure we use a command-line prompt (don't try to make a gui)
                force_interactive=true;
                break;
            case 'e': 
                 execute_files+=optarg;
                 execute_files+=" ";
                break;
            default:
                errflg++;
                G4cout << "Option not implemented" << G4endl;
            case 'h': case '?':
                Usage(argv[0]);
                return 0;
        }
    }
    if(errflg) {
        Usage(argv[0]);
        return 1;
    }

    COMET::ICOMETLog::SetLogStream(&G4cout);
    COMET::ICOMETLog::SetDebugStream(&G4cerr);
    COMET::ICOMETLog::Configure();


    // Set the mandatory initialization classes
    // Construct the default run manager
    G4RunManager* runManager = COMETCreateRunManager(physicsList, profile);
    
#ifdef G4VIS_USE
    // Visualization.
    G4VisManager* visManager = new G4VisExecutive;
    visManager->Initialize();
#endif
    
    // Create the persistency manager.
    COMETPersistencyManager* persistencyManager 
        = COMETRootPersistencyManager::GetInstance();

    // Get the pointer to the UI manager
    G4UImanager* UI = G4UImanager::GetUIpointer();

    // Set the defaults for the simulation.
    UI->ApplyCommand("/comet/conditions SimG4-defaults 1.0");

    if (persistencyManager && outputFilename != "") {
        G4String command = "/db/open ";
        UI->ApplyCommand(command+outputFilename);
    }
    
    std::signal(SIGILL,  SIG_DFL);
    std::signal(SIGBUS,  SIG_DFL);
    std::signal(SIGSEGV, SIG_DFL);

    // Process requested macro or if none, open an interactive session
    Run(force_interactive,force_terminal, execute_files, argc-optind, argv+optind);

    // job termination
#ifdef G4VIS_USE
    delete visManager;
#endif
    
    if (persistencyManager) {
        persistencyManager->Close();
        delete persistencyManager;
    }
    delete runManager;
    
    return 0;
}