#ifndef _fwk_RunManager_h_
#define _fwk_RunManager_h_

#include <string>
#include <set>
#include <map>
#include <fwk/VModule.h>

#include <utl/Stopwatch.h>
#include <utl/RealTimeStopwatch.h>
#include <utl/Singleton.h>


namespace utl {
  class Reader;
  class Branch;
}

namespace evt {
  class Event;
}


namespace fwk {

  class RunController : public utl::Singleton<RunController> {

  public:
    enum BreakStatus {
      eNoBreak,
      eBreak,
      eContinue
    };

    /// Return number of registered modules
    int GetNumberOfRegisteredModules() const;

    /// Get list of all module builder names and module versions in the registry
    // Should this be removed?  Note that it will create modules that don't
    // already exist.
    std::string GetRegisteredModuleNames() const;

    /// Get a set of the names of all modules accessed thus far in the run
    const std::set<std::string>& GetUsedModuleNames() const
    { return fUsedModuleNames; }

    /// Get module by name
    VModule& GetModule(const std::string& moduleName) const;
    bool HasModule(const std::string& moduleName) const;

    /// Get Event currently being processed
    evt::Event& GetCurrentEvent() const { return *fCurEvent; }

    /// Is timing enabled?
    bool IsTiming() const { return fTiming; }

    /// Is module tracing enabled?
    bool IsModuleTracing() const { return fModuleTracing; }

    virtual void Init();
    virtual void Run();
    virtual void Finish();

  protected:
    RunController();
    virtual ~RunController();

    void InitBranch(utl::Branch& currentB);
    void RunBranch(utl::Branch& currentB);
    void FinishBranch(utl::Branch& currentB);

  private:

    void DoRunSequence(const utl::Branch& currentB);
    BreakStatus DoNextInSequence(const utl::Branch& currentB);
    void GetNextModuleName(const utl::Branch& currentB);

    std::set<std::string> fUniqueModuleNames;

    mutable std::set<std::string> fUsedModuleNames;

    evt::Event* fCurEvent;

    bool fTiming;
    bool fModuleTracing;
    utl::Stopwatch fStopwatch;
    utl::RealTimeStopwatch fRealTimeStopwatch;

    friend class utl::Singleton<RunController>;

  };


} // namespace fwk_RunController_h_

#endif

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// compile-command: "make -C ..; "
// End: