#include "wxMaracasRenderTabbedPanel.h"
#include "HistogramDialogComboBox.h"

#include "wxMaracasMultipleVolumeRendererPanel.h"
#include "wxMaracasSurfaceRenderingPanel.h"
#include "wxMaracasSurfaceRenderingProp3DMHD.h"
#include "wxMaracasMultipleVolumeRendererManagerData.h"

#include <wx/colordlg.h>
#include <wx/button.h> 

#include <OpenImage.xpm>
#include "Color.xpm"

#include <vtkProp3D.h>

/**
** Class constructor
**/
wxMaracasRenderTabbedPanel::wxMaracasRenderTabbedPanel(wxWindow* parent, int id)
: wxPanel(parent, -1, wxDefaultPosition, wxDefaultSize)
{
	_id = id;
	volmanager = new wxMaracasMultipleVolumeRendererManager();
	surrendmanager1 = new wxMaracasSurfaceRenderingManager();
	surrendmanager2 = new wxMaracasSurfaceRenderingManager();
	surrendmanager3 = new wxMaracasSurfaceRenderingManager();
}

/**
** Class Destructor
**/
wxMaracasRenderTabbedPanel::~wxMaracasRenderTabbedPanel()
{	
	//wxMaracasRenderTabbedPanel::getInstance()->addRemoveActorV(_propid, false);
	//wxMaracasRenderTabbedPanel::getInstance()->addRemoveActorSA(_propid, false);
	//wxMaracasRenderTabbedPanel::getInstance()->addRemoveActorSB(_propid, false);
	//wxMaracasRenderTabbedPanel::getInstance()->addRemoveActorSC(_propid, false);
	this->deleteVolume(_id);
	delete wxtabs;	
}

/**
** Initializes rendered images, and creates and adds elements to the panel
**/
void wxMaracasRenderTabbedPanel::createControls(vtkImageData* inImg, std::string pathfile, std::string filename)
{
	wxFlexGridSizer* sizerrenderprop = new wxFlexGridSizer(1);

	wxFlexGridSizer* sizercheck = new wxFlexGridSizer(2);
	checkboxVol = new  wxCheckBox(this,-1,wxString(_T("Volume Rendering")));
	Connect(checkboxVol->GetId(), wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction)&wxMaracasRenderTabbedPanel::onCheckBoxVChange);	
	checkboxVol->SetValue(true);	
	sizercheck->Add(checkboxVol, wxFIXED_MINSIZE);

	checkboxSA = new  wxCheckBox(this,-1,wxString(_T("Surface Rendering A")));
	Connect(checkboxSA->GetId(), wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction)&wxMaracasRenderTabbedPanel::onCheckBoxSAChange);	
	checkboxSA->SetValue(true);	
	sizercheck->Add(checkboxSA, wxFIXED_MINSIZE);	

	checkboxSB = new  wxCheckBox(this,-1,wxString(_T("Surface Rendering B")));
	Connect(checkboxSB->GetId(), wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction)&wxMaracasRenderTabbedPanel::onCheckBoxSBChange);	
	checkboxSB->SetValue(true);	
	sizercheck->Add(checkboxSB, wxFIXED_MINSIZE);

	checkboxSC = new  wxCheckBox(this,-1,wxString(_T("Surface Rendering C")));
	Connect(checkboxSC->GetId(), wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction)&wxMaracasRenderTabbedPanel::onCheckBoxSCChange);	
	checkboxSC->SetValue(true);	
	sizercheck->Add(checkboxSC, wxFIXED_MINSIZE);

	wxButton* _openParameters = new wxButton(this, -1, wxString(_T("Apply Transformation")));	
	Connect(_openParameters->GetId(), wxEVT_COMMAND_BUTTON_CLICKED, (wxObjectEventFunction)&wxMaracasRenderTabbedPanel::onOpenParameters);			
	sizercheck->Add(_openParameters,wxFIXED_MINSIZE);

	wxButton* _openCutter = new wxButton(this, -1, wxString(_T("Open Cutter View")));	
	Connect(_openCutter->GetId(), wxEVT_COMMAND_BUTTON_CLICKED, (wxObjectEventFunction)&wxMaracasRenderTabbedPanel::onOpenCutter);			
	sizercheck->Add(_openCutter,wxFIXED_MINSIZE);
	sizerrenderprop->Add(sizercheck, wxFIXED_MINSIZE);

	wxtabs = new wxNotebook(this, -1);

	if(inImg == NULL)
	{
		vtkImageData* img = volmanager->getImageData(pathfile);
		//vtkImageData* img1 = surrendmanager1->getImageData(pathfile);
		//vtkImageData* img2 = surrendmanager2->getImageData(pathfile);
		//vtkImageData* img3 = surrendmanager3->getImageData(pathfile);
		if(img!=NULL /*&& img1!=NULL && img2!=NULL && img3!=NULL*/)
		{
			addVolume(img, filename);
			addSurface1(img, filename);
			addSurface2(img, filename);
			addSurface3(img, filename);	
			wxtabs->Refresh();
		}
	}	
	else
	{
		addVolume(inImg, filename);
		addSurface1(inImg, filename);
		addSurface2(inImg, filename);
		addSurface3(inImg, filename);	
		wxtabs->Refresh();
	}

	sizerrenderprop->Add(wxtabs, wxSizerFlags().Expand().Center());

	this->SetSizer(sizerrenderprop, true);		
	this->SetAutoLayout( true );
}


/**
** Sets given renderer
**/
void wxMaracasRenderTabbedPanel::setRenderer(vtkRenderer* renderer)
{
	volmanager->setRenderer(renderer);
	surrendmanager1->setRenderer(renderer);
	surrendmanager2->setRenderer(renderer);
	surrendmanager3->setRenderer(renderer);
}

/**
** Adds a volume using Volume Rendering
**/
void wxMaracasRenderTabbedPanel::addVolume(vtkImageData* img, std::string dataname)
{
	try
	{
		int _propidV = volmanager->addVolume(_id, img, dataname);
		if(_propidV!=-1)
		{
			wxMaracasMultipleVolumeRendererPanel* controlpanV = new wxMaracasMultipleVolumeRendererPanel(wxtabs, _propidV, img, true);
			wxtabs->AddPage(controlpanV, _T("Vol Rendering"), true);
			controlpanV->updateVolume();
		}
	}
	catch(char* str)
	{
		std::cout << "Exception : " << str << '\n';
		wxMessageDialog* diag = new wxMessageDialog(this, wxString(str,wxConvUTF8 ), wxString(str,wxConvUTF8 ), wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
}

/**
** Adds a volume using surface rendering
**/
void wxMaracasRenderTabbedPanel::addSurface1(vtkImageData* img, std::string dataname)
{
	try
	{
		int _propidSA = surrendmanager1->addPropMHD(_id, img, dataname);
		
		if(_propidSA!=-1)
		{
			wxMaracasSurfaceRenderingPanel* controlpanSA = new wxMaracasSurfaceRenderingProp3DMHD(wxtabs, _propidSA, true, 1);
			int maxiso = surrendmanager1->getMaxIsoValue(_propidSA);
			((wxMaracasSurfaceRenderingProp3DMHD*)controlpanSA)->createControls(maxiso);
			wxtabs->AddPage(controlpanSA, _T("SR A"));
		}
	}
	catch(char* str)
	{
		std::cout << "Exception : " << str << '\n';
		wxMessageDialog* diag = new wxMessageDialog(this, wxString(str,wxConvUTF8 ), wxString(str,wxConvUTF8 ), wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
}

/**
** Adds a volume using surface rendering
**/
void wxMaracasRenderTabbedPanel::addSurface2(vtkImageData* img, std::string dataname)
{
	try
	{
		int _propidSB = surrendmanager2->addPropMHD(_id, img, dataname);
		if(_propidSB!=-1)
		{
			wxMaracasSurfaceRenderingPanel* controlpanSB = new wxMaracasSurfaceRenderingProp3DMHD(wxtabs, _propidSB, true, 2);
			int maxiso = surrendmanager2->getMaxIsoValue(_propidSB);
			((wxMaracasSurfaceRenderingProp3DMHD*)controlpanSB)->createControls(maxiso);
			wxtabs->AddPage(controlpanSB, _T("SR B"));

		}
	}
	catch(char* str)
	{
		std::cout << "Exception : " << str << '\n';
		wxMessageDialog* diag = new wxMessageDialog(this, wxString(str,wxConvUTF8 ), wxString(str,wxConvUTF8 ), wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
}

/**
** Adds a volume using Surface Rendering
**/
void wxMaracasRenderTabbedPanel::addSurface3(vtkImageData* img, std::string dataname)
{
	try
	{
		int _propidSC = surrendmanager3->addPropMHD(_id, img, dataname);

		if(_propidSC!=-1)
		{
			wxMaracasSurfaceRenderingPanel* controlpanSC = new wxMaracasSurfaceRenderingProp3DMHD(wxtabs, _propidSC, true, 3);
			int maxiso = surrendmanager3->getMaxIsoValue(_propidSC);
			((wxMaracasSurfaceRenderingProp3DMHD*)controlpanSC)->createControls(maxiso);
			wxtabs->AddPage(controlpanSC, _T("SR C"));
		}
	}
	catch(char* str)
	{
		std::cout << "Exception : " << str << '\n';
		wxMessageDialog* diag = new wxMessageDialog(this, wxString(str,wxConvUTF8 ), wxString(str,wxConvUTF8 ), wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
}

/**
** Deletes complete volume
**/
void wxMaracasRenderTabbedPanel::deleteVolume(int volid)
{
	try
	{
		volmanager->deleteActor(volid);
		surrendmanager1->deleteActor(volid);
		surrendmanager2->deleteActor(volid);
		surrendmanager3->deleteActor(volid);
	}
	catch(char* str)
	{
		std::cout << "Exception : " << str << '\n';
		wxMessageDialog* diag = new wxMessageDialog(this, wxString(str,wxConvUTF8 ), wxString(str,wxConvUTF8 ), wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
}

/**
** Adds or removes volume rendering actor with given ID
**/
void wxMaracasRenderTabbedPanel::addRemoveActorV(int id, bool addremove)
{
	try{
		volmanager->addRemoveActor(id, addremove);
	}
	catch(char* str){
		std::cout << "Exception : " << str << '\n';
		wxMessageDialog* diag = new wxMessageDialog(this, wxString(str,wxConvUTF8 ), wxString(str,wxConvUTF8 ), wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
}

/**
** Adds or removes surface rendering actor with given ID
**/
void wxMaracasRenderTabbedPanel::addRemoveActorSA(int id, bool addremove)
{
	try{
		surrendmanager1->addRemoveActor(id, addremove);
	}
	catch(char* str){
		std::cout << "Exception : " << str << '\n';
		wxMessageDialog* diag = new wxMessageDialog(this, wxString(str,wxConvUTF8 ), wxString(str,wxConvUTF8 ), wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
}

/**
** Adds or removes surface rendering actor with given ID
**/
void wxMaracasRenderTabbedPanel::addRemoveActorSB(int id, bool addremove)
{
	try{
		surrendmanager2->addRemoveActor(id, addremove);
	}
	catch(char* str){
		std::cout << "Exception : " << str << '\n';
		wxMessageDialog* diag = new wxMessageDialog(this, wxString(str,wxConvUTF8 ), wxString(str,wxConvUTF8 ), wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
}

/**
** Adds or removes surface rendering actor with given ID
**/
void wxMaracasRenderTabbedPanel::addRemoveActorSC(int id, bool addremove)
{	
	try{
		surrendmanager3->addRemoveActor(id, addremove);
	}
	catch(char* str){
		std::cout << "Exception : " << str << '\n';
		wxMessageDialog* diag = new wxMessageDialog(this, wxString(str,wxConvUTF8 ), wxString(str,wxConvUTF8 ), wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
}	

/**
** Sets color points values for the given volume rendering identified by parameter: volumeid
**/
void wxMaracasRenderTabbedPanel::SetValuesColorPointsFunction(int volid, std::vector<double> greylevelcolors,std::vector<double> red,std::vector<double> green,std::vector<double> blue)
{
	volmanager->setVolumeColor(volid, greylevelcolors, red, green, blue);
}

/**
** Sets points values for the given volume rendering identified by parameter: volumeid
**/
void wxMaracasRenderTabbedPanel::SetValuesPointsFunction(int volid, std::vector<double> greylevel, std::vector<double> values)
{
	try{
		volmanager->setVolumeOpacity(volid, greylevel, values);
	}
	catch(char* str)
	{
		wxString s( str,wxConvUTF8 );
		wxMessageDialog* diag = new wxMessageDialog(this, s, s, wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
	
}

/**
** Returns transfer function for the given volume rendering identified by parameter: volumeid
**/
vtkPiecewiseFunction* wxMaracasRenderTabbedPanel::GetTransferFunction(int volumeid)
{
	return volmanager->GetTransferFunction(volumeid);
}

/**
** Returns color function for the given volume rendering identified by parameter: volumeid
**/
vtkColorTransferFunction* wxMaracasRenderTabbedPanel::GetColorFunction(int volumeid)
{
    return volmanager->GetColorFunction(volumeid);
}

/**
** Changes color function by the given value for the given volume rendering identified by parameter: volumeid
**/
void wxMaracasRenderTabbedPanel::changeOpacityA(int _propid, int value)
{
	surrendmanager1->changeOpacity(_propid,value);
}

/**
** Changes isoValue by the given value for the given surface rendering image identified by parameter: propid
**/
void wxMaracasRenderTabbedPanel::changeIsoValueA(int propid, double value)
{
	surrendmanager1->changeIsoValue(propid, value);
}

/**
** Changes color for the given surface rendering image identified by parameter: propid
**/
void wxMaracasRenderTabbedPanel::changeColorA(int propid, double red, double green, double blue)
{
	try
	{
		surrendmanager1->changeColor(propid, red, green, blue);
	}
	catch(char* str)
	{
		wxString s( str,wxConvUTF8 );
		wxMessageDialog* diag = new wxMessageDialog(this, s, s, wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
}

/**
** Changes color function by the given value for the given volume rendering identified by parameter: volumeid
**/
void wxMaracasRenderTabbedPanel::changeOpacityB(int _propid, int value)
{
	surrendmanager2->changeOpacity(_propid,value);
}

/**
** Changes isoValue by the given value for the given surface rendering image identified by parameter: propid
**/
void wxMaracasRenderTabbedPanel::changeIsoValueB(int propid, double value)
{
	surrendmanager2->changeIsoValue(propid, value);
}

/**
** Changes color for the given surface rendering image identified by parameter: propid
**/
void wxMaracasRenderTabbedPanel::changeColorB(int propid, double red, double green, double blue)
{
	try
	{
		surrendmanager2->changeColor(propid, red, green, blue);
	}
	catch(char* str)
	{
		wxString s( str,wxConvUTF8 );
		wxMessageDialog* diag = new wxMessageDialog(this, s, s, wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
}

/**
** Changes color function by the given value for the given volume rendering identified by parameter: volumeid
**/
void wxMaracasRenderTabbedPanel::changeOpacityC(int _propid, int value)
{
	surrendmanager3->changeOpacity(_propid,value);
}

/**
** Changes isoValue by the given value for the given surface rendering image identified by parameter: propid
**/
void wxMaracasRenderTabbedPanel::changeIsoValueC(int propid, double value)
{
	surrendmanager3->changeIsoValue(propid, value);
}

/**
** Changes color for the given surface rendering image identified by parameter: propid
**/
void wxMaracasRenderTabbedPanel::changeColorC(int propid, double red, double green, double blue)
{
	try
	{
		surrendmanager3->changeColor(propid, red, green, blue);
	}
	catch(char* str)
	{
		wxString s( str,wxConvUTF8 );
		wxMessageDialog* diag = new wxMessageDialog(this, s, s, wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
}

/**
** Method called when VolumeRendering checkbox status changes: Either shows or hides VolumeRendering image
**/
void wxMaracasRenderTabbedPanel::onCheckBoxVChange(wxCommandEvent& event)
{
	try{
		volmanager->addRemoveActor(this->getPropIdV(), checkboxVol->GetValue());	
	}
	catch(char* str){
		std::cout << "Exception : " << str << '\n';
		wxMessageDialog* diag = new wxMessageDialog(this, wxString(str,wxConvUTF8 ), wxString(str,wxConvUTF8 ), wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
}

/**
** Method called when SurfaceRendering A checkbox status changes: Either shows or hides SurfaceRendering image
**/
void wxMaracasRenderTabbedPanel::onCheckBoxSAChange(wxCommandEvent& event)
{	
	try{
		surrendmanager1->addRemoveActor(this->getPropIdV(), checkboxSA->GetValue());	
	}
	catch(char* str){
		std::cout << "Exception : " << str << '\n';
		wxMessageDialog* diag = new wxMessageDialog(this, wxString(str,wxConvUTF8 ), wxString(str,wxConvUTF8 ), wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
}

/**
** Method called when SurfaceRendering B checkbox status changes: Either shows or hides SurfaceRendering B image
**/
void wxMaracasRenderTabbedPanel::onCheckBoxSBChange(wxCommandEvent& event)
{	
	try{
		surrendmanager2->addRemoveActor(this->getPropIdV(), checkboxSB->GetValue());	
	}
	catch(char* str){
		std::cout << "Exception : " << str << '\n';
		wxMessageDialog* diag = new wxMessageDialog(this, wxString(str,wxConvUTF8 ), wxString(str,wxConvUTF8 ), wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
}

/**
** Method called when SurfaceRendering C checkbox status changes: Either shows or hides SurfaceRendering C image
**/
void wxMaracasRenderTabbedPanel::onCheckBoxSCChange(wxCommandEvent& event)
{	
	try{
		surrendmanager3->addRemoveActor(this->getPropIdV(), checkboxSC->GetValue());	
	}
	catch(char* str){
		std::cout << "Exception : " << str << '\n';
		wxMessageDialog* diag = new wxMessageDialog(this, wxString(str,wxConvUTF8 ), wxString(str,wxConvUTF8 ), wxICON_ERROR);
		diag->ShowModal();
		delete diag;
	}
}

/**
**
**/
void wxMaracasRenderTabbedPanel::onOpenParameters(wxCommandEvent& event){	
	if(dialog == NULL){
		dialog = new wxMaracasRenderImageManagementPanel(this, volmanager, surrendmanager1, surrendmanager2, surrendmanager3, this->getPropIdV());
		dialog->SetSize(400, 580);
	}
	dialog->Show();
}


/**
** Gets volume rendering image asociated to the given ID
**/
void wxMaracasRenderTabbedPanel::onColorChange(wxCommandEvent& event)
{	
	/*Temporarily disabled*/

	//if(mwxwidget->ShowModal()==wxID_OK){
        //updateVolume();
	//	mwxwidget->Show(false);
	//}	
}

/**
** 
**/
vtkImageData* wxMaracasRenderTabbedPanel::getVolImage()
{	
	return volmanager->getImageData();
}

/**
** Gets surface rendering A image asociated to the given ID
**/
vtkImageData* wxMaracasRenderTabbedPanel::getSurfAImage()
{	
	return surrendmanager1->getImageData();
}

/**
** Gets surface rendering B image asociated to the given ID
**/
vtkImageData* wxMaracasRenderTabbedPanel::getSurfBImage()
{	
	return surrendmanager2->getImageData();
}

/**
** Gets surface rendering C image asociated to the given ID
**/
vtkImageData* wxMaracasRenderTabbedPanel::getSurfCImage()
{	
	return surrendmanager3->getImageData();
}

/**
**
**/
void wxMaracasRenderTabbedPanel::onOpenCutter(wxCommandEvent& event)
{	
	
}

/**
**
**/
int wxMaracasRenderTabbedPanel::getPropIdV()
{
	return _id;
}