#include <cpPlugins/Interface/Interface.h>
#include <cpPlugins/Interface/ProcessObject.h>
#include <cpPlugins/Interface/Image.h>

#include <cpExtensions/Visualization/ImageSliceActors.h>
#include <cpExtensions/Interaction/SphereWidget.h>

#include <vtkImageActorPointPlacer.h>
#include <vtkPointHandleRepresentation3D.h>
#include <vtkProperty.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkSphere.h>
#include <vtkSphereRepresentation.h>
#include <vtkSphereWidget2.h>
#include <vtkCommand.h>
#include <vtkCallbackCommand.h>

// -------------------------------------------------------------------------
// type definiftions

typedef cpPlugins::Interface::Interface     TInterface;
typedef cpPlugins::Interface::ProcessObject TProcessObject;
typedef cpPlugins::Interface::DataObject    TDataObject;
typedef cpPlugins::Interface::Image         TImage;
typedef cpPlugins::Interface::Parameters    TParameters;
typedef TInterface::TClasses                TClasses;

typedef cpExtensions::Visualization::ImageSliceActors TSliceActors;
typedef cpExtensions::Interaction::SphereWidget       TSphereWidget;

// -------------------------------------------------------------------------

std::string _pathIOplugin = "C://dev//creatis//cpPlugins//build//Debug//cpPluginsIO.dll";
std::string _img = "C://img//SphereVolume.mhd";

vtkSmartPointer<cpExtensions::Visualization::ImageSliceActors> image_actors;

void WheelCallbackFunction(vtkObject* caller, long unsigned int eventId, void* clientData, void* vtkNotUsed(callData))
{
  std::cout << "WheelCallbackFunction callback" << std::endl;

  vtkSmartPointer<TSphereWidget> sphere =
    reinterpret_cast<TSphereWidget*>(clientData);

 // double * center = image_actors->GetImageActor()->GetCenter();
  double * center = image_actors->GetPlaneActor()->GetCenter();
  auto slice = image_actors->GetSliceNumber();
  std::cout << "plane: [" << center[0] << " , " << center[1] + slice << " , " << (center[2] + 19)*(-1) << "] " << std::endl;
  std::cout << "slice #. " << slice <<std::endl;

  sphere->SetCenter(center);
  
}



int main(int argc, char* argv[])
{
  if (argc >= 3)
  {
    _pathIOplugin = argv[1];
    _img = argv[2];
  }

  // Create interface
  TInterface plugins;
  if (!plugins.Load(_pathIOplugin))
  {
    std::cerr << "Failed to load plugins." << std::endl;
    return(1);
  }

  // Create reader
  TProcessObject::Pointer reader;
  reader = plugins.CreateObject("cpPlugins::IO::ImageReader");
  if (reader.IsNull())
  {
    std::cerr
      << "No suitable reader found in plugins." << std::endl
      << "Reader: " << reader.GetPointer() << std::endl
      << std::endl;
    return(1);
  } 

  // Configure reader
  TParameters* reader_params = reader->GetParameters();
  reader_params->AddToStringList("FileNames", _img);

  // Execute pipeline
  std::string err = reader->Update();
  if (err != "")
  {
    std::cerr << "ERROR: " << err << std::endl;
    return(1);

  } 

  TImage* image = reader->GetOutput< TImage >("Output");

  // Configure visualization objects
  vtkSmartPointer< vtkRenderer > renderer =
    vtkSmartPointer< vtkRenderer >::New();
  renderer->SetBackground(0.1, 0.1, 0.1);

  vtkSmartPointer< vtkRenderWindow > window =
    vtkSmartPointer< vtkRenderWindow >::New();
  window->AddRenderer(renderer);
  window->SetSize(600, 600);

  // Set up the interaction
  vtkSmartPointer< vtkRenderWindowInteractor > interactor =
    vtkSmartPointer< vtkRenderWindowInteractor >::New();
  window->SetInteractor(interactor);

  // Create slice actors
  image_actors = vtkSmartPointer< TSliceActors >::New();
  image_actors->SetInputImage(image->GetVTK< vtkImageData >());
  image_actors->SetAxis(2);
  image_actors->PushActorsInto(window);

  vtkSmartPointer< vtkImageActorPointPlacer > placer =
    vtkSmartPointer< vtkImageActorPointPlacer >::New();
  placer->SetImageActor(image_actors->GetImageActor());
 
  // Create a sphere widget
  vtkSmartPointer<TSphereWidget> sphereWidget =
    vtkSmartPointer<TSphereWidget>::New();
  sphereWidget->SetInteractor(interactor);

  vtkSmartPointer<vtkCallbackCommand> myCallBack =
    vtkSmartPointer<vtkCallbackCommand>::New();
  myCallBack->SetCallback(WheelCallbackFunction);
  myCallBack->SetClientData(sphereWidget);
  
 
  interactor->AddObserver(vtkCommand::MouseWheelForwardEvent, myCallBack);
  interactor->AddObserver(vtkCommand::MouseWheelBackwardEvent, myCallBack);

  // Begin interaction
  renderer->ResetCamera(); 
  window->Render();
  sphereWidget->On();
  interactor->Start();

  return(0);
}