#include <RAT/Processor.hh>
#include <RAT/Factory.hh>
#include <RAT/DataCleaning.hh>
#include <RAT/DataCleaningProc.hh>

#include <iostream>
#include <RAT/Log.hh>

#include <RAT/FTSCut.hh>
#include <RAT/FlasherGeoCut.hh>
#include <RAT/ITCTimeSpreadCut.hh>
#include <RAT/JunkCut.hh>
#include <RAT/MuonTag.hh>
#include <RAT/NeckCut.hh>
#include <RAT/OwlCut.hh>
#include <RAT/QClusterCut.hh>
#include <RAT/QvNhit.hh>
#include <RAT/QvTCut.hh>
#include <RAT/RingOfFire.hh>
#include <RAT/CrateIsotropy.hh>
#include <RAT/ZeroZeroCut.hh>
#include <RAT/PrescaleCut.hh>
#include <RAT/TPMuonFollowerCut.hh>
#include <RAT/CAENCut.hh>
#include <RAT/NothingCut.hh>
#include <RAT/NhitCut.hh>
#include <RAT/PollingCut.hh>
#include <RAT/WaterBlind.hh>
#include <RAT/ThresholdFlasherCut.hh>
#include <RAT/TPBurstCut.hh>
#include <RAT/LivetimeCuts.hh>
#include <RAT/MissedMuonFollowerCut.hh>
#include <RAT/MissingCAENData.hh>
#include <RAT/PedCut.hh>
#include <RAT/AtmosphericCut.hh>
#include <RAT/EmptyCrate.hh>
#include <RAT/MissedCountBurstCut.hh>

namespace RAT {

  DataCleaning::DataCleaning() : Processor("DataCleaning"), fKey(0)
  {
    RAT::GlobalFactory<DataCleaningProc>::Register("ftscut",
        new RAT::Alloc<DataCleaningProc, FTSCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("flashergeocut",
        new RAT::Alloc<DataCleaningProc, FlasherGeoCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("itctimespreadcut",
        new RAT::Alloc<DataCleaningProc, ITCTimeSpreadCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("junkcut",
        new RAT::Alloc<DataCleaningProc, JunkCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("muontag",
        new RAT::Alloc<DataCleaningProc, MuonTag>);
    RAT::GlobalFactory<DataCleaningProc>::Register("neckcut",
        new RAT::Alloc<DataCleaningProc, NeckCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("owlcut",
        new RAT::Alloc<DataCleaningProc, OwlCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("qcluster",
        new RAT::Alloc<DataCleaningProc, QClusterCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("qvnhit",
        new RAT::Alloc<DataCleaningProc, QvNhit>);
    RAT::GlobalFactory<DataCleaningProc>::Register("qvt",
        new RAT::Alloc<DataCleaningProc, QvTCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("ringoffire",
        new RAT::Alloc<DataCleaningProc, RingOfFire>);
    RAT::GlobalFactory<DataCleaningProc>::Register("crateisotropy",
        new RAT::Alloc<DataCleaningProc, CrateIsotropy>);
    RAT::GlobalFactory<DataCleaningProc>::Register("zerozerocut",
        new RAT::Alloc<DataCleaningProc, ZeroZeroCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("prescalecut",
        new RAT::Alloc<DataCleaningProc, PrescaleCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("tpmuonfollowercut",
        new RAT::Alloc<DataCleaningProc, TPMuonFollowerCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("caencut",
        new RAT::Alloc<DataCleaningProc, CAENCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("nothingcut",
        new RAT::Alloc<DataCleaningProc, NothingCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("nhitcut",
        new RAT::Alloc<DataCleaningProc, NhitCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("pollingcut",
        new RAT::Alloc<DataCleaningProc, PollingCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("thresholdflashercut",
        new RAT::Alloc<DataCleaningProc, ThresholdFlasherCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("tpburstcut",
        new RAT::Alloc<DataCleaningProc, TPBurstCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("livetimecuts",
        new RAT::Alloc<DataCleaningProc, LivetimeCuts>);
    RAT::GlobalFactory<DataCleaningProc>::Register("missedmuonfollower",
        new RAT::Alloc<DataCleaningProc, MissedMuonFollowerCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("missingcaendata",
        new RAT::Alloc<DataCleaningProc, MissingCAENData>);
    RAT::GlobalFactory<DataCleaningProc>::Register("pedcut",
        new RAT::Alloc<DataCleaningProc, PedCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("atmospheric",
        new RAT::Alloc<DataCleaningProc, AtmosphericCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("emptycrate",
        new RAT::Alloc<DataCleaningProc, EmptyCrate>);
    RAT::GlobalFactory<DataCleaningProc>::Register("missedcountburstcut",
        new RAT::Alloc<DataCleaningProc, MissedCountBurstCut>);
    RAT::GlobalFactory<DataCleaningProc>::Register("waterBlind",
        new RAT::Alloc<DataCleaningProc, WaterBlind>);
  }

  std::vector<std::string> DataCleaning::GetNamedMask(std::string name)
  {
    try{
      return fLBitMask->GetSArray(name);
    }
    catch( RAT::DBNotFoundError &e ){
      warn << "DataCleaning::GetNamedMask: Cannot find named mask " << name << newline;
      Log::Die("DataCleaning::GetNamedMask, use a real mask defined in DATACLEANING.ratdb or don't call /rat/proc datacleaning");
      return std::vector<std::string>();
    }
  }

  void DataCleaning::SetS(const std::string& param, const std::string& value)
  {
    if (param == "add"){
      if (std::find(fAddedCuts.begin(),fAddedCuts.end(),value) == fAddedCuts.end()){
        fAddedCuts.push_back(value);
      }
    }else if (param == "mask"){
      if (std::find(fAddedMasks.begin(),fAddedMasks.end(),value) == fAddedMasks.end()){
        fAddedMasks.push_back(value);
      }
    }else{
      throw ParamUnknown(param);
    }
  }

  void DataCleaning::SetI(const std::string& param, const int value)
  {
    if (param == "verbose"){
      if (value >= 0)
        DataCleaningProc::SetVerbose(value);
    }else if (param == "pass") {
        DataCleaningProc::SetProcessPass(value);
    }else{
      throw ParamUnknown(param);
    }
  }

  void DataCleaning::BeginOfRun(DS::Run& run)
  {
    fLBitMask = DB::Get()->GetLink("DATACLEANING","bitmask");
    for (size_t i=0;i<fAddedCuts.size();i++){
      fCutProcs.push_back(RAT::GlobalFactory<DataCleaningProc>::New(fAddedCuts[i]));
      fAppliedCuts.push_back(fAddedCuts[i]);
    }

    // Always apply the blindness anytime data cleaning is applied
    fCutProcs.push_back(RAT::GlobalFactory<DataCleaningProc>::New("waterBlind"));
    fAppliedCuts.push_back("waterBlind");

    for (size_t i=0;i<fAddedMasks.size();i++){
      std::vector<std::string> namedmask = GetNamedMask(fAddedMasks[i]);
      for (size_t j=0;j<namedmask.size();j++){
        std::string cutname;
        size_t pos = namedmask[j].find("-");
        if (pos != namedmask[j].npos){
          cutname = namedmask[j].substr(0,pos);
        }else{
          cutname = namedmask[j];
        }
        if (std::find(fAppliedCuts.begin(),fAppliedCuts.end(),cutname) == fAppliedCuts.end()){
          fCutProcs.push_back(RAT::GlobalFactory<DataCleaningProc>::New(cutname));
          fAppliedCuts.push_back(cutname);
        }
      }
    }

    for (int i=0;i<(int)fCutProcs.size();i++)
      fCutProcs[i]->BeginOfRun(run);
  }

  void DataCleaning::EndOfRun(DS::Run& run)
  {
    for (size_t i=0;i<fCutProcs.size();i++)
      fCutProcs[i]->EndOfRun(run);
    for (int i=0;i<(int)fCutProcs.size();i++)
      delete fCutProcs[i];
    fCutProcs.clear();
    fAppliedCuts.clear();
  }

  Processor::Result DataCleaning::DSEvent(DS::Run& run, DS::Entry& ds)
  {
    Processor::Result flag = OKTRUE;
    for (int i=0;i<(int)fCutProcs.size();i++)
      if (fCutProcs[i]->DSEvent(run, ds) != OKTRUE){flag = OKFALSE;};
    return flag;
  }

}