#include <RAT/DataCleaningUtility.hh>
#include <RAT/DS/BitMask.hh>
#include <RAT/DS/EV.hh>
#include <RAT/DB.hh>
#include <RAT/DU/Utility.hh>
#include <RAT/DU/DataCleaningBits.hh>
#include <RAT/DS/DataQCFlags.hh>
#include <RAT/Log.hh>

#include <vector>
#include <string>


namespace RAT {

  ULong64_t GetDataCleaningWord( const std::string& bitMask )
  {
    RAT::DBLinkPtr datacleaningDB = RAT::DB::Get()->GetLink( "DATACLEANING", "bitmask" );
    std::vector<std::string> mask = datacleaningDB->GetSArray( bitMask );
    RAT::DU::DataCleaningBits dataCleaningBits = RAT::DU::Utility::Get()->GetDataCleaningBits(); // To get the data cleaning bits
    ULong64_t result = 0;
    for( unsigned int i = 0; i < mask.size(); i++ ){
      result |= ((ULong64_t)0x1 << dataCleaningBits.GetBitIndex( mask.at(i) ) );
    }
    return result;
  }

  /////////////////////////////
  /////////////////////////////

  ULong64_t GetDataCleaningWord( const std::vector<std::string>& cutnames )
  {
    RAT::DU::DataCleaningBits dataCleaningBits = RAT::DU::Utility::Get()->GetDataCleaningBits(); // To get the data cleaning bits
    ULong64_t result = 0;
    for( unsigned int i = 0; i < cutnames.size(); i++ ){
      result |= ((ULong64_t)0x1 << dataCleaningBits.GetBitIndex( cutnames.at(i) ) );
    }
    return result;
  }

  /////////////////////////////
  /////////////////////////////

  Bool_t EventIsClean( const RAT::DS::EV& ev,
                       const ULong64_t dataCleaningWord,
                       const Int_t pass )
  {
    Bool_t cleanFlag = false;
    const RAT::DS::DataQCFlags& dataQCFlags = ev.GetDataCleaningFlags();
    Int_t passNumber = -1;
    if( pass >= 0 )
      passNumber = pass;
    else
      passNumber = dataQCFlags.GetLatestPass();

    if(passNumber<0) {
      warn<<"The applied flags were not found in any pass, returning notClean "<<newline;
      return cleanFlag;

    }
    const RAT::DS::BitMask& bitMaskFlags = dataQCFlags.GetFlags(passNumber);
    const RAT::DS::BitMask& bitMaskApplied = dataQCFlags.GetApplied(passNumber);

    if( !CheckMask( bitMaskApplied, dataCleaningWord ) ){ // Checks cuts have been applied
      MissingBits( bitMaskApplied, dataCleaningWord ); // List which cuts have not been applied
      warn<<"DataCleaningUtility::EventIsClean: Not all cuts in mask have been applied!"<<newline;;
    }
    else{
      if( CheckMask( bitMaskFlags, dataCleaningWord ) ) // Checks cuts have been passed
        cleanFlag = true;
    }

    return cleanFlag;
  }

  /////////////////////////////
  /////////////////////////////

  Bool_t CheckMask( const RAT::DS::BitMask& bitMask,
                    const ULong64_t dataCleaningWord )
  {
    ULong64_t comparison = dataCleaningWord & bitMask.GetULong64_t( 0 );
    if( comparison == dataCleaningWord )
      return true;
    else
      return false;
  }

  /////////////////////////////
  /////////////////////////////

  void MissingBits( const RAT::DS::BitMask& bitMask,
                    const ULong64_t dataCleaningWord )
  {
    ULong64_t comparison = dataCleaningWord & bitMask.GetULong64_t( 0 );
    comparison ^= dataCleaningWord; // Finds missing bits in mask

    RAT::DU::DataCleaningBits dataCleaningBits = RAT::DU::Utility::Get()->GetDataCleaningBits(); // To get the data cleaning bits

    for( std::map<size_t, std::string>::iterator iDCBits = dataCleaningBits.GetInverseMapBegin();
         iDCBits != dataCleaningBits.GetInverseMapEnd(); iDCBits++ )
      {
        if( comparison & ((ULong64_t)0x1 << iDCBits->first ) ){
          warn << "DataCleaningUtility::MissingBits: Bit for " << iDCBits->second << " is missing." << newline;
        }
      }
  }

} // namespace RAT