//-----------------------------------------------------------
// File and Version Information:
// $Id$
//
// Description:
//      Implementation of class PndTpcClusterFinder
//      see PndTpcClusterFinder.hh for details
//
// Environment:
//      Software developed for the PANDA Detector at FAIR.
//
// Author List:
//      Sebastian Neubert    TUM            (original author)
//
//
//-----------------------------------------------------------

// Panda Headers ----------------------

// This Class' Header ------------------
#include "PndTpcClusterFinder.h"

// C/C++ Headers ----------------------
#include <iostream>
#include "assert.h"

// Collaborating Class Headers --------
#include "PndTpcPadPlane.h"
#include "PndTpcSectorProcessor.h"
#include "PndTpcCluster.h"
#include "PndTpcDigiAge.h"
#include "PndTpcDigiMapper.h"
#include "McId.h"
#include "McIdCollection.h"

// Class Member definitions -----------

PndTpcClusterFinder::PndTpcClusterFinder(PndTpcPadPlane* p,
				   std::vector<PndTpcCluster*>* ob,
				   unsigned int timeslice)
  : _padplane(p), _output_buffer(ob), _dt(timeslice)
{
  // construct sector processors
  std::vector<unsigned int> ids=_padplane->GetSectorIds();
  unsigned int nsec=ids.size();
  for(unsigned int is=0;is<nsec;++is){
    unsigned int sectorid=ids[is];
    _sproc[sectorid]=new PndTpcSectorProcessor();
    _sproc[sectorid]->Init(_padplane,sectorid,ob);
  }
  std::cout<<"PndTpcClusterFinder: "
	   <<_sproc.size()<<" SectorProcessors instantiated."<<std::endl;
}

PndTpcClusterFinder::~PndTpcClusterFinder(){
  std::map<unsigned int,PndTpcSectorProcessor*>::iterator secIt=_sproc.begin();
  while(secIt!=_sproc.end()){
    delete secIt->second;
    ++secIt;
  }
  _sproc.clear();
}



void 
PndTpcClusterFinder::process(std::vector<PndTpcDigi*>& digis)
{
  // time binning:
  sort(digis.begin(),digis.end(),PndTpcDigiAge());
  unsigned int ndigis=digis.size();
  if(ndigis==0)return;

  if(_trcl){// trivial clustering;
    for(unsigned int i=0;i<ndigis;++i){
      TVector3 pos;
      PndTpcDigiMapper::getInstance()->map(digis[i],pos);
      McIdCollection id=digis[i]->mcId();
      PndTpcCluster* cl=new PndTpcCluster(pos,digis[i]->amp(),0);
      cl->SetMcId(id);
      _output_buffer->push_back(cl);
    }
    return;
  }

  double oldt=digis[0]->t();
  unsigned int i=0;
  while(i<ndigis){
    if(digis[i]->t()-_dt>oldt){
      // trigger processing
      //std::cout<<"Beginning cluster finding cycle at t="<<oldt<<std::endl;
      std::map<unsigned int,PndTpcSectorProcessor*>::iterator secIt=_sproc.begin();
      while(secIt!=_sproc.end()){
	secIt->second->process();
	secIt->second->reset();
	++secIt;
      }
      oldt=digis[i]->t();
    }
    putDigi(digis[i]);
    ++i;
  }// end loop over digis
  // process remaining
  std::map<unsigned int,PndTpcSectorProcessor*>::iterator secIt=_sproc.begin();
  while(secIt!=_sproc.end()){
    secIt->second->process();
    secIt->second->reset();
    ++secIt;
  }
}

void 
PndTpcClusterFinder::reset()
{
  std::map<unsigned int,PndTpcSectorProcessor*>::iterator secIt=_sproc.begin();
  while(secIt!=_sproc.end()){
    secIt->second->reset();
    ++secIt;
  }
}


void
PndTpcClusterFinder::putDigi(PndTpcDigi* digi)
{
  PndTpcPad* pad=_padplane->GetPad(digi->padId());
  unsigned int sectorId=pad->sectorId();
  //std::cout<<"putting digi("<<digi->padId()<<") in sector "<<sectorId<<std::endl;
  _sproc[sectorId]->putDigi(digi);
}


void
PndTpcClusterFinder::checkConsistency()
{
  assert(_padplane!=NULL);
  std::vector<PndTpcPad*> buffer=_padplane->GetPads();
  unsigned int npads=buffer.size();
  std::cout<<"PndTpcClusterFinder::checkConsistency: "
	   <<npads<<" pads in PadList"<<std::endl;
  unsigned int npproc=0;
  std::map<unsigned int, PndTpcSectorProcessor*>::iterator secit=_sproc.begin();
  std::map<unsigned int, PndTpcSectorProcessor*>::iterator secend=_sproc.end();
  while(secit!=secend){// loop over sectors
    PndTpcSectorProcessor* secproc=secit->second;
    npproc+=secproc->getNPads();
    ++secit;
  }
  std::cout<<"PndTpcClusterFinder::checkConsistency: "
	   <<npads<<" pad processors available"<<std::endl;
  assert(npads=npproc);
  for(int ip=0;ip<npads;++ip){
    unsigned int sid=buffer[ip]->sectorId();
    unsigned int pid=buffer[ip]->id();
    const padprocessor* pp=_sproc[sid]->getPP(pid);
    
    if(pp==NULL){
      std::cout<<"Padprocessor#"<<pid<<" not instantiated!"<<std::endl;
    }
  }
  //std::cout<<_sproc[72]->getId()<<std::endl;
}