#include <globals.hh>
#include <G4UIdirectory.hh>
#include <G4UIparameter.hh>
#include <G4UIcommand.hh>
#include <G4UIcmdWithAString.hh>

#include <RAT/ProcBlockManager.hh>
#include <RAT/ProcBlock.hh>
#include <RAT/ProcAllocator.hh>
#include <RAT/DBTextLoader.hh>
#include <RAT/Log.hh>

// Processors
#include <RAT/PMTTimeJitterProc.hh>
#include <RAT/ChanSWStatusProc.hh>
#include <RAT/ChanSWStatusCalib.hh>
#include <RAT/CountProc.hh>
#include <RAT/NumberProcessedProc.hh>
#include <RAT/OutROOTProc.hh>
#include <RAT/OutNetProc.hh>
#include <RAT/OutNtupleProc.hh>
#include <RAT/PruneProc.hh>
#include <RAT/TrackPruneProc.hh>
#include <RAT/BurstProc.hh>
#include <RAT/FrontEndProc.hh>
#include <RAT/TriggerProc.hh>
#include <RAT/EventBuilderProc.hh>
#include <RAT/SimpleDAQProc.hh>
#include <RAT/NHitCutProc.hh>
#include <RAT/TriggerEfficiencyProc.hh>
#include <RAT/ScintEdepCutProc.hh>
#include <RAT/CherenkovPhotonCountCutProc.hh>
#include <RAT/ClassifierCutProc.hh>
#include <RAT/FitValidityCutProc.hh>
#include <RAT/FitEnergyCutProc.hh>
#include <RAT/SecondaryNhitsProc.hh>
#include <RAT/DataCleaningCutProc.hh>
#include <RAT/RadiusCutProc.hh>
#include <RAT/TrigTypeSelector.hh>
#include <RAT/PMTCalib.hh>
#include <RAT/PMTNoiseProc.hh>
#include <RAT/SanityCheckProc.hh>
#include <RAT/DataCleaningProc.hh>
#include <RAT/DataCleaning.hh>
#include <RAT/DCAProc.hh>
#include <RAT/DataQualityProc.hh>
#include <RAT/DQPMTProc.hh>
#include <RAT/DQRunProc.hh>
#include <RAT/DQTimeProc.hh>
#include <RAT/DQTellieProc.hh>
#include <RAT/DQTriggerProc.hh>
#include <RAT/DQOccupancyByTrigger.hh>
#include <RAT/DropoutEvaluator.hh>
#include <RAT/ReactorNuOscProc.hh>
#include <RAT/FitterProcessor.hh>
#include <RAT/DefaultFitter.hh>
#include <RAT/ClassifierProcessor.hh>
#include <RAT/ScintFitter.hh>
#include <RAT/WaterFitter.hh>
#include <RAT/PartialFitter.hh>
#include <RAT/PartialWaterFitter.hh>
#include <RAT/ECAProc.hh>
#include <RAT/PCAProc.hh>
#include <RAT/ChannelFlagsProc.hh>
#include <RAT/PythonProc.hh>
#include <RAT/SOCDataProc.hh>
#include <RAT/SOCPeakProc.hh>
#include <RAT/SOCFitterProc.hh>
#include <RAT/OutSOCProc.hh>
#include <RAT/EventListProc.hh>
#include <RAT/TellieMonitorProc.hh>
#include <RAT/DQLaserballProc.hh>
#include <RAT/PCATellieMonitorProc.hh>
#include <RAT/DQSmellieProc.hh>
#include <RAT/DQN16Proc.hh>
#include <RAT/PingCratesTriggerSignals.hh>
#include <RAT/TriggerClockJumpProc.hh>
#include <RAT/ReconstructClocks.hh>
#include <RAT/ProduceRunTableProc.hh>
#include <RAT/IsCalibrationSource.hh>
using namespace RAT;

#include <string>
using namespace std;

namespace RAT
{
// Helper func defined in ConstructUserProc.cc and overridden by user - Still needed? PGJ
Processor* construct_user_proc(std::string userProcName);
}

ProcBlockManager::ProcBlockManager( ProcBlock *theMainBlock )
  : fMainBlock( theMainBlock )
{
  fLastProc = NULL;

  // Build UI commands
  G4UIdirectory* ratDir = new G4UIdirectory("/rat/");
  ratDir->SetGuidance(" control commands");

  fAddProcCmd = new G4UIcmdWithAString( "/rat/proc",this );
  fAddProcCmd->SetGuidance( "Add a processor to the analysis stack" );
  fAddProcCmd->SetParameterName( "procname",false );

  fDeferAddProcCmd = new G4UIcmdWithAString( "/rat/proclast",this );
  fDeferAddProcCmd->SetGuidance( "Add a processor to the end of the current analysis stack" );
  fDeferAddProcCmd->SetParameterName( "procname",false );

  fIfCmd = new G4UIcmdWithAString( "/rat/proc/if",this );
  fIfCmd->SetGuidance( "Add a condition on a processor to the analysis stack" );
  fIfCmd->SetParameterName( "procname",false );

  fElseCmd = new G4UIcommand( "/rat/proc/else", this);
  fElseCmd->SetGuidance( "Add the false condition to the previous conditional processor on the analysis stack." );

  fEndBlockCmd = new G4UIcommand( "/rat/proc/endblock", this);
  fEndBlockCmd->SetGuidance( "End the processor block on the analysis stack." );

  fEndIfCmd = new G4UIcommand( "/rat/proc/endif", this);
  fEndIfCmd->SetGuidance( "End the conditional if processor block on the analysis stack." );

  fEndWhileCmd = new G4UIcommand( "/rat/proc/endwhile", this);
  fEndWhileCmd->SetGuidance( "End the conditional while processor block on the analysis stack." );

  fWhileCmd = new G4UIcmdWithAString( "/rat/proc/while",this );
  fWhileCmd->SetGuidance( "Add a conditional loop on a processor to the analysis stack" );
  fWhileCmd->SetParameterName( "procname",false );

  // set proc parameter command
  G4UIparameter* aParam;
  fSetCmd = new G4UIcommand("/rat/procset", this);
  fSetCmd->SetGuidance("Set parameter for most recent processor");
  aParam = new G4UIparameter("param", 's', false); //required
  fSetCmd->SetParameter(aParam);
  aParam = new G4UIparameter("newvalue", 's', false); //required
  fSetCmd->SetParameter(aParam);

  // ----------------Create processor allocator table-----------------

  // I/O
  fProcAllocators["outroot"] = new ProcAllocatorTmpl<OutROOTProc>;
  fProcAllocators["outnet"] = new ProcAllocatorTmpl<OutNetProc>;
  fProcAllocators["outntuple"] = new ProcAllocatorTmpl<OutNtupleProc>;
  fProcAllocators["eventlist"] = new ProcAllocatorTmpl<EventListProc>;

  // Fitters
  fProcAllocators["fitter"] = new ProcAllocatorTmpl<FitterProcessor>;
  fProcAllocators["classifier"] = new ProcAllocatorTmpl<ClassifierProcessor>;
  fProcAllocators["scintFitter"] = new ProcAllocatorTmpl<ScintFitter>;
  fProcAllocators["waterFitter"] = new ProcAllocatorTmpl<WaterFitter>;
  fProcAllocators["partialFitter"] = new ProcAllocatorTmpl<PartialFitter>;
  fProcAllocators["partialWaterFitter"] = new ProcAllocatorTmpl<PartialWaterFitter>;
  fProcAllocators["defaultfitter"] = new ProcAllocatorTmpl<DefaultFitter>;

  // DAQ
  fProcAllocators["frontend"]= new ProcAllocatorTmpl<FrontEndProc>;
  fProcAllocators["trigger"]= new ProcAllocatorTmpl<TriggerProc>;
  fProcAllocators["eventbuilder"]= new ProcAllocatorTmpl<EventBuilderProc>;
  fProcAllocators["simpledaq"]= new ProcAllocatorTmpl<SimpleDAQProc>;

  // Misc
  fProcAllocators["burst"] = new ProcAllocatorTmpl<BurstProc>;
  fProcAllocators["count"] = new ProcAllocatorTmpl<CountProc>;
  fProcAllocators["numberProcessed"] = new ProcAllocatorTmpl<NumberProcessedProc>;
  fProcAllocators["prune"] = new ProcAllocatorTmpl<PruneProc>;
  fProcAllocators["pruneTrack"] = new ProcAllocatorTmpl<TrackPruneProc>;
  fProcAllocators["tellieMonitoring"] = new ProcAllocatorTmpl<TellieMonitorProc>;

  // Conditional analysis
  fProcAllocators["triggerEfficiency"] = new ProcAllocatorTmpl<TriggerEfficiencyProc>;
  fProcAllocators["nhitCut"] = new ProcAllocatorTmpl<NHitCutProc>;
  fProcAllocators["scintEdepCut"] = new ProcAllocatorTmpl<ScintEdepCutProc>;
  fProcAllocators["classifierCut"] = new ProcAllocatorTmpl<ClassifierCutProc>;
  fProcAllocators["fitValidityCut"] = new ProcAllocatorTmpl<FitValidityCutProc>;
  fProcAllocators["fitEnergyCut"] = new ProcAllocatorTmpl<FitEnergyCutProc>;
  fProcAllocators["secondaryNhitsCut"] = new ProcAllocatorTmpl<SecondaryNhitsProc>;
  fProcAllocators["dataCleaningCut"] = new ProcAllocatorTmpl<DataCleaningCutProc>;
  fProcAllocators["radiusCut"] = new ProcAllocatorTmpl<RadiusCutProc>;
  fProcAllocators["trigTypeSelector"] = new ProcAllocatorTmpl<TrigTypeSelector>;
  fProcAllocators["cherenkovCountCut"] = new ProcAllocatorTmpl<CherenkovPhotonCountCutProc>;
  fProcAllocators["dcaProc"] = new ProcAllocatorTmpl<DCAProc>;

  // Calibration
  fProcAllocators["calibratePMT"]= new ProcAllocatorTmpl<PMTCalib>;
  fProcAllocators["chanSWStatusProc"]= new ProcAllocatorTmpl<ChanSWStatusProc>;
  fProcAllocators["chanSWStatusCalib"]= new ProcAllocatorTmpl<ChanSWStatusCalib>;
  fProcAllocators["sanitychecks"]= new ProcAllocatorTmpl<SanityCheckProc>;
  fProcAllocators["genECA"]= new ProcAllocatorTmpl<ECAProc>;
  fProcAllocators["genPCA"]= new ProcAllocatorTmpl<PCAProc>;
  fProcAllocators["pmtnoiseproc"] = new ProcAllocatorTmpl<PMTNoiseProc>;
  fProcAllocators["datacleaning"] = new ProcAllocatorTmpl<DataCleaning>;
  fProcAllocators["PMTjitter"] = new ProcAllocatorTmpl<PMTTimeJitterProc>;
  fProcAllocators["triggerclockjumpproc"] = new ProcAllocatorTmpl<TriggerClockJumpProc>;
  fProcAllocators["reconstructClocks"] = new ProcAllocatorTmpl<ReconstructClocks>;
  fProcAllocators["flagChannels"] = new ProcAllocatorTmpl<ChannelFlagsProc>;
  fProcAllocators["produceRunTable"] = new ProcAllocatorTmpl<ProduceRunTableProc>;
  fProcAllocators["taggedSource"] = new ProcAllocatorTmpl<IsCalibrationSource>;

  fProcAllocators["dqpmtproc"] = new ProcAllocatorTmpl<DQPMTProc>;
  fProcAllocators["dqoccupancybytrigger"] = new ProcAllocatorTmpl<DQOccupancyByTrigger>;
  fProcAllocators["dqrunproc"] = new ProcAllocatorTmpl<DQRunProc>;
  fProcAllocators["dqtimeproc"] = new ProcAllocatorTmpl<DQTimeProc>;
  fProcAllocators["dqtellieproc"] = new ProcAllocatorTmpl<DQTellieProc>;
  fProcAllocators["dqlaserballproc"] = new ProcAllocatorTmpl<DQLaserballProc>;
  fProcAllocators["dqsmellieproc"] = new ProcAllocatorTmpl<DQSmellieProc>;
  fProcAllocators["dqN16proc"] = new ProcAllocatorTmpl<DQN16Proc>;
  fProcAllocators["dqtriggerproc"] = new ProcAllocatorTmpl<DQTriggerProc>;
  fProcAllocators["PCATellieMonitoring"] = new ProcAllocatorTmpl<PCATellieMonitorProc>;
  fProcAllocators["reactornuosc"] = new ProcAllocatorTmpl<ReactorNuOscProc>;
  fProcAllocators["pingcratesproc"] = new ProcAllocatorTmpl<PingCratesTriggerSignals>;
  fProcAllocators["dropoutevaluator"] = new ProcAllocatorTmpl<DropoutEvaluator>;

  // Calibration -> Optical
  fProcAllocators["socdata"] = new ProcAllocatorTmpl<SOCDataProc>;
  fProcAllocators["socpeakfind"] = new ProcAllocatorTmpl<SOCPeakProc>;
  fProcAllocators["socfitter"] = new ProcAllocatorTmpl<SOCFitterProc>;
  fProcAllocators["outsoc"] = new ProcAllocatorTmpl<OutSOCProc>;


  // Escape Hatch
  fProcAllocators["python"] = new ProcAllocatorTmpl<PythonProc>;

  // -----------------------------------------------------------------
}


ProcBlockManager::~ProcBlockManager()
{
  // UI commands
  delete fAddProcCmd;
  delete fDeferAddProcCmd;
  delete fIfCmd;
  delete fElseCmd;
  delete fWhileCmd;
  delete fEndBlockCmd;
  delete fEndIfCmd;
  delete fEndWhileCmd;
  delete fSetCmd;

  // fProcAllocators
  std::map<std::string, ProcAllocator *>::iterator allocator = fProcAllocators.begin();
  while (allocator != fProcAllocators.end()) {
    delete allocator->second; // allocator points to pair<>,
                            // Processor object is the second item in pair
    ++allocator;
  }

  // Do not delete fMainBlock, owned by Gsim
}

G4String ProcBlockManager::GetCurrentValue(G4UIcommand * command)
{
  Log::Die( "ProcBlockManager::GetCurrentValue: Get value not supported on " + command->GetCommandPath() );
  return G4String( "You should never see this." );
}

void ProcBlockManager::SetNewValue( G4UIcommand* command,
                                    G4String newValue )
{
  if( command == fAddProcCmd )
    {
      SelectProcessor( newValue );
      fMainBlock->AddProcessorCommand( fLastProc );
    }
  else if( command == fDeferAddProcCmd )
    {
      SelectProcessor( newValue );
      fMainBlock->AddProcessorCommand( fLastProc );
    }
  else if( command == fIfCmd )
    {
      SelectProcessor( newValue );
      fMainBlock->IfCommand( fLastProc );
    }
  else if( command == fWhileCmd )
    {
      SelectProcessor( newValue );
      fMainBlock->WhileCommand( fLastProc );
    }
  else if( command == fElseCmd )
    fMainBlock->ElseCommand();
  else if( command == fEndBlockCmd )
    fMainBlock->EndCommand( ProcBlock::eEndBlock );
  else if( command == fEndIfCmd )
    fMainBlock->EndCommand( ProcBlock::eEndIf );
  else if( command == fEndWhileCmd )
    fMainBlock->EndCommand( ProcBlock::eEndWhile );
  else if (command == fSetCmd)
    DoProcSetCmd(newValue);
  else
    Log::Die( "ProcBlockManager::SetNewValue: Invalid command " + command->GetCommandPath() );
}


void
ProcBlockManager::SelectProcessor( const std::string& procname )
{
    info << YELLOW
         << "ProcBlockManager::DoProcCmd: Initializing processor "
         << CLR << procname << "\n";
    // Is this a user processor? (starts with "user")
    if( procname.find("user") == 0 )
      {
        fLastProc = construct_user_proc(procname);
      }
    else if( fProcAllocators.count( procname ) > 0 )
      {
        // Crazy syntax required because we have a list of pointers to functors,
        // rather than just a list of functors.  Had to use pointers because
        // of the polymorphism.  C++ makes OOP ugly.
        fLastProc = (*fProcAllocators[procname])();
      }
    else
      {
        Log::Die( "ProcBlockManager::DoProcCmd: Failed to construct processor " + procname );
      }
}

void ProcBlockManager::DoProcSetCmd( const std::string& cmdstring )
{
  Tokenizer t(cmdstring);

  std::string indentifierChars = "."; // Extra characters to count as part of the identifier
  if (t.Next(indentifierChars) != Tokenizer::TYPE_IDENTIFIER)
    Log::Die("ProcBlockManager::DoProcSetCmd: Invalid param name in /rat/procset "
                + cmdstring);
  std::string param(t.Token());

  try {
    switch (t.Next()) {
    case Tokenizer::TYPE_INTEGER:
      fLastProc->SetI(param, t.AsInt());
      break;
    case Tokenizer::TYPE_DOUBLE:
      fLastProc->SetD(param, t.AsDouble());
      break;
    case Tokenizer::TYPE_STRING:
      fLastProc->SetS(param, t.Token());
      break;
    default:
      Log::Die("ProcBlockManager::DoProcSetCmd: Invalid value in /rat/procset "
                  + cmdstring);
    }
  } catch (Processor::ParamUnknown &pu) {
    Log::Die("ProcBlockManager::DoProcSetCmd: Parameter unknown: " + pu.fParam);
  } catch (Processor::ParamInvalid &pi) {
    Log::Die("ProcBlockManager::DoProcSetCmd: Invalid value for parameter " + pi.fParam + ": " + pi.fMsg);
  }
}