#include <future>
#include <iostream>
#include <cpExtensions/IO/MementoState.h>

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

#include <vtkImageCast.h>
#include <vtkMetaImageWriter.h>
#include <vtkMetaImageReader.h>
#include <vtkImageMandelbrotSource.h>
#include <vtkImageActor.h>
#include <vtkRenderWindowInteractor.h>

#include <itkImage.h>
#include <itkBinaryErodeImageFilter.h>
#include <itkBinaryBallStructuringElement.h>
#include <itkImageFileReader.h>

#include <itkImageToVTKImageFilter.h>
#include <itkVTKImageToImageFilter.h>
#include <itkBinaryThresholdImageFilter.h>
#include <itkInvertIntensityImageFilter.h>

typedef itk::Image<unsigned char, 2>    ImageType;
typedef itk::ImageFileReader<ImageType> ReaderType;

typedef cpPlugins::Interface::Image            TPluginImage;

int main() {
  auto memento = cpExtensions::IO::MementoState();
  
  //here goes the code
  
  
  std::string filePath = "julia_mha.mhd";
  std::string filePathRaw = "julia_mha.raw";
  // Create an image
  vtkSmartPointer<vtkImageMandelbrotSource> source =
    vtkSmartPointer<vtkImageMandelbrotSource>::New();

  vtkSmartPointer<vtkImageCast> castFilter =
    vtkSmartPointer<vtkImageCast>::New();
  castFilter->SetOutputScalarTypeToUnsignedChar();
  castFilter->SetInputConnection(source->GetOutputPort());
  castFilter->Update();

  vtkSmartPointer<vtkMetaImageWriter> writer =
    vtkSmartPointer<vtkMetaImageWriter>::New();
  writer->SetInputConnection(castFilter->GetOutputPort());
  writer->SetFileName(filePath.c_str());
  writer->SetRAWFileName(filePathRaw.c_str());
  writer->Write();

  //ReaderType::Pointer reader = ReaderType::New();
  vtkSmartPointer<vtkMetaImageReader> reader =
    vtkSmartPointer<vtkMetaImageReader>::New();
  reader->SetFileName(filePath.c_str());
  reader->Update();
  
  //first memento
 /* auto obj = TPluginImage::New();

  auto oo = dynamic_cast<cpPlugins::Interface::Image *> (reader->GetOutput());
  obj->SetSource(oo);
  memento.SetToMemento(oo);*/

  // filter 1 (state 2) ---------------------------------------------------------------
  
  typedef itk::BinaryBallStructuringElement<
    ImageType::PixelType, 2>                  StructuringElementType;
  StructuringElementType structuringElement;
  structuringElement.SetRadius(10);
  structuringElement.CreateStructuringElement();

  typedef itk::VTKImageToImageFilter<ImageType>       imgToFilter;
  imgToFilter::Pointer connectorimg = imgToFilter::New();
  connectorimg->SetInput(reader->GetOutput());
  connectorimg->Update();

  typedef itk::BinaryErodeImageFilter<ImageType, ImageType, StructuringElementType>
    BinaryErodeImageFilterType;
  
  BinaryErodeImageFilterType::Pointer erodeFilter
    = BinaryErodeImageFilterType::New();
  erodeFilter->SetInput(connectorimg->GetOutput());
  erodeFilter->SetKernel(structuringElement);

  // filter 2 (state 3) ---------------------------------------------------------------

  typedef itk::BinaryThresholdImageFilter<ImageType, ImageType>
    BinaryThresholdImageFilterType;

  BinaryThresholdImageFilterType::Pointer thresholdFilter
    = BinaryThresholdImageFilterType::New();
  thresholdFilter->SetInput(erodeFilter->GetOutput());
  thresholdFilter->SetLowerThreshold(10);
  thresholdFilter->SetUpperThreshold(30);
  thresholdFilter->SetInsideValue(255);
  thresholdFilter->SetOutsideValue(0);


  // filter 3 (state 4) ---------------------------------------------------------------

  typedef itk::InvertIntensityImageFilter <ImageType>
    InvertIntensityImageFilterType;

  InvertIntensityImageFilterType::Pointer invertIntensityFilter
    = InvertIntensityImageFilterType::New();
  invertIntensityFilter->SetInput(thresholdFilter->GetOutput());
  invertIntensityFilter->SetMaximum(255);

  // undo (state 3) ---------------------------------------------------------------

  // undo (state 2) ---------------------------------------------------------------

  // redo (state 3) ---------------------------------------------------------------

  // visualization -- just for test

  typedef itk::ImageToVTKImageFilter<ImageType>       ConnectorType;
  ConnectorType::Pointer connector = ConnectorType::New();
  connector->SetInput(invertIntensityFilter->GetOutput());
  connector->Update();

  vtkSmartPointer<vtkImageActor> actor =
    vtkSmartPointer<vtkImageActor>::New();
  actor->GetMapper()->SetInputData(connector->GetOutput());

  vtkSmartPointer<vtkRenderer> renderer =
    vtkSmartPointer<vtkRenderer>::New();
  vtkSmartPointer<vtkRenderWindow> renderWindow =
    vtkSmartPointer<vtkRenderWindow>::New();
  renderWindow->AddRenderer(renderer);
  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
    vtkSmartPointer<vtkRenderWindowInteractor>::New();
  renderWindowInteractor->SetRenderWindow(renderWindow);

  renderer->AddActor(actor);
  renderer->SetBackground(.2, .3, .4);

  renderWindow->Render();
  renderWindowInteractor->Start();



//#ifdef _DEBUG
//  auto i = 0;
//  std::cout << "wait for close";
//  std::cin >> i;
//#endif

  return 0;

}