#include <RAT/CrateIsotropy.hh>
#include <RAT/DB.hh>
#include <RAT/BitManip.hh>
#include <RAT/Processor.hh>

using namespace std;

namespace RAT {

  void CrateIsotropy::BeginOfRun(DS::Run&)
  {
    fLClean = DB::Get()->GetLink("DATACLEANING",fName);
    fCrateFrac = fLClean->GetD("crate_frac");
    fCardFrac = fLClean->GetD("card_frac");
    fChanFrac = fLClean->GetD("chan_frac");
  }

  Processor::Result CrateIsotropy::DSEvent(DS::Run&, DS::Entry& ds)
  {
    bool pass = true; // If any triggered event fails, they all fail
    for( size_t iEvent = 0; iEvent < ds.GetEVCount(); iEvent++ )
      if( Event(ds, ds.GetEV(iEvent)) != OKTRUE )
        pass = false;
    return pass ? OKTRUE : OKFALSE;
  }

  Processor::Result CrateIsotropy::Event(DS::Entry&, DS::EV& ev)
  {
    vector<double> crate_count(19,0);
    vector<double> card_count(16);
    vector<double> chan_count(32);
    int pmtid,crate,card,channel,count;

    fPassFlag = true;

    // should pass orphans and zero hit events
    if (ev.GetUncalPMTs().GetCount() == 0){ // || ev.IsOrphan()
      UpdateMask(ev);
      return fPassFlag ? OKFALSE : OKTRUE;
    }

    count = ev.GetUncalPMTs().GetCount();
    for (int ipmt=0;ipmt<count;ipmt++){ // should I be looping over all kinds of pmts?
      const DS::PMTUncal& pmt = ev.GetUncalPMTs().GetPMT(ipmt);
      pmtid = pmt.GetID();
      crate = BitManip::GetCrate(pmtid);
      crate_count[crate]++;
    } // end loop over pmts

    // check each crate to see if it has a large fraction of the hits
    for (int icrate=0;icrate<19;icrate++){
      if (crate_count[icrate]/(double)count > fCrateFrac){
        // now we need to loop over the pmts again and check the
        // adjacent cards and channels for crate isotropy
        for (int i=0;i<16;i++)
          card_count[i] = 0;
        for (int i=0;i<32;i++)
          chan_count[i] = 0;
        for (int ipmt=0;ipmt<count;ipmt++){
          const DS::PMTUncal& pmt = ev.GetUncalPMTs().GetPMT(ipmt);
          pmtid = pmt.GetID();
          crate = BitManip::GetCrate(pmtid);
          if (crate == icrate){
            card = BitManip::GetCard(pmtid);
            channel = BitManip::GetChannel(pmtid);
            card_count[card]++;
            chan_count[channel]++;
          }
        } // end loop over pmts

        // now we loop over pairs of adjacent cards and channel
        // to see if any pair has a large fraction of the hits.
        // we wrap card 16 to 1 and channel 32 to 1.
        for (int icard=0;icard<16;icard++)
          if ((card_count[icard]+card_count[(icard+1)%16])/crate_count[icrate] > fCardFrac)
            fPassFlag = false;
        for (int ichan=0;ichan<32;ichan++)
          if ((chan_count[ichan]+chan_count[(ichan+1)%32])/crate_count[icrate] > fChanFrac)
            fPassFlag = false;

      } // end if crate fails cratefrac
    } // end loop over crates

    // now update the mask
    UpdateMask(ev);
    return fPassFlag ? OKFALSE : OKTRUE;
  }

} // namespace RAT