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

#include <wx/colordlg.h>
#include <OpenImage.xpm>
#include "Color.xpm"


/**
**	
**/
wxMaracasRenderTabbedPanel::wxMaracasRenderTabbedPanel(wxWindow* parent/*, wxMaracasMultipleVolumeRendererManager* _volmanager, wxMaracasSurfaceRenderingManager* _surrendmanager1, wxMaracasSurfaceRenderingManager* _surrendmanager2, 
									  wxMaracasSurfaceRenderingManager* _surrendmanager3, wxString pathfile, wxString filename*/)
: wxPanel(parent, -1, wxDefaultPosition, wxDefaultSize)
{
	//_propid = propid;
	volmanager = new wxMaracasMultipleVolumeRendererManager();
	surrendmanager1 = new wxMaracasSurfaceRenderingManager();
	surrendmanager2 = new wxMaracasSurfaceRenderingManager();
	surrendmanager3 = new wxMaracasSurfaceRenderingManager();

}

/**
**
**/
void wxMaracasRenderTabbedPanel::createControls(wxString pathfile, wxString filename)
{
	//wxPanel* up = new wxPanel(this, wxID_ANY);
	wxFlexGridSizer* sizerrenderprop = new wxFlexGridSizer(1);
	
	//wxString choices[2];
	//choices[0] = wxString(_T("On"));
	//choices[1] = wxString(_T("Off"));
	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);

	//wxString choices[2];
	//choices[0] = wxString(_T("On"));
	//choices[1] = wxString(_T("Off"));
	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);

	//wxString choices[2];
	//choices[0] = wxString(_T("On"));
	//choices[1] = wxString(_T("Off"));
	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);

	//wxString choices[2];
	//choices[0] = wxString(_T("On"));
	//choices[1] = wxString(_T("Off"));
	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);
	sizerrenderprop->Add(sizercheck, wxFIXED_MINSIZE);
	//up->SetSizer(sizerup, true);		
	//up->SetAutoLayout( true );

	wxtabs = new wxNotebook(this, -1);

	std::string s = std::string(pathfile.mb_str());
	vtkImageData* img1 = volmanager->getImageData(s);
	vtkImageData* img2 = surrendmanager1->getImageData(s);
	vtkImageData* img3 = surrendmanager2->getImageData(s);
	vtkImageData* img4 = surrendmanager3->getImageData(s);
	if(img1!=NULL)
	{

		s = std::string(filename.mb_str());
		addVolume(img1, s);
		addSurface1(img2, s);
		addSurface2(img3, s);
		addSurface3(img4, s);	
		wxtabs->Refresh();
	}

	//wxFlexGridSizer* sizerrenderprop = new wxFlexGridSizer(2,1,5);
	//sizerrenderprop->Add(up, wxFIXED_MINSIZE);
	
	sizerrenderprop->Add(wxtabs, wxFIXED_MINSIZE);

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

}

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

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

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

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

void wxMaracasRenderTabbedPanel::addSurface2(vtkImageData* img, std::string dataname)
{
	try
	{
		int _propidSB = surrendmanager2->addPropMHD(img, dataname);
		if(_propidSB!=-1)
		{
			controlpanSB = new wxMaracasSurfaceRenderingProp3DMHD(wxtabs, _propidSB, true, 2);
			int maxiso = surrendmanager2->getMaxIsoValue(_propidSB);
			((wxMaracasSurfaceRenderingProp3DMHD*)controlpanSB)->createControls(maxiso);
			wxtabs->AddPage(controlpanSB, _T("Surf Rendering B"));

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

void wxMaracasRenderTabbedPanel::addSurface3(vtkImageData* img, std::string dataname)
{
	try
	{
		_propidSC = surrendmanager3->addPropMHD(img, dataname);

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

/**
** Deletes complete volume
**/
void wxMaracasRenderTabbedPanel::deleteVolume(int volid)
{
	volmanager->deleteActor(volid);
	surrendmanager1->deleteActor(volid);
	surrendmanager2->deleteActor(volid);
	surrendmanager3->deleteActor(volid);
}

/**
** Adds or removes volume rendering actor with given ID
**/
void wxMaracasRenderTabbedPanel::addRemoveActorV(int id, bool addremove)
{
	volmanager->addRemoveActor(id, addremove);
}

/**
** Adds or removes surface rendering actor with given ID
**/
void wxMaracasRenderTabbedPanel::addRemoveActorSA(int id, bool addremove)
{
	surrendmanager1->addRemoveActor(id, addremove);
}

/**
** Adds or removes surface rendering actor with given ID
**/
void wxMaracasRenderTabbedPanel::addRemoveActorSB(int id, bool addremove)
{
	surrendmanager2->addRemoveActor(id, addremove);
}

/**
** Adds or removes surface rendering actor with given ID
**/
void wxMaracasRenderTabbedPanel::addRemoveActorSC(int id, bool addremove)
{	
	surrendmanager3->addRemoveActor(id, addremove);
}	

/**
** 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)
{
	volmanager->setVolumeOpacity(volid, greylevel, values);
}

/**
** 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;
	}
}

/**
** 
**/
void wxMaracasRenderTabbedPanel::onUpdate(wxCommandEvent& event)
{
	updateVolume();    
}

/**
** 
**/
void wxMaracasRenderTabbedPanel::updateVolume()
{
	/*Temporarily disabled*/

	std::vector<double> greylevelcolors;
	std::vector<double> red;
	std::vector<double> green;
	std::vector<double> blue;

	std::vector<double> greylevel;
	std::vector<double> values;

    HistogramDialogComboBox* histo = controlpanV->getMwxwidget();
	histo->GetValuesColorPointsFunction(greylevelcolors, red, green, blue);
	histo->GetValuesPointsFunction(greylevel, values);


	volmanager->setVolumeColor(controlpanV->getPropId(), greylevelcolors, red, green, blue);
	volmanager->setVolumeOpacity(controlpanV->getPropId(), greylevel, values);
	//wxMaracasMultipleVolumeRendererView::getInstance()->SetValuesColorPointsFunction(this->_propid, greylevelcolors, red, green, blue);
	//wxMaracasMultipleVolumeRendererView::getInstance()->SetValuesPointsFunction(this->_propid, greylevel, values);

}

/**
**
**/
void wxMaracasRenderTabbedPanel::onColorChange(wxCommandEvent& event)
{	
	/*Temporarily disabled*/

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

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

/**
** Method called when VolumeRendering checkbox status changes: Either shows or hides VolumeRendering image
**/
void wxMaracasRenderTabbedPanel::onCheckBoxVChange(wxCommandEvent& event)
{
	volmanager->addRemoveActor(this->getPropIdV(), checkboxVol->GetValue());	
}

/**
** Method called when SurfaceRendering A checkbox status changes: Either shows or hides SurfaceRendering image
**/
void wxMaracasRenderTabbedPanel::onCheckBoxSAChange(wxCommandEvent& event)
{	
	surrendmanager1->addRemoveActor(this->getPropIdSA(), checkboxSA->GetValue());	
}

/**
** Method called when SurfaceRendering B checkbox status changes: Either shows or hides SurfaceRendering B image
**/
void wxMaracasRenderTabbedPanel::onCheckBoxSBChange(wxCommandEvent& event)
{	
	surrendmanager2->addRemoveActor(this->getPropIdSB(), checkboxSB->GetValue());	
}

/**
** Method called when SurfaceRendering C checkbox status changes: Either shows or hides SurfaceRendering C image
**/
void wxMaracasRenderTabbedPanel::onCheckBoxSCChange(wxCommandEvent& event)
{	
	surrendmanager3->addRemoveActor(this->getPropIdSC(), checkboxSC->GetValue());	
}

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

/**
**
**/
int wxMaracasRenderTabbedPanel::getPropIdSA()
{
	return _propidSA;
}

/**
**
**/
int wxMaracasRenderTabbedPanel::getPropIdSB()
{
	return _propidSB;
}

/**
**
**/
int wxMaracasRenderTabbedPanel::getPropIdSC()
{
	return _propidSC;
}