#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 <vtkMapper.h>
#include <vtkSphereRepresentation.h>
#include <vtkImageSliceMapper.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;
vtkSmartPointer<cpExtensions::Interaction::SphereWidget> sphereWidget;


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

  int axis = image_actors->GetAxis();
  vtkImageMapper3D * mapper = image_actors->GetImageActor()->GetMapper();
  vtkAbstractMapper3D* abs = dynamic_cast<vtkAbstractMapper3D*>(mapper);
  auto imgSliceMap = vtkImageSliceMapper::SafeDownCast(abs);
 // auto centerImg = imgSliceMap->GetCenter();  
  
  auto center = image_actors->GetPlaneActor()->GetCenter();

  std::cout << "plane: {" << center[0] << " , " << center[1] << " , " << center[2] << "} " << std::endl;
  //std::cout << "slice: {" << centerImg[0] << " , " << centerImg[1] << " , " << centerImg[2] << "} " << std::endl;

  switch (axis)
  {
  case 0: // X
    center[1] = sphereWidget->GetPosition()[1];
    center[2] = sphereWidget->GetPosition()[2];
    break;                    
  case 1: // Y                
    center[0] = sphereWidget->GetPosition()[0];
    center[2] = sphereWidget->GetPosition()[2];
    break;                    
  case 2: // Z                
    center[1] = sphereWidget->GetPosition()[1];
    center[0] = sphereWidget->GetPosition()[0];
    break;
  default: 
    break;
  }

  sphereWidget->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(0);
  image_actors->PushActorsInto(window);

  vtkSmartPointer< vtkImageActorPointPlacer > placer =
    vtkSmartPointer< vtkImageActorPointPlacer >::New();
  placer->SetImageActor(image_actors->GetImageActor());
 
  // Create a sphere widget
  sphereWidget =
    vtkSmartPointer<TSphereWidget>::New();
  sphereWidget->SetInteractor(interactor);
  sphereWidget->SetAxis(image_actors->GetAxis()); //sinchronize image pane with sphere plane

  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);
}