//-----------------------------------------------------------
// File and Version Information:
// $Id$
//
// Description:
//      Data container for a track matching attempt
//
//
// Environment:
//      Software developed for the PANDA Detector at FAIR.
//
// Author List:
//      Felix Boehmer    TUM            (original author)
//
//
//-----------------------------------------------------------

#include "MatchingTuple.h"
#include "MatchingCriterion.h"

#include <stdexcept>
#include <iostream>


MatchingTuple::MatchingTuple() 
: 
  fMatched(false),
  fRefID(-1)
{
    fCritMap.clear();
    fIdMap.clear();
}


MatchingTuple::MatchingTuple(const std::map<TString, unsigned int>& idMap) 
:
  fMatched(false),
  fIdMap(idMap),
  fRefID(-1)
{
    fCritMap.clear();
}


const MatchingCriterion&
MatchingTuple::getCriterion(const char* name) const {
  TString n(name);
  return getCriterion(n);
}

const MatchingCriterion&
MatchingTuple::getCriterion(const TString& name) const {
  if(fCritMap.count(name)) {
    return fCritMap.find(name)->second;
  }
  else {
    std::string err("MatchingTuple::getCriterion() No criterion with name '");
    err.append(std::string(name.Data()));
    err.append("' was registered");
    std::runtime_error ex(err);
    throw ex;
  }
}

unsigned int
MatchingTuple::getIdFromBranch(const TString& name) const {
  if(fIdMap.count(name))
    return fIdMap.find(name)->second;
  else {
    std::string err("MatchingTuple::getIdFromBranch() No branch with name '");
    err.append(std::string(name.Data()));
    err.append("' was registered");
    std::runtime_error ex(err);
    throw ex;
  }
}


unsigned int
MatchingTuple::getIdFromBranch(const char* name) const {
  TString n(name);
  return getIdFromBranch(n);
}






int 
MatchingTuple::addCriterion(const MatchingCriterion& crit) {
  TString temp(crit.getName());
  if(fCritMap.count(temp))   //check if there is a criterion registered under that name
    return 1;                
  else {
    fCritMap[temp] = crit;
    return 0;
  }
}


int 
MatchingTuple::addIdAndBranch(unsigned int id, const TString& br) {
  if(fIdMap.count(br))
    return 1;
  else 
    fIdMap[br] = id;
}


std::vector<TString>
MatchingTuple::getListOfCritNames() const {
  std::map<TString, MatchingCriterion>::const_iterator it;
  std::vector<TString> ret;
  for(it=fCritMap.begin(); it!=fCritMap.end(); it++) {
    TString name = it->first;
    ret.push_back(name);
  }
  return ret;
}

std::vector<TString>
MatchingTuple::getListOfBranchNames() const {
  std::map<TString, unsigned int>::const_iterator it;
  std::vector<TString> ret;
  for(it=fIdMap.begin(); it!=fIdMap.end(); it++) {
    TString name = it->first;
    ret.push_back(name);
  }
  return ret;
} 

bool
MatchingTuple::hasBranch(const TString& br) const {
  if(fIdMap.count(br))
    return true;
  return false;
} 


bool
MatchingTuple::hasBranch(const char* br) const {
  TString tbr(br);
  return hasBranch(tbr);
}

void
MatchingTuple::print() const {
  std::cout<<"MatchingTuple at "<<this<<" :"<<std::endl;
  std::string matched("no");
  if(fMatched) 
    matched = std::string("yes");
  std::cout<<"Matched: "<<matched<<std::endl;
  std::cout<<"List of branches: "<<std::endl;
  std::map<TString, unsigned int>::const_iterator brit;
  for(brit=fIdMap.begin(); brit!=fIdMap.end(); brit++) 
    std::cout<<"   "<<(brit->first).Data()<<std::endl;
  std::cout<<"# of attached criteria: "<<fCritMap.size()<<std::endl;
}
  
ClassImp(MatchingTuple)