#include <RAT/ClassifierFactory.hh>
#include <RAT/Processor.hh>
#include <RAT/EarlyTime.hh>
#include <RAT/IsotropyRegions.hh>
#include <RAT/MeanTime.hh>
#include <RAT/PreTriggerHits.hh>
#include <RAT/TimingPeaks.hh>
#include <RAT/AlphaClassifierUnseeded.hh>
#include <RAT/AlphaClassifierSeeded.hh>
#include <RAT/string_utilities.hpp>
#include <RAT/NearAVAngularClassifier.hh>
#include <RAT/Beta14.hh>
#include <RAT/Isotropy.hh>
#include <RAT/ITR.hh>
#include <RAT/QPDT.hh>
#include <RAT/BiPoCumulTimeResid.hh>
#include <RAT/BiPoLikelihoodDiff.hh>
#include <RAT/AlphaBetaClassifier.hh>
#include <RAT/MuonClassifier.hh>
#include <RAT/BerkeleyAlphaBeta.hh>
#include <RAT/IBDClassifierUnseeded.hh>

using namespace RAT::Classifiers;

#include <string>
using namespace std;

ClassifierFactory::ClassifierFactory()
{
  fFactory.Register( EarlyTime::Name(), new Alloc<Classifier, EarlyTime>() );
  fFactory.Register( IsotropyRegions::Name(), new Alloc<Classifier, IsotropyRegions>() );
  fFactory.Register( MeanTime::Name(), new Alloc<Classifier, MeanTime>() );
  fFactory.Register( PreTriggerHits::Name(), new Alloc<Classifier, PreTriggerHits>() );
  fFactory.Register( TimingPeaks::Name(), new Alloc<Classifier, TimingPeaks>() );
  fFactory.Register( AlphaClassifierUnseeded::Name(), new Alloc<Classifier, AlphaClassifierUnseeded>() );
  fFactory.Register( AlphaClassifierSeeded::Name(), new Alloc<Classifier, AlphaClassifierSeeded>() );
  fFactory.Register( NearAVAngularClassifier::Name(), new Alloc<Classifier, NearAVAngularClassifier>() );
  fFactory.Register( Beta14::Name(), new Alloc<Classifier, Beta14>() );
  fFactory.Register( Isotropy::Name(), new Alloc<Classifier, Isotropy>() );
  fFactory.Register( ITR::Name(), new Alloc<Classifier, ITR>() );
  fFactory.Register( QPDT::Name(), new Alloc<Classifier, QPDT>() );
  fFactory.Register( BiPoCumulTimeResid::Name(), new Alloc<Classifier, BiPoCumulTimeResid>() );
  fFactory.Register( BiPoLikelihoodDiff::Name(), new Alloc<Classifier, BiPoLikelihoodDiff>() );
  fFactory.Register( AlphaBetaClassifier::Name(), new Alloc<Classifier, AlphaBetaClassifier>() );
  fFactory.Register( MuonClassifier::Name(), new Alloc<Classifier, MuonClassifier>() );
  fFactory.Register( BerkeleyAlphaBeta::Name(), new Alloc<Classifier, BerkeleyAlphaBeta>() );
  fFactory.Register( IBDClassifierUnseeded::Name(), new Alloc<Classifier, IBDClassifierUnseeded>() );
}

void
ClassifierFactory::Register( std::string name, AllocBase<Classifier>* allocator )
{
  fFactory.Register( name, allocator );
}

Classifier*
ClassifierFactory::GetClassifier( const std::string name )
{
  string classifierName, initialisation("");
  const size_t hyphenPos = name.find( "-" );
  if( hyphenPos != string::npos )
    {
      classifierName = name.substr( 0, hyphenPos );
      initialisation = name.substr( hyphenPos + 1 );
    }
  else
    classifierName = name;

  Classifier* classifier = fFactory.New( classifierName );
  classifier->Initialise( initialisation );
  return classifier;
}