#include <QVTKOpenGLNativeWidget.h>
#include <vtkActor.h>
#include <vtkDataSetMapper.h>
#include <vtkDoubleArray.h>
#include <vtkGenericOpenGLRenderWindow.h>
#include <vtkPointData.h>
#include <vtkProperty.h>
#include <vtkRenderer.h>
#include <vtkSphereSource.h>
#include <vtkVolume.h>
#include <vtkVolumeProperty.h>
#include <vtkSmartVolumeMapper.h>
#include <vtkOpenGLGPUVolumeRayCastMapper.h>
#include <vtkImageReslice.h>
#include <vtkImageMapper3D.h>
#include <vtkImageActor.h>
#include <vtkLookupTable.h>
#include <vtkImageMapToColors.h>
#include <vtkTransform.h>
#include <vtkChartXY.h>
#include <vtkContextScene.h>
#include <vtkContextView.h>
#include <vtkFloatArray.h>
#include <vtkIntArray.h>
#include <vtkPlot.h>
#include <vtkTable.h>
#include <vtkColorSeries.h>
#include <vtkAxis.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkChartHistogram2D.h>
#include <vtkContextScene.h>
#include <vtkContextView.h>
#include <vtkIntArray.h>
#include <vtkPlot.h>
#include <vtkTable.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkPolyData.h>
#include <vtkSTLReader.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkProperty.h>

#include <QApplication>
#include <QDockWidget>
#include <QGridLayout>
#include <QLabel>
#include <QMainWindow>
#include <QPointer>
#include <QPushButton>
#include <QVBoxLayout>
#include <QDebug>
#include <QSlider>
#include <QRadioButton>
#include <QDialog>
#include <QtCharts/QChartView>
#include <QtCharts/QBarSeries>
#include <QtCharts/QBarSet>
#include <QtCharts/QBarCategoryAxis>
#include <QtCharts/QValueAxis>

#include <cmath>
#include <cstdlib>
#include <random>

#include <iostream>
#include <fstream>
#include <sstream>

#include <vtkImageData.h>
#include <vtkSmartPointer.h>
#include <vtkActor.h>
#include <vtkRenderer.h>
#include <vtkNamedColors.h>
#include <vtkColorTransferFunction.h>
#include <vtkPiecewiseFunction.h>
#include <vtkImageHistogram.h>
#include <vtkImageAccumulate.h>
#include <vtkImageBlend.h>

using namespace std;


int main(int argc, char* argv[])
{
    QSurfaceFormat::setDefaultFormat(QVTKOpenGLNativeWidget::defaultFormat());
    QApplication app(argc, argv);

    QMainWindow mainWindow;
    mainWindow.resize(1200, 900);

    QGridLayout* gridLayout = new QGridLayout();
    QWidget* centralWidget = new QWidget(&mainWindow);
    centralWidget->setLayout(gridLayout);
    mainWindow.setCentralWidget(centralWidget);

    QDockWidget controlDock;
    mainWindow.addDockWidget(Qt::LeftDockWidgetArea, &controlDock);

    QLabel controlDockTitle("");
    controlDock.setTitleBarWidget(&controlDockTitle);

    QPointer<QVBoxLayout> dockLayout = new QVBoxLayout();
    QWidget layoutContainer;
    layoutContainer.setLayout(dockLayout);
    controlDock.setWidget(&layoutContainer);

    QPointer<QVTKOpenGLNativeWidget> ctRenderWidget = new QVTKOpenGLNativeWidget();
    QPointer<QVTKOpenGLNativeWidget> mrRenderWidget = new QVTKOpenGLNativeWidget();
    QPointer<QVTKOpenGLNativeWidget> ctMrRenderWidget = new QVTKOpenGLNativeWidget();

    vtkNew<vtkGenericOpenGLRenderWindow> ctRenderWindow;
    vtkNew<vtkGenericOpenGLRenderWindow> mrRenderWindow;
    vtkNew<vtkGenericOpenGLRenderWindow> ctMrRenderWindow;
    ctRenderWidget->setRenderWindow(ctRenderWindow.Get());
    mrRenderWidget->setRenderWindow(mrRenderWindow.Get());
    ctMrRenderWidget->setRenderWindow(ctMrRenderWindow.Get());

    vtkNew<vtkGenericOpenGLRenderWindow> histogramRenderWindow;
    QVTKOpenGLNativeWidget* histogramRenderWidget = new QVTKOpenGLNativeWidget();
    histogramRenderWidget->setRenderWindow(histogramRenderWindow.Get());

    vtkNew<vtkGenericOpenGLRenderWindow> MRhistogramRenderWindow;
    QVTKOpenGLNativeWidget* MRhistogramRenderWidget = new QVTKOpenGLNativeWidget();
    MRhistogramRenderWidget->setRenderWindow(MRhistogramRenderWindow.Get());

    QSlider slider(Qt::Vertical);
    dockLayout->addWidget(&slider);

    slider.setMinimum(0);
    slider.setMaximum(141);
    slider.setValue(0);


    // File headers
    string CTinput = "D:/adobiiii/mr-ct/CT.rdata"; ///////////////change later
    string MRinput = "D:/adobiiii/mr-ct/MR.rdata"; ///////////////change later
    ifstream MRstream(MRinput + ".header");
    ifstream CTstream(CTinput + ".header");
    string line;

    std::ifstream MRfin(MRinput, ios::in | ios::binary | ios::ate);
    std::ifstream CTfin(CTinput, ios::in | ios::binary | ios::ate);

    //size CT
    int CTsize = CTfin.tellg();
    cout << CTsize;
    CTfin.seekg(0, ios::beg);

    char *CTbuffer = new char[CTsize];
    CTfin.read(CTbuffer, CTsize);
    CTfin.close();

    //size MR
    int MRsize = MRfin.tellg();
    cout << MRsize;
    MRfin.seekg(0, ios::beg);

    char *MRbuffer = new char[MRsize];
    MRfin.read(MRbuffer, MRsize);
    MRfin.close();


    //Setup allocator for input file MR
    vtkSmartPointer<vtkImageData> MRimageData = vtkSmartPointer<vtkImageData>::New();
    MRimageData->SetDimensions(512, 512, 192);
    MRimageData->SetSpacing(0.351562, 0.351562, 0.7);
    MRimageData->SetOrigin(0, 0, 0);
    MRimageData->AllocateScalars(VTK_UNSIGNED_SHORT, 1);

    //Setup allocator for input file CT
    vtkSmartPointer<vtkImageData> CTimageData = vtkSmartPointer<vtkImageData>::New();
    CTimageData->SetDimensions(512, 512, 247);
    CTimageData->SetSpacing(0.447266, 0.447266, 0.625);
    CTimageData->SetOrigin(0, 0, 0);
    CTimageData->AllocateScalars(VTK_UNSIGNED_SHORT, 1);

    //Copy image data MR
    unsigned char* MRimageDataPointer = static_cast<unsigned char*>(MRimageData->GetScalarPointer());
    std::memcpy(MRimageDataPointer, MRbuffer, MRsize);
    //Copy image data CT
    unsigned char* CTimageDataPointer = static_cast<unsigned char*>(CTimageData->GetScalarPointer());
    std::memcpy(CTimageDataPointer, CTbuffer, CTsize);

    //Mapping data MR
    vtkNew<vtkOpenGLGPUVolumeRayCastMapper> MRvolumeMapper;
    MRvolumeMapper->SetInputData(MRimageData);

    //Mapping data CT
    vtkNew<vtkOpenGLGPUVolumeRayCastMapper> CTvolumeMapper;
    CTvolumeMapper->SetInputData(CTimageData);

    //Volumes properties MR
    vtkNew<vtkVolumeProperty> MRvolumeProperty;
    MRvolumeProperty->SetInterpolationTypeToLinear();

    vtkNew<vtkVolume> MRvolume;
    MRvolume->SetMapper(MRvolumeMapper);
    MRvolume->SetProperty(MRvolumeProperty);

    vtkNew<vtkImageReslice> MRreslice;
    MRreslice->SetInputData(MRimageData);
    MRreslice->SetOutputDimensionality(2);
    MRreslice->SetResliceAxesDirectionCosines(1, 0, 0, 0, 1, 0, 0, 0, 1);
    MRreslice->SetInterpolationModeToLinear();

    MRreslice->SetResliceAxesOrigin(0, 0, 1);

    //Volumes properties CT
    vtkNew<vtkVolumeProperty> CTvolumeProperty;
    CTvolumeProperty->SetInterpolationTypeToLinear();

    vtkNew<vtkVolume> CTvolume;
    CTvolume->SetMapper(CTvolumeMapper);
    CTvolume->SetProperty(CTvolumeProperty);

    vtkNew<vtkImageReslice> CTreslice;
    CTreslice->SetInputData(CTimageData);
    CTreslice->SetOutputDimensionality(2);
    CTreslice->SetResliceAxesDirectionCosines(1, 0, 0, 0, 1, 0, 0, 0, 1);
    CTreslice->SetInterpolationModeToLinear();

    CTreslice->SetResliceAxesOrigin(0, 0, 1);

    // Create a vtkLookupTable for color mapping MR
    vtkNew<vtkLookupTable> MRcolorTable;
    MRcolorTable->SetTableRange(0, 256); // Zakres danych medycznych
    MRcolorTable->SetHueRange(0.7, 0.7);
    MRcolorTable->SetSaturationRange(1.0, 1.0); // Nasycenie kolorów
    MRcolorTable->SetValueRange(0.2, 1.0); // Jasność kolorów
    MRcolorTable->SetAlphaRange(1.0, 1.0); // Kolor nie jest przezroczysty
    MRcolorTable->SetNumberOfColors(256); // Liczba kolorów w mapie (dostosuj według potrzeb)
    // Tworzenie mapy kolorów
    for (int i = 0; i < 256; i++) {
        double val = static_cast<double>(i) / 255.0;
        MRcolorTable->SetTableValue(i, val, val, val * 0.8, 1.0); // Ustaw niebieski kolor
    }

    // Create a vtkLookupTable for color mapping CT
    vtkNew<vtkLookupTable> CTcolorTable;
    CTcolorTable->SetTableRange(0, 10000); // Zakres danych medycznych
    CTcolorTable->SetHueRange(0.0, 0.0);
    CTcolorTable->SetSaturationRange(0.0, 0.0); // Nasycenie kolorów
    CTcolorTable->SetValueRange(0.0, 1.0); // Jasność kolorów
    CTcolorTable->SetAlphaRange(1.0, 1.0); // Kolor nie jest przezroczysty

    MRcolorTable->Build();
    CTcolorTable->Build();

    // Przeprowadź przekształcenie geometryczne danych MR
    vtkNew<vtkTransform> transform;

    // Przekształcenie do współrzędnych rzeczywistych przez pomnożenie każdego woksela zbioru MR przez jego rozmiar
    transform->Scale(0.351562, 0.351562, 0.7);

    // Oblicz przesunięcie tak, aby maksymalne wartości były w tej samej pozycji
    double shiftX = (512 - 512) / 2.0; // Szerokość CT - Szerokość MR
    double shiftY = (512 - 512) / 2.0; // Wysokość CT - Wysokość MR
    double shiftZ = (247 - 192) / 2.0; // Grubość CT - Grubość MR

    // Przesuń dane MR
    vtkNew<vtkTransform> shiftTransform;
    shiftTransform->Translate(shiftX, shiftY, shiftZ);

    // Dodaj przesunięcie do transformacji
    transform->Concatenate(shiftTransform);

    // Przekształcenie do współrzędnych zbioru CT przez podzielenie każdego woksela zbioru MR przez rozmiar woksela zbioru CT
    transform->Scale(1.0 / 0.447266, 1.0 / 0.447266, 0.625 / 0.7);

    vtkNew<vtkImageReslice> MRCTreslice;
    MRCTreslice->SetInputData(MRimageData);
    MRCTreslice->SetOutputDimensionality(2);
    MRCTreslice->SetResliceAxesDirectionCosines(1, 0, 0, 0, 1, 0, 0, 0, 1);
    MRCTreslice->SetInterpolationModeToLinear();

    // Dodaj transformację do MRCTreslice
    MRCTreslice->SetResliceTransform(transform);

    vtkNew<vtkImageMapToColors> MRcolorMapper;
    MRcolorMapper->SetInputConnection(MRreslice->GetOutputPort());
    MRcolorMapper->SetLookupTable(MRcolorTable.Get());

    vtkNew<vtkImageMapToColors> CTcolorMapper;
    CTcolorMapper->SetInputConnection(CTreslice->GetOutputPort());
    CTcolorMapper->SetLookupTable(CTcolorTable.Get());

    vtkNew<vtkImageMapToColors> MRCTcolorMapper;
    MRCTcolorMapper->SetInputConnection(MRCTreslice->GetOutputPort());
    MRCTcolorMapper->SetLookupTable(MRcolorTable.Get());


    // Tworzenie histogramu CT
    vtkNew<vtkImageHistogram> ctHistogram;
    ctHistogram->SetInputData(CTimageData);
    ctHistogram->SetNumberOfBins(256); // Liczba koszyków
    ctHistogram->SetBinOrigin(0); // Początek zakresu wartości pikseli CT
    ctHistogram->SetBinSpacing(64); // Rozmiar koszyka (jeden piksel)

    // Tworzenie histogramu MR
    vtkNew<vtkImageHistogram> mrHistogram;
    mrHistogram->SetInputData(MRimageData);
    mrHistogram->SetNumberOfBins(256); // Liczba koszyków
    mrHistogram->SetBinOrigin(0); // Początek zakresu wartości pikseli MR
    mrHistogram->SetBinSpacing(1); // Rozmiar koszyka (jeden piksel)

    // Oblicz miarę NMI
    double nmi = 0.0;
    // Oblicz histogramy CT i MR
    ctHistogram->Update();
    mrHistogram->Update();

    // Oblicz sumy binów histogramów CT i MR
    double sumBinsCT = 0.0;
    double sumBinsMR = 0.0;
    double epsilon = 1e-10; // Mała stała zapobiegająca dzieleniu przez zero

    for (int i = 0; i < 256; ++i) {
        double pCT = ctHistogram->GetOutput()->GetScalarComponentAsDouble(i, 0, 0, 0);
        double pMR = mrHistogram->GetOutput()->GetScalarComponentAsDouble(i, 0, 0, 0);

        sumBinsCT += pCT;
        sumBinsMR += pMR;

        if (pCT > 0 && pMR > 0) {
            double pJoint = pCT * pMR; // Oblicz prawdopodobieństwo wspólne
            nmi += pJoint * log(pJoint / (pCT * pMR) + epsilon); // Dodaj do NMI
        }
    }

    // Oblicz miarę NMI
    nmi /= sqrt(sumBinsCT * sumBinsMR);

    // Formatuj wynik jako liczbę zmiennoprzecinkową z ograniczoną precyzją po przecinku
    std::ostringstream stream;
    stream << std::fixed << std::setprecision(12) << nmi; // Ustal precyzję, np. 4 miejsca po przecinku

    QString nmiString = QString::fromStdString(stream.str());

    // Tworzenie QLabel do wyświetlenia wyniku NMI
    QLabel *nmiLabel = new QLabel("NMI: " + nmiString);
    dockLayout->addWidget(nmiLabel);


    // Create a vtkImageActor and set it up to display the slice with colors
    vtkNew<vtkImageActor> MRimageActor;
    vtkNew<vtkImageActor> CTimageActor;
    vtkNew<vtkImageActor> MRCTimageActor;
    vtkNew<vtkImageActor> hist;
    vtkNew<vtkImageActor> histMR;
    MRimageActor->GetMapper()->SetInputConnection(MRcolorMapper->GetOutputPort());
    CTimageActor->GetMapper()->SetInputConnection(CTcolorMapper->GetOutputPort());
    MRCTimageActor->GetMapper()->SetInputConnection(MRCTcolorMapper->GetOutputPort());
    hist->GetMapper()->SetInputConnection(ctHistogram->GetOutputPort());
    histMR->GetMapper()->SetInputConnection(mrHistogram->GetOutputPort());

    vtkNew<vtkRenderer> MRrenderer;
    vtkNew<vtkRenderer> CTrenderer;
    vtkNew<vtkRenderer> MRCTrenderer;
    vtkNew<vtkRenderer> histRenderer;
    vtkNew<vtkRenderer> MRhistRenderer;
    mrRenderWindow->AddRenderer(MRrenderer);
    MRrenderer->AddActor(MRimageActor);
    ctRenderWindow->AddRenderer(CTrenderer);
    CTrenderer->AddActor(CTimageActor);
    ctMrRenderWindow->AddRenderer(MRCTrenderer);
    MRCTrenderer->AddActor(MRCTimageActor);

    histogramRenderWindow->AddRenderer(histRenderer);
    histRenderer->AddActor(hist);

    MRhistogramRenderWindow->AddRenderer(MRhistRenderer);
    MRhistRenderer->AddActor(histMR);

    // Dodaj widżety do siatki w głównym oknie
    gridLayout->addWidget(ctRenderWidget, 0, 0);
    gridLayout->addWidget(mrRenderWidget, 0, 1);
    gridLayout->addWidget(ctMrRenderWidget, 0, 2);
    gridLayout->addWidget(histogramRenderWidget, 1, 0);
    gridLayout->addWidget(MRhistogramRenderWidget, 1, 1);


    mainWindow.show();
    MRrenderer->Render();
    CTrenderer->Render();
    MRCTrenderer->Render();
    histRenderer->Render();
    MRhistRenderer->Render();

    QObject::connect(&slider, &QSlider::valueChanged, [&](int value) {
        MRreslice->SetResliceAxesOrigin(0, 0, value);
        CTreslice->SetResliceAxesOrigin(0, 0, value);
        MRCTreslice->SetResliceAxesOrigin(0, 0, value);
        MRrenderer->GetRenderWindow()->Render();
        CTrenderer->GetRenderWindow()->Render();
        MRCTrenderer->GetRenderWindow()->Render();
        });

    return app.exec();
}