/*=========================================================================

Program:   wxMaracas
Module:    $RCSfile: CutModelManager.cxx,v $
Language:  C++
Date:      $Date: 2010/04/02 07:22:25 $
Version:   $Revision: 1.9 $

Copyright: (c) 2002, 2003
License:

This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#include "CutModelManager.h"

//Machete
#include "CutModelMainPanel.h"

/**
**	Start of the manager class
**/
CutModelManager::CutModelManager(std::string path){
	_path = path;
	_img = NULL;
	_img2 = NULL;
	_interactor = NULL;	
	_render = NULL;
	_currentaction=0;

}
CutModelManager::~CutModelManager(){
	std::string files = _path;
	files+="/infounrd_0_fig_0.info";	
	remove(files.c_str());	
	_vectordata.clear();
	_img = NULL;
	_img2 = NULL;
	_interactor = NULL;	
	_render = NULL;
}


vtkImageData* CutModelManager::getImageData(){
	return _img2;
}

void CutModelManager::setImageData(vtkImageData* img){
	int type = CutModelMainPanel::getInstance()->GetType();
	if( type == 0)
	{
		_img = img;

		if(_img2!=NULL){
			_img2->Delete();
		}
		_img2 = vtkImageData::New();
		_img2->SetExtent(_img->GetExtent());
		_img2->SetSpacing(_img->GetSpacing());
		_img2->AllocateScalars();

		_img2->DeepCopy(_img);
	}
	else
	{
		_img2 = img;

		if(_img!=NULL){
			_img->Delete();
		}
		_img = vtkImageData::New();
		_img->SetExtent(_img2->GetExtent());
		_img->SetSpacing(_img2->GetSpacing());
		_img->AllocateScalars();

		_img->DeepCopy(_img2);
	}
}

void CutModelManager::setInteractor(vtkRenderWindowInteractor* interactor){
	_interactor = interactor;
}

void CutModelManager::setRenderer(vtkRenderer* renderer){
	_render = renderer;
}

void CutModelManager::onAddCutModel(int id, vtkCommand* observer) throw( CutModelException){
	checkInvariant();


	CutModelData* data = new CutModelData(id,_interactor, observer, _img);
	_vectordata.push_back(data);

	_render->AddActor(data->getActor());

	//_render->UpdateCamera();
	_render->Render();
}

void CutModelManager::checkInvariant() throw( CutModelException){
	if(_img==NULL){
		throw CutModelException("The image is not set");
	}
	if(_img2==NULL){
		throw CutModelException("The image is not set");
	}
	if(_interactor==NULL){
		throw CutModelException("Interactor not set");
	}
	if(_render==NULL){
		throw CutModelException("Render not set");
	}
}

double* CutModelManager::getImageRange()throw( CutModelException){
	checkInvariant();
	return _img->GetScalarRange();
}

void CutModelManager::changeOpacity(int id,int opacity)throw( CutModelException){
	checkInvariant();
	CutModelData* current = getCutModelData(id);
	current->changeOpacity(opacity);
}

void CutModelManager::ShowViewBox(int id,bool check)throw( CutModelException){
	checkInvariant();
	CutModelData* current = getCutModelData(id);
	current->ShowViewBox(check);
}

void CutModelManager::ChangeShape(int id,int selection)throw( CutModelException){
	checkInvariant();
	CutModelData* current = getCutModelData(id);
	current->ChangeShape(selection);			
	_render->Render();
}

CutModelData* CutModelManager::getCutModelData(int id)throw( CutModelException){

	CutModelData* current = NULL;
	for(int i= 0; i < _vectordata.size();i++){
		CutModelData* temp = _vectordata[i];
		std::cout<<"id in CutModelManager:: "<<id<<std::endl;
		std::cout<<"vectordataid in CutModelManager:: "<<temp->getId()<<std::endl;

		if(temp->getId() == id){
			current =  temp;
		}
	}
	if(current ==NULL){

		throw CutModelException("Data not found");
	}
	return current;
}

void CutModelManager::updateActorDirection(int id)throw( CutModelException){
	checkInvariant();
	CutModelData* current = getCutModelData(id);
	current->udapteActorDirection();

}

void CutModelManager::changeColor(int id,double r,double g,double b)throw( CutModelException){

	checkInvariant();
	CutModelData* current = getCutModelData(id);
	current->changeColor(r,g,b);
	_render->Render();
}
void CutModelManager::RemoveActor(int id)throw( CutModelException){

	checkInvariant();

	CutModelData* current = getCutModelData(id);
	for(int i = 0; i < _vectordata.size()-1;i++){
		if(_vectordata[i]->getId()==id){				
			for(int j = i; j < _vectordata.size()-1;j++){
				_vectordata[j]=_vectordata[j+1];
			}
			i = _vectordata.size();
		}
	}
	_render->RemoveViewProp(current->getActor());		
	//_render->RemoveViewProp(current->get
	delete current;
	_vectordata.pop_back();
	_render->Render();

}

void CutModelManager::ExecuteCut(int id, double* range, bool isinside)throw( CutModelException){
	checkInvariant();

	CutModelData* current = getCutModelData(id);
	current->ExecuteCut(range, isinside,_img2);


	/*
	Setting extra information for the undo
	*/
	CutModelSaveBinInfo* undoaction = this->AddActionUndo(id, CUTMODEL_CUT);
	undoaction->setRange(range);
	undoaction->setIsInside(isinside);

}

vtkImageData* CutModelManager::GetResultImage(){
	checkInvariant();
	return _img2;
}

void CutModelManager::RefreshActor(int id){
	checkInvariant();
	CutModelData* current = getCutModelData(id);	
	_render->RemoveActor(current->getActor());
	_render->AddActor(current->getActor());	
	current->RefreshViewBox();
	_render->Render();
}

void CutModelManager::SaveCutModelData(std::string filename)throw( CutModelException){	


	throw CutModelException("not implemented");




}



void CutModelManager::LoadCutModelData(std::string filename)throw( CutModelException){

	throw CutModelException("not implemented");

}

CutModelSaveBinInfo* CutModelManager::AddActionUndo(int idc, UNDOTYPE type)throw( CutModelException){

	for(int i = _undoredo.size()-1; i > _currentaction;i--){
		delete _undoredo[i];
		_undoredo.pop_back();		
	}

	CutModelSaveBinInfo* cutmodel = new CutModelSaveBinInfo(idc, _currentaction, type, _path);
	if(type == CUTMODEL_CUT){
		cutmodel->saveMatrix4x4(this->getCutModelData(idc)->getCurrentMatrix()->GetMatrix());
		cutmodel->setCurrentShape(this->getCutModelData(idc)->getCurrentShape());
	}

	_undoredo.push_back(cutmodel);

	_currentaction++;// = _undoredo.size();
	//std::cout<<"current index "<<_currentaction;

	return cutmodel;
}

int CutModelManager::Undo()	throw( CutModelException){
	//&& _currentaction < _undoredo.size()
	if(_currentaction > 0){
		int tempaction = _currentaction-1;
		CutModelSaveBinInfo* currentundo = _undoredo[tempaction];
		CutModelData* currentmodel;

		if(currentundo->getActionType()==CUTMODEL_CUT){
			//Undo the cut
			vtkTransform* transform = currentundo->getTransformFromMatrixFile();

			currentmodel = getCutModelData(currentundo->getId());

			currentmodel->setTransform(transform, _img2);

			currentmodel->setCurrentShape(currentundo->getCurrentShape());

			currentmodel->ExecuteUnCut(currentundo->getIsInside(), _img, _img2);

		}
		//Every thing ok
		_currentaction--;
		return 0;
	}
	return -1;
}

int CutModelManager::Redo()	throw( CutModelException){

	if(_currentaction >= 0 && _currentaction < _undoredo.size()){

		CutModelSaveBinInfo* currentundo = _undoredo[_currentaction];
		CutModelData* currentmodel;

		if(currentundo->getActionType()==CUTMODEL_CUT){
			//Redo the cut
			vtkTransform* transform = currentundo->getTransformFromMatrixFile();
			currentmodel = getCutModelData(currentundo->getId());
			currentmodel->setTransform(transform, _img2);
			currentmodel->setCurrentShape(currentundo->getCurrentShape());
			currentmodel->ExecuteCut(currentundo->getRange(), currentundo->getIsInside(), _img2);
		}

		_currentaction++;

		return 0;
	}
	return -1;
}

void CutModelManager::ParallelProjectionOn(){
	_render->GetActiveCamera()->ParallelProjectionOn();
}

void CutModelManager::ParallelProjectionOff(){
	_render->GetActiveCamera()->ParallelProjectionOff();
}


//RaC
void CutModelManager::UpdatePolygon(bool mode)
{
	if(mode)
	{
		cutterstyle->Delete();
		cutterstyle = vtkInteractorStyleCutter::New();

		cutterstyle->SetInteractor ( _interactor );
		_interactor ->SetInteractorStyle( cutterstyle );
	}
	else
	{
		cutterstyle->VisibilityOff();

		loop = vtkImplicitSelectionLoop::New();
		mapper = vtkPolyDataMapper::New();
		if(cutterstyle->Finished())
		{
			if(actor3D != NULL)
			{
				_render->RemoveActor(actor3D);
			}

			loop->SetLoop( cutterstyle->GetLoopPoints() );
			loop->SetNormal( cutterstyle->GetDirection());


			/// Printing Points
			int numPoints = cutterstyle->GetLoopPoints()->GetNumberOfPoints();
			contourDirection = cutterstyle->GetDirection();

			contourPoints = cutterstyle->GetLoopPoints();

			_polygonCutter = new CutModelPolygon();

			cout<<"RaC Printing points......"<<endl;
			for(int t=0;t<numPoints;t++)
			{
				double point[3];
				cutterstyle->GetLoopPoints()->GetPoint(t,point);
				cout<<"Initial Point:"<<t<<" XX:"<<point[0]<<" YY:"<<point[1]<<" ZZ:"<<point[2]<<endl;
			}
			cout<<endl;

			sample = vtkSampleFunction::New();

			sample->SetImplicitFunction(loop);
			sample->CappingOn();			

			contour = vtkContourFilter::New();
			contour->SetInput((vtkDataObject *)sample->GetOutput());
			contour->SetValue(0,1);

			actor = contour->GetOutput();

			actor3D = vtkActor::New();			
			mapper->SetInput(actor);			 
			mapper->SetScalarModeToUseCellData();
			actor3D->SetMapper( mapper);
			_render->AddActor(actor3D);			
		}		

		interactorstyle->SetInteractor (  _interactor );
		_interactor->SetInteractorStyle( interactorstyle );
	} 

	_interactor->Render();
	_render->ResetCameraClippingRange();
}
void CutModelManager::ExecuteCutPolygon(bool inOutCut){

	_polygonCutter->setInImage(_img2);
	_polygonCutter->setPoints(contourPoints);
	_polygonCutter->setDirection(contourDirection);
	_polygonCutter->processOutImage(inOutCut);
}

void CutModelManager::InitializePolygonInteractorStyle(){

	cutterstyle = vtkInteractorStyleCutter::New();		
	interactorstyle = vtkInteractorStyleTrackballCamera ::New();
	interactorstyle->SetInteractor (  _interactor );
	_interactor->SetInteractorStyle( interactorstyle );
}