#include <future>
#include <iostream>
#include <cpExtensions/IO/MementoState.h>
#include <cpPlugins/Plugins/BasicFilters/BinaryErodeImageFilter.h>

#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>

#include <itkImageToVTKImageFilter.h>

#ifdef WIN32
#define myWait Sleep(10000);
#else
#define myWait usleep(10000);
#endif


// -------------------------------------------------------------------------
// 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::IO::MementoState TMemento;
typedef cpPlugins::BasicFilters::BinaryErodeImageFilter TBinaryErodeFilter;
// -------------------------------------------------------------------------

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

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

  // Create interface
   TInterface plugins;
  if (!plugins.Load(_pathIOplugin) ||
      !plugins.Load(_pathBasicFiltersPlugin))
  {
    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");

  //first memento
  TMemento* _memento = new TMemento();
  _memento->SetToMemento(image);
  
 /* auto retrievedImage = _memento->GetFromMemento(1);
  image->SetVTK(retrievedImage);
*/
  // filter 1 (state 2) ---------------------------------------------------------------

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

  // filter 1
  TDataObject * readerOut = reader->GetOutput< TDataObject >("Output");
  binaryFilter->SetInput("Input", readerOut);
  binaryFilter->Update();
  _memento->SetToMemento(binaryFilter->GetOutput< TImage >("Output"));

  myWait;

  vtkSmartPointer<vtkImageData> retrievedImage = _memento->MementoUndo();
  
  // the retrieved image could not be ready if this happens the function returns null
  // for the test we made the example wait before try to read but this is the way 
  // to handle this
  if (retrievedImage == nullptr)
  {
    return (1);
  }
  
  //image->SetVTK(retrievedImage.Get()); // this metohd is not implemented yet

  // 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
  vtkSmartPointer< TSliceActors > image_actors =
    vtkSmartPointer< TSliceActors >::New();
  //image_actors->SetInputImage(image->GetVTK< vtkImageData >(), 2);
  image_actors->SetInputImage(retrievedImage);
  image_actors->SetAxis(2);
  image_actors->PushActorsInto(window);

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

  return 0;

}