#include <iostream>
#include <iomanip>
#include <math.h>
#include <vector>
#include <Cubes/cubes.hh>
#include <Detection/detection.hh>
#include <Utils/utils.hh>

/**
 * Cube::ObjectMerger():
 *   A Function that takes a Cube's list of Detections and
 *   combines those that are close (according to the 
 *   thresholds specified in the parameter list par).
 *   It also excludes those that do not make the minimum
 *   number of channels requirement.
 */
void Cube::ObjectMerger()
{

  if(this->objectList.size() > 0){

    // make a vector "currentList", which starts as a copy of the Cube's objectList,
    //  but is the one worked on.
    vector <Detection> *currentList = new vector <Detection>(this->objectList.size());
    *currentList = this->objectList;
    vector <Detection>::iterator iter;

    // The Cube's objectList is cleared, and then the final objects are added to it at the end.
    this->objectList.clear();
  
    int counter, compCounter,numLoops;
    bool areNear,isMatch;
    long gap;

    bool isVerb = this->par.isVerbose();

    if(this->par.getFlagGrowth()) numLoops=2;
    else numLoops = 1;

    for(int nloop = 0; nloop < numLoops; nloop++){

      counter=0;
      while( counter < (currentList->size()-1) ){
	if(isVerb){
	  std::cout.setf(std::ios::right);
	  if(nloop>0) std::cout << "Progress#2: " << std::setw(6) << counter << "/" ;
	  else std::cout << "Progress: " << std::setw(6) << counter << "/" ;
	  std::cout.unsetf(std::ios::right);
	  std::cout.setf(std::ios::left);
	  std::cout << std::setw(6) << currentList->size() 
		    << "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b" << std::flush;
	  if(nloop>0) std::cout << "\b\b" << std::flush; ;
	  std::cout.unsetf(std::ios::left);
	}

	compCounter = counter + 1;
	do {

	  Detection *obj1 = new Detection;
	  *obj1 = currentList->at(counter);
	  Detection *obj2 = new Detection;
	  *obj2 = currentList->at(compCounter);

	  if(areClose(*obj1, *obj2, this->par)){
	    obj1->addAnObject( *obj2 );
	    iter = currentList->begin() + compCounter;
	    currentList->erase(iter);
	    iter = currentList->begin() + counter;
	    currentList->erase(iter);
	    currentList->push_back( *obj1 );

	    if(isVerb){
	      std::cout.setf(std::ios::right);
	      std::cout << "Progress: "
			<< std::setw(6) << counter << "/";
	      std::cout.unsetf(std::ios::right);
	      std::cout.setf(std::ios::left);
	      std::cout << std::setw(6) << currentList->size() 
			<< "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b" << std::flush;
	      std::cout.unsetf(std::ios::left);
	    }
	    compCounter = counter + 1;

	  }
	  else compCounter++;

	  delete obj2;
	  delete obj1;

	} while( (compCounter<currentList->size()) );

	counter++;

      }  // end of while(counter<(currentList->size()-1)) loop

      if( (nloop==0) && (this->par.getFlagGrowth()) ) {
	std::cout << "Growing objects...     "<< std::flush;
	this->setCubeStats();
	vector <Detection> *newList = new vector <Detection>;
	std::cout<< "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"<<std::flush;
	std::cout << " Growing object #      "<< std::flush;
	std::cout.setf(std::ios::left);
	for(int i=0;i<currentList->size();i++){
	  std::cout<< "\b\b\b\b\b\b"<<std::setw(6)<<i+1<<std::flush;
	  Detection *obj = new Detection;
	  *obj = currentList->at(i);
	  growObject(*obj,*this);
	  newList->push_back(*obj);
	  delete obj;
	}
	delete currentList;
	currentList = newList;
	std::cout.unsetf(std::ios::left);
	std::cout<< "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"<<std::flush;
      }

    } 
    // when you get here, every detection in the input list has been 
    // examined and compared to every other detection.

    int listCounter = 0;
    while(listCounter < currentList->size()){

      (*currentList)[listCounter].addOffsets(this->par);
      (*currentList)[listCounter].calcParams();

      // Now, for each object in the newly modified list, we need to check if 
      // they pass the requirements on the minimum no. of channels and minimum 
      // number of spatial pixels
      // If not, remove from list.

      if( (*currentList)[listCounter].hasEnoughChannels(this->par.getMinChannels())
	  && ((*currentList)[listCounter].getSpatialSize() >= this->par.getMinPix()) ){
	listCounter++;
	if(isVerb){
	  std::cout << "Final total:"<<std::setw(5)<<listCounter<<"      "
		    << "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"<<std::flush;
	}
      }      
      else currentList->erase(currentList->begin()+listCounter);

    }

    this->objectList = *currentList;
    currentList->clear();
    delete currentList;

  }

}