#include <vtkActor.h>
#include <vtkMultiBlockPLOT3DReader.h>
#include <vtkMultiBlockDataSet.h>
#include <vtkDataSetMapper.h>
#include <vtkDataSet.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkDataSetReader.h>
#include <vtkInteractorStyleTrackballCamera.h>
#include <vtkImplicitPlaneWidget.h>
#include <vtkXMLUnstructuredGridReader.h>
#include <vtkCutter.h>
#include <vtkPlane.h>
#include <vtkWarpScalar.h>
#include <vtkPlaneWidget.h>
#include <vtkWarpVector.h>
#include <vtkDataObject.h>
#include <vtkPointData.h>
#include <vtkDataArray.h>
#include <vtkDataSetAttributes.h>

#include <vtkStructuredPoints.h>
#include <vtkStructuredPointsReader.h>
#include <vtkSmartPointer.h>

#include <vtkPolyData.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>

#include <vtkGlyph3D.h>

#include <vtkSphere.h>
#include <vtkTransform.h>
#include <vtkSphereSource.h>
#include <vtkSphereWidget.h>
#include <vtkSphereRepresentation.h>
#include <vtkCommand.h>

#include <vtkConeSource.h>
#include <vtkArrowSource.h>

/*class vtkPlaneCallback : public vtkCommand
{
public:
	static vtkPlaneCallback *New()
	{
		return new vtkPlaneCallback;
	}

	virtual void Execute(vtkObject* caller, unsigned long, void*)
	{
		vtkImplicitPlaneWidget *planeWidget =
			reinterpret_cast<vtkImplicitPlaneWidget*>(caller);
		vtkPlane*plane = vtkPlane::New();
		planeWidget->GetPlane(plane);
		cutter->SetCutFunction(plane);
		plane->Delete();
	}
	vtkPlaneCallback() {}
public:
	vtkCutter * cutter;
};*/

class vtkSphereCallback : public vtkCommand
{
public:
	static vtkSphereCallback *New()
	{
		return new vtkSphereCallback;
	}
	virtual void Execute(vtkObject *caller, unsigned long, void*)
	{
		vtkSphereWidget *sphereWidget =
			reinterpret_cast<vtkSphereWidget*>(caller);
		vtkSphere*sphere = vtkSphere::New();

		double center[3];
		//sphereWidget->GetCenter(center);
		sphereWidget->GetSphere(sphere);
		cutter->SetCutFunction(sphere);
		std::cout << "Center: " << center[0] << " " << center[1] << " " << center[2] << std::endl;
		sphere->Delete();
	}
	vtkSphereCallback() {}
public:
	vtkCutter * cutter;
};

int main(int argc, char *argv[])
{
	/*vtkMultiBlockPLOT3DReader *pl3d = vtkMultiBlockPLOT3DReader::New();
	pl3d->SetXYZFileName("D:/Tomas/Studijos/VIzualizavimo Sistemos/Paskaita4/Combuster/combxyz.bin");
	pl3d->SetQFileName("D:/Tomas/Studijos/VIzualizavimo Sistemos/Paskaita4/Combuster/combq.bin");
	pl3d->SetScalarFunctionNumber(110);
	pl3d->Update();*/

		//nuskaitymas
		vtkSmartPointer<vtkStructuredPointsReader> reader = vtkSmartPointer<vtkStructuredPointsReader>::New();
		reader->SetFileName("D:/Tomas/Studijos/VIzualizavimo Sistemos/VTK_PROJEKTAS/VisualStudioProject/Models/carotid.vtk");
		reader->Update();

		vtkSmartPointer<vtkDataSetMapper> carotidMapper = vtkSmartPointer<vtkDataSetMapper>::New();
		carotidMapper->SetInputConnection(reader->GetOutputPort());
		//Create carotid actor
		vtkSmartPointer<vtkActor> carotidActor = vtkSmartPointer<vtkActor>::New();
		carotidActor->GetProperty()->SetOpacity(0.5);
		carotidActor->SetMapper(carotidMapper);


	/*vtkDataSetMapper *mapper = vtkDataSetMapper::New();
	mapper->SetInputData(vtkDataSet::SafeDownCast(pl3d->GetOutput()->GetBlock(0)));
	vtkActor *actor = vtkActor::New();
	actor->SetMapper(mapper);*/
	vtkRenderer *renderer = vtkRenderer::New();
	vtkRenderWindow *renderWindow = vtkRenderWindow::New();
	renderWindow->AddRenderer(renderer);
	vtkRenderWindowInteractor *interactor = vtkRenderWindowInteractor::New();
	interactor->SetRenderWindow(renderWindow);
	vtkInteractorStyleTrackballCamera *style = vtkInteractorStyleTrackballCamera::New();
	interactor->SetInteractorStyle(style);

	/*vtkSmartPointer<vtkImplicitPlaneWidget> planeWidget = vtkSmartPointer<vtkImplicitPlaneWidget>::New();
	planeWidget->SetInteractor(interactor);
	planeWidget->SetProp3D(carotidActor);
	planeWidget->OutlineTranslationOff();
	planeWidget->SetPlaceFactor(1.0);
	planeWidget->PlaceWidget();
	planeWidget->SetNormal(0, 0, 1); // normal of your target plane
	planeWidget->SetOrigin(8, 0, 29); // origin of your target plane
	planeWidget->UpdatePlacement();*/

	vtkSmartPointer<vtkSphereWidget> sphereWidget =
		vtkSmartPointer<vtkSphereWidget>::New();
	sphereWidget->SetInteractor(interactor);
	sphereWidget->SetRepresentationToSurface();

	vtkSmartPointer<vtkCutter> cutter = vtkSmartPointer<vtkCutter>::New();
	cutter->SetInputData(vtkDataSet::SafeDownCast(reader->GetOutput()));
	vtkDataSet::SafeDownCast(reader->GetOutput())->Print(std::cout);
	vtkPlane *plane = vtkPlane::New();
	vtkSphere *sphere = vtkSphere::New();
	//planeWidget->GetPlane(plane);
	sphereWidget->GetSphere(sphere);
	cutter->SetCutFunction(plane);

	vtkDataSetMapper *cuttermapper = vtkDataSetMapper::New();
	cuttermapper->SetInputConnection(cutter->GetOutputPort());


	vtkActor *cutteractor = vtkActor::New();
	cutteractor->SetMapper(cuttermapper);


	//vtkSmartPointer<vtkPlaneCallback> planeCallback = vtkSmartPointer<vtkPlaneCallback>::New();
	//planeWidget->AddObserver(vtkCommand::EndInteractionEvent, planeCallback);
	//planeCallback->cutter = cutter;

	vtkSmartPointer<vtkSphereCallback> sphereCallback = vtkSmartPointer<vtkSphereCallback>::New();
	sphereWidget->AddObserver(vtkCommand::EndInteractionEvent, sphereCallback);
	sphereCallback->cutter = cutter;

	vtkConeSource *cone = vtkConeSource::New();
	cone->SetResolution(12);

	vtkGlyph3D *glyph = vtkGlyph3D::New();
	glyph->SetInputConnection(cutter->GetOutputPort());
	glyph->SetSourceConnection(cone->GetOutputPort());
	glyph->SetVectorModeToUseNormal();
	glyph->SetScaleModeToScaleByVector();
	glyph->SetScaleFactor(0.25);

	vtkPolyDataMapper *spikeMapper = vtkPolyDataMapper::New();
	spikeMapper->SetInputConnection(glyph->GetOutputPort());

	vtkActor *spikeActor = vtkActor::New();
	spikeActor->SetMapper(spikeMapper);

	//planeWidget->On();
	sphereWidget->SetCenter(130, 110, 25);
	sphereWidget->SetRadius(10.0);
	sphereWidget->On();

	//renderer->AddActor(actor);

	renderer->AddActor(cutteractor);
	renderer->AddActor(spikeActor);

	renderer->AddActor(cutteractor);
	renderWindow->SetSize(900, 900);
	interactor->Initialize();
	interactor->Start();
	return EXIT_SUCCESS;
}