/*=========================================================================                                                                               
Program:   bbtk
Module:    $RCSfile$
Language:  C++
Date:      $Date$
Version:   $Revision$
=========================================================================*/

/* ---------------------------------------------------------------------

* Copyright (c) CREATIS-LRMN (Centre de Recherche en Imagerie Medicale)
* Authors : Eduardo Davila, Laurent Guigues, Jean-Pierre Roux
*
*  This software is governed by the CeCILL-B license under French law and 
*  abiding by the rules of distribution of free software. You can  use, 
*  modify and/ or redistribute the software under the terms of the CeCILL-B 
*  license as circulated by CEA, CNRS and INRIA at the following URL 
*  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html 
*  or in the file LICENSE.txt.
*
*  As a counterpart to the access to the source code and  rights to copy,
*  modify and redistribute granted by the license, users are provided only
*  with a limited warranty  and the software's author,  the holder of the
*  economic rights,  and the successive licensors  have only  limited
*  liability. 
*
*  The fact that you are presently reading this means that you have had
*  knowledge of the CeCILL-B license and that you accept its terms.
* ------------------------------------------------------------------------ */                                                                         

/**
*  \file 
*  \brief Class bbtk::wxVtkSceneManager . 
*/


#include "wxVtkSceneManager.h"

namespace bbtk
{


	//=========================================================================
	wxVtkSceneManager::wxVtkSceneManager(wxGEditorTabPanel *parent, wxVtk3DBaseView *baseView,int idManager)
	{
		_parent = parent;
		_numBoxes=0;
		_idManager=idManager;
		_baseView=baseView;
		_idLastController=0;
		_startDragging=false;

		if( _baseView!=NULL )
		{
			_baseView->GetWxVTKRenderWindowInteractor()->SetDropTarget((wxDropTarget*)parent);			
			configureBaseView();
			_worldState=NOTHING_HAPPENS;
			registerController(this);
			
		}

	}

	//=========================================================================

	void wxVtkSceneManager::disconnectDrop()
	{
		_baseView->GetWxVTKRenderWindowInteractor()->SetDropTarget(NULL);
  	}

	//=========================================================================

	wxVtkSceneManager::~wxVtkSceneManager()
	{
	}

	//=========================================================================

	void wxVtkSceneManager::configureBaseView()
	{
		vtkInteractorStyleBaseView2D *interactorstylebaseview = vtkInteractorStyleBaseView2D::New();

		_baseView->SetInteractorStyleBaseView(interactorstylebaseview);

		// Important to activate the 2D interaction system
		wxVTKRenderWindowInteractor *iren = _baseView->GetWxVTKRenderWindowInteractor();
		interactorstylebaseview->SetInteractor ( iren );
		iren->SetInteractorStyle(interactorstylebaseview);
		interactorstylebaseview->SetwxVtkBaseView(_baseView);
		
		_baseView->GetRenderer()->GetActiveCamera()->ParallelProjectionOn();
		_baseView->GetRenderer()->ResetCamera(-100,100,-100,100,900,1000);
		
		_baseView->GetRenderer()->SetBackground(0.9,0.9,0.9);
		_baseView->GetRenderer()->GradientBackgroundOff();
		_baseView->Refresh();
	}

	//=========================================================================

	void wxVtkSceneManager::createGBlackBox(int x, int y, std::string packageName, std::string boxType)
	{

		int windowWidth=_baseView->GetRenWin()->GetSize()[0];
		int windowHeight=_baseView->GetRenWin()->GetSize()[1];

		int type = GBLACKBOX;

		//Create the MVC Objects
		
		GBlackBoxModel *model = (GBlackBoxModel*)GObjectsMVCFactory::getInstance()->createGObjectModel(type);
		vtkGObjectView *view = GObjectsMVCFactory::getInstance()->createGObjectView(type);
		GObjectController* controller = GObjectsMVCFactory::getInstance()->createGObjectController(type);
		
		BlackBoxDescriptor::Pointer descriptor = GObjectsMVCFactory::getInstance()->getBlackBoxDescriptor(packageName, boxType);
		
		//Prepares the initial model
		//The coordinates obtained are the following. Top-Left:x=0,y=0 Bottom-Right:x=width,y=height  

		double xx = x;
		double yy = windowHeight-y;
		
		//z value is not important yet, because it is only used a parallel projection
		double zz = 900;

		_baseView->TransCoordScreenToWorld(xx,yy,zz);
		model->setInicPoint(xx,yy,zz);
		
		_numBoxes++;
		std::stringstream stream;
		
		if(_numBoxes<10)
		{
			stream << "Box0" << _numBoxes;
		}
		else
		{
			stream << "Box" << _numBoxes;
		}
		std::string arraystring = stream.str();

		model->setBBTKName(arraystring);
		model->setBBTKType(boxType);
		model->setBBTKPackage(packageName);
				
		model->addObserver(view);
		model->addObserver(this);

		//Iterate and create the input ports
		std::map<std::string, BlackBoxInputDescriptor*> descriptorInMap = descriptor->GetInputDescriptorMap();
		std::map<std::string, BlackBoxInputDescriptor*>::iterator itInput;

		int i=0;
		for(itInput = descriptorInMap.begin(); itInput != descriptorInMap.end(); ++itInput)
		{
			BlackBoxInputDescriptor *desc = itInput->second;
			createGInputPort(GINPUTPORT,i,model,desc);
			i++;
		}

		//Iterate and create the output ports
		std::map<std::string, BlackBoxOutputDescriptor*> descriptorOutMap = descriptor->GetOutputDescriptorMap();
		std::map<std::string, BlackBoxOutputDescriptor*>::iterator itOutput;

		i=0;
		for(itOutput = descriptorOutMap.begin();itOutput != descriptorOutMap.end(); ++itOutput)
		{
			BlackBoxOutputDescriptor *desc = itOutput->second;
			createGOutputPort(GOUTPUTPORT,i,model,desc);
			i++;
		}


		//Associates the view with the correspondent renderer and the  model.
		//(NOTE: Refresh is only made by the view)
		view->setModel(model);
		view->setBaseView(_baseView);
		view->initVtkObjects();
		
		//Associates the controller with the correspondent model and view
		controller->setModelAndView(model,view);

		//Resgiter change to the observers of the actual model
		model->notifyObservers(_idManager);
		
		//Register the controller of the new object
		registerController((InteractorStyleMaracas*) controller);

		//Add the object to the objects list 
		int newId = _controllers.size();
		controller->setId(newId);
		_controllers[newId] = controller;

	}

	//=========================================================================

	void wxVtkSceneManager::createGInputPort(int portType, int posinBox,GBlackBoxModel *blackBox, BlackBoxInputDescriptor *desc)
	{
		GPortController* portController = createGPort(portType,desc->GetName(),desc->GetTypeName(),posinBox,blackBox);
		blackBox->addInputPort((GPortModel*)portController->getModel());
	}

	//=========================================================================

	void wxVtkSceneManager::createGOutputPort(int portType, int posinBox,GBlackBoxModel *blackBox, BlackBoxOutputDescriptor *desc)
	{
		GPortController* portController = createGPort(portType,desc->GetName(),desc->GetTypeName(),posinBox,blackBox);
		blackBox->addOutputPort((GPortModel*)portController->getModel());
	}

	//=========================================================================

	GPortController* wxVtkSceneManager::createGPort(int portType,std::string bbtkName, std::string bbtkType, int posInBox,GBlackBoxModel *blackBox)
	{
		int type = GPORT;

		//Create the MVC Objects
		GPortModel *model = (GPortModel*)GObjectsMVCFactory::getInstance()->createGObjectModel(type);
		vtkGObjectView *view = GObjectsMVCFactory::getInstance()->createGObjectView(type);
		GObjectController* controller = GObjectsMVCFactory::getInstance()->createGObjectController(type);

		model->registerInBox(blackBox,portType, posInBox);
		
		model->setBBTKType(bbtkType);
		model->setBBTKName(bbtkName);

		model->addObserver(view);
		model->addObserver(this);

		//Associates the view with the correspondent renderer and the  model.
		//(NOTE: Refresh is only made by the view)
		view->setModel(model);
		view->setBaseView(_baseView);
		view->initVtkObjects();
		
		//Associates the controller with the correspondent model and view
		controller->setModelAndView(model,view);

		model->notifyObservers(_idManager);

		//Register the controller of the new object
		registerController((InteractorStyleMaracas*) controller);
		
		int newId = _controllers.size();
		controller->setId(newId);
		_controllers[newId] = controller;

		return (GPortController*)controller;
	}

	//=========================================================================

	void wxVtkSceneManager::createGConnector(GPortModel* startPort)
	{
		int type = GCONNECTOR;

		manualConnectorContourController* manContourControl	= new manualConnectorContourController();
		manualConnectorContourView* manContourView	= new manualConnectorContourView();
		manualContourModel* manContourModel	= new manualContourModel();

		GConnectorController* connectorcontroller = new GConnectorController();				
		GConnectorModel* connectorModel = new GConnectorModel();
		GConnectorView* connectorView = new GConnectorView();
		connectorModel->setGObjectType(type);

		manContourModel->SetCloseContour(false);
		connectorModel->setStartPort(startPort);

		manContourView->SetModel( manContourModel );
		manContourView->SetWxVtkBaseView( _baseView );
		manContourView->SetRange( 0.5 );
		manContourView->SetZ( 900 );

		manContourView->SetColorNormalContour(0, 0, 1);
		manContourView->SetColorEditContour(0.5, 0.5, 0.5);
		manContourView->SetColorSelectContour(1, 0.8, 0);
		manContourView->SetWidthLine(1);

		manContourControl->SetModelView( manContourModel , manContourView );
		
		manContourControl->CreateNewManualContour();

		manContourView->RefreshContour();


		double x,y,z;
		connectorModel->getInicPoint(x,y,z);

		manContourControl->SetState(1);
		manContourModel->SetCloseContour(false);
		
		manContourModel->AddPoint(x,y,z);
		manContourView->AddPoint();

		manContourModel->AddPoint(x,y,z);
		manContourView->AddPoint();

		int bak= manContourControl->GetNumberOfPointsManualContour() - 1;
		manContourControl->_bakIdPoint=bak;
		manContourView->Refresh();

		manContourControl->SetMoving( false );

		registerController((InteractorStyleMaracas*) connectorcontroller);

		connectorcontroller->setManualContourController(manContourControl);		
		connectorModel->setManualContourModel(manContourModel);
		connectorView->setManualContourView(manContourView);
		connectorView->setModel(connectorModel);
		connectorcontroller->setModelAndView(connectorModel,connectorView);

		int newId = _controllers.size();
		connectorcontroller->setId(newId);
		_controllers[newId] = connectorcontroller;

	}

	//=========================================================================

	void wxVtkSceneManager::registerController(InteractorStyleMaracas *param)
	{
		vtkInteractorStyleBaseView* baseViewControlManager = (vtkInteractorStyleBaseView*)_baseView->GetInteractorStyleBaseView();
		baseViewControlManager->AddInteractorStyleMaracas( param );
	}

	//=========================================================================

	void wxVtkSceneManager::unregisterController(InteractorStyleMaracas *param)
	{
		vtkInteractorStyleBaseView* baseViewControlManager = (vtkInteractorStyleBaseView*)_baseView->GetInteractorStyleBaseView();
		baseViewControlManager->RemoveInteractorStyleMaracas( param );
	}

	//=========================================================================

	vtkRenderer* wxVtkSceneManager::getRenderer()
	{
		return _baseView->GetRenderer();
	}

	//=========================================================================

	vtkRenderWindow* wxVtkSceneManager::getRenderWindow()
	{
		return _baseView->GetRenWin();
	}
	//=========================================================================

		
	void wxVtkSceneManager::update(int idController,int command)
	{
		if(command != NO_COMMAND)
		{
			if(command == ADD_TO_SELECTED)
			{
				GObjectController* cont = _controllers[idController];

				bool foundID=false;
				for (int i=0; i<_selectedObjects.size() && foundID==false; i++)
				{
					int id = _selectedObjects[i];
					if(id==idController)
					{
						foundID = true;
					}
				}
				if(!foundID)
				{
					int id = idController;
					_selectedObjects.push_back(id);
				}

			}
			else if(command == INIT_CREATION_CONTOUR)
			{	
				_worldState = INIT_CREATION_CONTOUR;
				GObjectController* cont = _controllers[idController];
				GPortModel* startOutputPort = (GPortModel*)cont->getModel();
				

				// The last one is the controller of the connector
				for(int i=0;i<_controllers.size();i++)
				{
					GObjectController* cont = _controllers[i];
					if(cont->getGObjectType() == GPORT )
					{
						GPortModel* port = (GPortModel*)cont->getModel();
						if(port->getPortType()==GINPUTPORT)
						{
							cont->SetActive(true);
						}
						else
						{
							cont->getView()->setState(NOTHING_HAPPENS);
							cont->getModel()->notifyObservers(_idManager);
							cont->SetActive(false);
						}
					}
					else
					{
						cont->getView()->setState(NOTHING_HAPPENS);
						cont->getModel()->notifyObservers(_idManager);
						cont->SetActive(false);
					}				
				}

				_selectedObjects.clear();

				createGConnector(startOutputPort);

			}
			else if(command == FIN_CREATION_CONTOUR && _worldState == INIT_CREATION_CONTOUR)
			{				
				_worldState = NOTHING_HAPPENS;
				int id = _controllers.size()-1;
				GObjectController* cont = _controllers[id];			
				GConnectorModel* modelContour = (GConnectorModel*)cont->getModel();

				GObjectController* finPort = _controllers[idController];
				if(finPort->getGObjectType() == GPORT)
				{
					GPortModel* modelPort = (GPortModel*)finPort->getModel();
					modelContour->setEndPort(modelPort);
				}			

				manualConnectorContourController* manCont = ((GConnectorController*)cont)->getManualContourController();			
				manualConnectorContourView* connView = (manualConnectorContourView*)manCont->GetManualViewBaseContour();
				connView->Refresh();

				for(int i=0;i<_controllers.size();i++)
				{
					GObjectController* cont = _controllers[i];
					if(cont->getView()!=NULL)
					{
						cont->getView()->setState(NOTHING_HAPPENS);
						cont->getModel()->notifyObservers(_idManager);
					}
					cont->SetActive(true);								
				}
			}
			
		}
	}

	//=========================================================================

	bool wxVtkSceneManager::OnMouseMove()
	{
		int X,Y;
		wxVTKRenderWindowInteractor *wxVTKiren;
		wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
		wxVTKiren->GetEventPosition(X,Y);
	
		
		if(_worldState == DRAG_OBJECTS)
		{			
			for (int i=0; i<_selectedObjects.size(); i++)
			{
				int id = _selectedObjects[i];
				GObjectController* cont = _controllers[id];
				if(_startDragging)
				{
					cont->getView()->setStartDragging(true);
				}
				cont->getView()->moveObject(X,Y);
				cont->getView()->setState(DRAG);
				cont->getModel()->notifyObservers(_idManager);
			}

			std::map<int, GObjectController*>::iterator it;

			for(it = _controllers.begin(); it != _controllers.end(); ++it)
			{
				GObjectController *desc = it->second;
				if(desc->getGObjectType()==GCONNECTOR)
				{
					GConnectorView* vconn = (GConnectorView*)desc->getView();
					vconn->updateStartEndPoints();
				}
			}
			
			_startDragging=false;

		}
		else if(_worldState == NOTHING_HAPPENS || _worldState == INIT_CREATION_CONTOUR)
		{
			std::map<int, GObjectController*>::iterator it;

			for(it = _controllers.begin(); it != _controllers.end(); ++it)
			{
				GObjectController *desc = it->second;
				int type = desc->getGObjectType();
				int state = desc->getView()->getState();
				
				if(state == HIGHLIGHTED){

					updateStatusBar(desc->getStatusText());
					if(type==GBLACKBOX)
					{
						GBlackBoxModel *mod = (GBlackBoxModel*)desc->getModel();
						_parent->displayBlackBoxInfo(mod->getBBTKPackage(),mod->getBBTKType());
					}
				}
			}
		}
		
		


		return true;
	}

	//=========================================================================
	
	bool wxVtkSceneManager::OnLeftButtonDown()
	{
		
		if(_selectedObjects.size()!=0)
		{
			_worldState = DRAG_OBJECTS;
			_startDragging = true;

			for (int i = 0; i < _selectedObjects.size(); i++)
			{
				int id = _selectedObjects[i];
				GObjectController* cont = _controllers[id];
				cont->getView()->setState(DRAG);
				cont->getModel()->notifyObservers(_idManager);
			}
		}
		
		
		
		return true;
	}

	//=========================================================================
	
	bool wxVtkSceneManager::OnLeftButtonUp()
	{
		if(_worldState == DRAG_OBJECTS)
		{
			_worldState = NOTHING_HAPPENS;

			for (int i = 0; i < _selectedObjects.size(); i++)
			{
				int id = _selectedObjects[i];
				GObjectController* cont = _controllers[id];
				cont->getView()->setState(SELECTED);
				cont->getModel()->notifyObservers(_idManager);
			}
		}
		return true;
	}

	//=========================================================================

	bool wxVtkSceneManager::OnRightButtonUp()
	{
		for (int i = 0; i < _selectedObjects.size(); i++)
		{
			int id = _selectedObjects[i];
			GObjectController* cont = _controllers[id];
			cont->SetActive(true);
			cont->getView()->setState(NOTHING_HAPPENS);
			cont->getModel()->notifyObservers(_idManager);
		}

		_selectedObjects.clear();

		return true;
	}

	//=========================================================================

	bool wxVtkSceneManager::OnLeftDClick()
	{
		int X,Y;
		wxVTKRenderWindowInteractor *wxVTKiren;
		wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetWxVTKRenderWindowInteractor();
		wxVTKiren->GetEventPosition(X,Y);

		std::map<int, GObjectController*>::iterator it;

		bool clickOnObject = false;

		for(it = _controllers.begin(); it != _controllers.end() && clickOnObject==false; ++it)
		{
			GObjectController *cont = it->second;
			int type = cont->getGObjectType();
			
			if(cont->getView()->isPointInside(X,Y))
			{
				if(type==GBLACKBOX)
				{
					for (int i=0; i<_selectedObjects.size(); i++)
					{
						int id = _selectedObjects[i];
						GObjectController* control = _controllers[id];
						control->getView()->setState(NOTHING_HAPPENS);
					}
					_selectedObjects.clear();

					GBlackBoxModel *bbmodel = (GBlackBoxModel*)cont->getModel();
					_parent->editBlackBox(bbmodel);
				}
				clickOnObject = true;			
			}
		}

		if(clickOnObject==false)
		{
			_parent->editDiagramParameters(this);
		}

		return true;
	}
	
	//=========================================================================

	bool wxVtkSceneManager::OnChar()
	{	
		char keyCode = _vtkInteractorStyleBaseView->GetInteractor()-> GetKeyCode();
		
		// KeyCode 127 : Delete Key
		// KeyCode 8 : Backspace Key
		if(keyCode == 8 || keyCode == 127)
		{
			if(_selectedObjects.size()>0)
			{
				for(int i=0;i<_selectedObjects.size();i++)
				{
					int id = _selectedObjects[i];
					removeObject(id);
				}
				_selectedObjects.clear();
			}
		}

		return true;
	}

	//=========================================================================

	void wxVtkSceneManager::removeObject(int id)
	{
		GObjectController *control = _controllers[id];
		std::vector<int> controllersToRemove;

		if(control->getGObjectType()==GBLACKBOX)
		{
			GBlackBoxModel *bbmod = (GBlackBoxModel*)control->getModel();
			std::vector<GPortModel*> inputs = bbmod->getInputPorts();
			
			for(int i = 0;i<inputs.size();i++)
			{
				controllersToRemove.push_back(inputs[i]->getObjectId());				
			}

			std::vector<GPortModel*> outputs = bbmod->getOutputPorts();

			for(int i = 0;i<outputs.size();i++)
			{
				controllersToRemove.push_back(outputs[i]->getObjectId());
			}

			controllersToRemove.push_back(bbmod->getObjectId());
		}

		for(int i = 0;i<controllersToRemove.size();i++)
		{
			int id = controllersToRemove[i];
			GObjectController *cont = _controllers[id];			
			cont->removeFromScene();
			unregisterController((InteractorStyleMaracas*)cont);			
			_controllers.erase(id);
		}


	}

	//=========================================================================

	void wxVtkSceneManager::displayBlackBoxInfo(std::string packageName, std::string boxName)
	{
		_parent->displayBlackBoxInfo(packageName,boxName);
	}

	//=========================================================================

	void wxVtkSceneManager::updateStatusBar(std::string textStatus)
	{
		_parent->updateStatusBar(textStatus);
	}

	//=========================================================================

	std::string wxVtkSceneManager::getDiagramScript()
	{
		bool existsExec=false;

		std::vector<std::string> packages;
		std::vector<int> boxes;
		std::vector<int> connections;
		std::vector<int> execBoxes;

		std::map<int, GObjectController*>::iterator it;

		for(it = _controllers.begin(); it != _controllers.end(); ++it)
		{
			GObjectController *desc = it->second;
			int type = desc->getGObjectType();

			if(type==GBLACKBOX)
			{
				GBlackBoxModel *mod = (GBlackBoxModel*)desc->getModel();
				
				std::string pkg = mod->getBBTKPackage();
				bool existsPkg = false;
				for(int t = 0;t<packages.size() && existsPkg == false;t++)
				{
					if(packages[t]==pkg)
					{
						existsPkg=true;
					}
				}
				if(!existsPkg)
				{
					packages.push_back(pkg);
				}


				boxes.push_back(it->first);
				if(mod->isExecutable())
				{
					execBoxes.push_back(it->first);
					existsExec=true;
				}
			}
			else if(type==GCONNECTOR)
			{
				connections.push_back(it->first);
			}
		}

		std::string script = "";
		script+="# BBTK GEditor Script\n";
		script+="# ----------------------\n";
		if(existsExec)
		{
			int i;
			for(i = 0; i<packages.size();i++)
			{
				script+="include ";
				script+=packages[i];
				script+="\n";
			}

			script+="include std\n";

			for(i = 0; i<boxes.size();i++)
			{
				script+="new ";
				int id = boxes[i];
				GObjectController *control = _controllers[id];
				GBlackBoxModel *model = (GBlackBoxModel*)control->getModel();

				script+=model->getBBTKType();
				script+=" ";
				script+=model->getBBTKName();
				script+="\n";

				std::vector<GPortModel*> inputs = model->getInputPorts();
				for(int j = 0; j<inputs.size();j++)
				{
					GPortModel* inputPort = inputs[j];
					if(inputPort->isValueSet())
					{
						script+="set ";
						script+=model->getBBTKName();
						script+=".";
						script+=inputPort->getBBTKName();
						script+=" ";
						script+=inputPort->getValue();
						script+="\n";
					}
				}

			}

			for(i = 0; i<connections.size();i++)
			{
				script+="connect ";
				int id = connections[i];
				GObjectController *control = _controllers[id];
				GConnectorModel *model = (GConnectorModel*)control->getModel();

				//Start Connection info
				GPortModel *start = model->getStartPort();
				script+=start->getParentBox()->getBBTKName();
				script+=".";
				script+=start->getBBTKName();

				script+=" ";

				//End Connection info
				GPortModel *end = model->getEndPort();
				script+=end->getParentBox()->getBBTKName();
				script+=".";
				script+=end->getBBTKName();

				script+="\n";
			}

			for(i = 0; i<execBoxes.size();i++)
			{
				script+="exec ";
				int id = execBoxes[i];
				GObjectController *control = _controllers[id];
				GBlackBoxModel *model = (GBlackBoxModel*)control->getModel();

				script+=model->getBBTKName();
				script+="\n";
			}

		}

		return script;
	}

	//=========================================================================

}  // EO namespace bbtk

// EOF