#include <RAT/MethodFactory.hh>
#include <RAT/FixedSeed.hh>
#include <RAT/Centroid.hh>
#include <RAT/PEnergy.hh>
#include <RAT/SimpleEnergy.hh>
#include <RAT/SimpleTime.hh>
#include <RAT/SimpleDirection.hh>
#include <RAT/Quad.hh>
#include <RAT/PositionTimeLikelihood.hh>
#include <RAT/DirectionLikelihood.hh>
#include <RAT/PositionTimeDirectionLikelihood.hh>
#include <RAT/HoughDirection.hh>
#include <RAT/TimeLikelihood.hh>
#include <RAT/EnergyLookup.hh>
#include <RAT/SmearResult.hh>
#include <RAT/EnergyPromptHits.hh>
#include <RAT/EnergyPromptLookup.hh>
#include <RAT/EnergyRSP.hh>
#include <RAT/SOCPositionTimeChiSquared.hh>
#include <RAT/NearAVAngular.hh>
#include <RAT/EnergyFunctional.hh>
#include <RAT/EnergyRThetaFunctional.hh>
#include <RAT/PartialEnergy.hh>
#include <RAT/MuonWater.hh>
#include <RAT/MuonScintillator.hh>
#include <RAT/PositionANN.hh>
#include <RAT/string_utilities.hpp>
#include <RAT/Processor.hh>
#include <RAT/DS/Entry.hh>
using namespace RAT::Methods;

#include <string>
using namespace std;

MethodFactory::MethodFactory()
{
  fFactory.Register( FixedSeed::Name(), new Alloc<Method, FixedSeed>() );
  fFactory.Register( Centroid::Name(), new Alloc<Method, Centroid>() );
  fFactory.Register( SimpleEnergy::Name(), new Alloc<Method, SimpleEnergy>() );
  fFactory.Register( SimpleTime::Name(), new Alloc<Method, SimpleTime>() );
  fFactory.Register( SimpleDirection::Name(), new Alloc<Method, SimpleDirection>() );
  fFactory.Register( Quad::Name(), new Alloc<Method, Quad>() );
  fFactory.Register( DirectionLikelihood::Name(), new Alloc<Method, DirectionLikelihood>() );
  fFactory.Register( PositionTimeLikelihood::Name(), new Alloc<Method, PositionTimeLikelihood>() );
  fFactory.Register( PositionTimeDirectionLikelihood::Name(), new Alloc<Method, PositionTimeDirectionLikelihood>() );
  fFactory.Register( HoughDirection::Name(), new Alloc<Method, HoughDirection>() );
  fFactory.Register( TimeLikelihood::Name(), new Alloc<Method, TimeLikelihood>() );
  fFactory.Register( EnergyLookup::Name(), new Alloc<Method, EnergyLookup>() );
  fFactory.Register( EnergyPromptHits::Name(), new Alloc<Method, EnergyPromptHits>() );
  fFactory.Register( EnergyPromptLookup::Name(), new Alloc<Method, EnergyPromptLookup>() );
  fFactory.Register( EnergyRSP::Name(), new Alloc<Method, EnergyRSP>() );
  fFactory.Register( PEnergy::Name(), new Alloc<Method, PEnergy>() );
  fFactory.Register( SOCPositionTimeChiSquared::Name(), new Alloc<Method, SOCPositionTimeChiSquared>() );
  fFactory.Register( NearAVAngular::Name(), new Alloc<Method, NearAVAngular>() );
  fFactory.Register( EnergyFunctional::Name(), new Alloc<Method, EnergyFunctional>() );
  fFactory.Register( EnergyRThetaFunctional::Name(), new Alloc<Method, EnergyRThetaFunctional>() );
  fFactory.Register( PartialEnergy::Name(), new Alloc<Method, PartialEnergy>() );
  fFactory.Register( MuonWater::Name(), new Alloc<Method, MuonWater>() );
  fFactory.Register( MuonScintillator::Name(), new Alloc<Method, MuonScintillator>() );
  fFactory.Register( PositionANN::Name(), new Alloc<Method, PositionANN>() );
  fFactory.Register( SmearResult::Name(), new Alloc<Method, SmearResult>() );
}

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


Method*
MethodFactory::GetMethod( const std::string name )
{
  string methodName, initialisation("");
  const size_t hyphenPos = name.find( "-" );
  if( hyphenPos != string::npos )
    {
      methodName = name.substr( 0, hyphenPos );
      initialisation = name.substr( hyphenPos + 1 );
    }
  else
    methodName = name;

  Method* method = fFactory.New( methodName );
  method->Initialise( initialisation );
  return method;
}