#include "itkImageRegionConstIterator.h"
#include "itkImageRegionIterator.h"
#include "itkImageToImageFilter.h"
#include "itkMetaDataDictionary.h"
#include "itkMetaDataObject.h"
#include <iostream>

template <typename TInputImage, typename TOutputImage>
class TestFilter : public itk::ImageToImageFilter<TInputImage, TOutputImage>
{
public:
    using Self = TestFilter;
    using Superclass = itk::ImageToImageFilter<TInputImage, TOutputImage>;
    using Pointer = itk::SmartPointer<Self>;
    using ConstPointer = itk::SmartPointer<const Self>;
    using ConstWeakPointer = itk::WeakPointer<const Self>;
    using InputImageType = TInputImage;
    using OutputImageType = TOutputImage;
    using InputPixelType = typename TInputImage::PixelType;
    using OutputPixelType = typename TOutputImage::PixelType;
    using OutputImagePointer = typename TOutputImage::Pointer;
    using InputImagePointer = typename TInputImage::Pointer;
    using InputImageConstPointer = typename InputImageType::ConstPointer;
    using InputIterator = itk::ImageRegionConstIterator<TInputImage>;
    using OutputIterator = itk::ImageRegionIterator<TOutputImage>;

    itkTypeMacro(NothingFilter, itk::ImageToImageFilter);
    itkNewMacro(Self);

    void SetAddend(const InputPixelType& addend)
    {
        m_Addend = addend;
    }

protected:
    void GenerateData()
    {
        try
        {
            std::cout << "Test Filter Adding " << m_Addend << "...";

            InputImageConstPointer  inputPtr  = this->GetInput(0);
            OutputImagePointer      outputPtr = this->GetOutput(0);

            outputPtr->SetBufferedRegion(outputPtr->GetLargestPossibleRegion());
            outputPtr->Allocate();

            InputIterator  inputItr  = InputIterator (inputPtr,  inputPtr->GetRequestedRegion());
            OutputIterator outputItr = OutputIterator(outputPtr, outputPtr->GetRequestedRegion());

            for (inputItr.GoToBegin(), outputItr.GoToBegin(); !outputItr.IsAtEnd(); ++outputItr, ++inputItr)
            {
                outputItr.Set(inputItr.Get() + m_Addend);
            }

            auto inputDict  = inputPtr->GetMetaDataDictionary();
            auto outputDict = outputPtr->GetMetaDataDictionary();

            std::cout << "\nInput Dictionary:  "; inputDict.Print(std::cout);
            itk::EncapsulateMetaData<float>(outputDict, "Float",  float(1.0));
            std::cout << "\nOutput Dictionary: "; outputDict.Print(std::cout);
            
            std::cout << "Done." << std::endl;
        }
        catch (std::exception& err)
        {
            std::string errMsg = "Error";
            throw;
        }
    }
private:
    InputPixelType m_Addend;
};


int main(int argc, char* argv[])
{
    try
    {
        using ImageType    = itk::Image<float, 3>;
        using IteratorType = itk::ImageRegionIterator<ImageType>;   
        using DictType     = itk::MetaDataDictionary;
        using FilterType   = TestFilter<ImageType, ImageType>;

        auto image   = ImageType::New();
        auto filter1 = FilterType::New();
        auto filter2 = FilterType::New();
        itk::Size<3>         size{ {2, 2, 2} };
        itk::Index<3U>       start{ {0, 0, 0} };
        itk::ImageRegion<3U> region(start, size);
        double origin [3] = { 0.0, 0.0, 0.0 };
        double spacing[3] = { 1.0, 1.0, 1.0 };
        image->SetOrigin(origin);
        image->SetSpacing(spacing);
        image->SetLargestPossibleRegion(region);
        image->SetBufferedRegion(image->GetLargestPossibleRegion());
        image->Allocate();
        image->FillBuffer(itk::NumericTraits<float>::Zero);

        filter1->SetInput(image); //importFilter->GetOutput());
        filter1->SetAddend(1);
        filter2->SetInput(filter1->GetOutput());
        filter2->SetAddend(2);
        filter2->Update();

        auto imageOut = filter2->GetOutput();

        IteratorType  itr  = IteratorType(imageOut,  imageOut->GetLargestPossibleRegion());
        for (itr.GoToBegin(); !itr.IsAtEnd(); ++itr)
        {
            std::cout << itr.Get() << ", ";
        }    
        std::cout << std::endl;
        

    }
    catch (std::exception& err)
    {
        std::cerr << err.what() << std::endl;
    }

    return 0;

}