#include "Level3Mods/RandomErrorModule.hh"

#include "CLHEP/Random/Ranlux64Engine.h"
#include "CLHEP/Random/RandFlat.h"


#ifdef DEFECT_OLD_IOSTREAM_HEADERS
#include <iostream>
#else
#include <iostream>
#  ifndef DEFECT_NO_STDLIB_NAMESPACES
using std::dec;
using std::cout;
using std::endl;
#  endif
#endif

const long RandomErrorModule::_defaultRandomSeed = 1485669224;


RandomErrorModule::RandomErrorModule( const char* const theName,
                                        const char* const theDescription )
  : AppFilterModule( theName, theDescription ),
    _ErrorProbability("ErrorProbability",this,1.),
    _randomSeed("RandomSeed",this,_defaultRandomSeed),
    _randomEngine(0),
    _flatGenerator(0),
    _debug("debug",this,false)
{
  // Define parameters for talk-to
  // -----------------------------
  _ErrorProbability.addDescription(
" \tThe per event probability of an error (default 1.)");
  _randomSeed.addDescription(
" \tSeed for the random number generator");
  _debug.addDescription(
" \tDebug mode (default false)");

  commands()->append(&_ErrorProbability);
  commands()->append(&_randomSeed);
  commands()->append(&_debug);
}

RandomErrorModule::~RandomErrorModule() 
{
  if (_randomEngine) delete _randomEngine;
  if (_flatGenerator) delete _flatGenerator;
}

AppResult RandomErrorModule::beginJob( AbsEvent* aJob ) 
{
  // Initialize the random number engine with a seed
  _randomEngine = new Ranlux64Engine(_randomSeed.value());
  // Initialize the flat random number generator (0,1) with our engine --
  // passing as a reference tells it to leave memory cleanup of the
  // engine to us
  _flatGenerator = new RandFlat(*_randomEngine,0.,1.);
   return AppResult::OK;
}

AppResult RandomErrorModule::beginRun( AbsEvent* aRun )
{
   return AppResult::OK;
}

AppResult RandomErrorModule::event( AbsEvent* anEvent ) {

  bool Passed = true;
  float threw = _flatGenerator->fire();
  bool errorEvent = ( threw < _ErrorProbability.value() );
  
  if ( _debug.value() )
    std::cout << "   ErrorModule: threw " << threw << " needed under "
         << _ErrorProbability.value() << std::endl;

  if (errorEvent) errlog(ELsevere,"Err:666, a random error") << endmsg;

  this->setPassed(Passed);

  if ( Passed && _debug.value() )
    std::cout << "     Passed Filter Module " << this->name() << "\n";
 
  return AppResult::OK;
}


AppResult RandomErrorModule::endRun( AbsEvent* aRun )
{
   return AppResult::OK;
}

AppResult RandomErrorModule::endJob( AbsEvent* aJob )
{
   return AppResult::OK;
}

AppResult RandomErrorModule::abortJob( AbsEvent* aJob ) 
{
  // Clean up the random number stuff.
  if (_flatGenerator) delete _flatGenerator;
  if (_randomEngine) delete _randomEngine;
  return AppResult::OK;
}

AppModule*
RandomErrorModule::clone(const char* cloneName)
{
  return new RandomErrorModule(cloneName,"this module is a clone of RandomErrorModule");
}