#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;
//     for(int i=0;i<this->objectList.size();i++) currentList->push_back( this->objectList[i] );

    // 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 );
	    //   	  currentList->insert(iter, *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;

  }



//     vector<Detection> *finalList = new vector<Detection>;
//     for(int listCounter = 0; listCounter < currentList->size(); listCounter++){
//       Detection *currentObject = new Detection;
//       *currentObject = currentList->at(listCounter);
//       currentObject->addOffsets(this->par);
//       currentObject->calcParams();
//       // Now, for each object in the newly modified list, we need to check if 
//       // they pass the minimum no. of channels requirement            
//       int numChannels = currentObject->getZmax() - currentObject->getZmin() + 1;
//       if( numChannels >= this->par.getMinChannels() ){

// 	/*
// 	// Now remove any multiply-appearing pixels in each good object
// 	// and add to the output list      
// 	Detection *newObject = new Detection;
// 	// the first pixel gets included -- then compare all others...
// 	newObject->addPixel(currentObject->getPixel(0)); 
// 	for(int pix = 1; pix < currentObject->getSize(); pix++){
// 	bool addThisOne = true;
// 	for(int newpix = 0; newpix < newObject->getSize(); newpix++){
// 	bool newOneMatches = ( newObject->getX(newpix) == currentObject->getX(pix) )
// 	&& ( newObject->getY(newpix) == currentObject->getY(pix) )
// 	&& ( newObject->getZ(newpix) == currentObject->getZ(pix) );
// 	addThisOne = addThisOne && !newOneMatches;
// 	}
// 	if(addThisOne) newObject->addPixel(currentObject->getPixel(pix));
// 	}
// 	newObject->addOffsets(this->par);
// 	newObject->calcParams();
// 	this->objectList.push_back(*newObject);
// 	*/
// 	finalList->push_back(*currentObject);
// 	if(isVerb){
// 	  std::cout << "Final total:"<<std::setw(5)<<finalList->size()
// 		    << "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"<<std::flush;
// 	}
// 	//	delete newObject;
//       }

//       delete currentObject;
//     }

//     currentList->clear();
//     delete currentList;

//     this->objectList = *finalList;
//     finalList->clear();
//     delete finalList;

//   }

}