#include <QApplication>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QQmlApplicationEngine>
#include <QQmlContext>
#include <QTimer>
#include <QtConcurrent/QtConcurrentRun>
#include "QmlCustomPlot.h"
#include <iostream>

// #include <execution>

int main(
    int argc, char *argv[])
{
    QApplication app(argc, argv);

    QQmlApplicationEngine engine;

    qmlRegisterType<QmlCustomPlot>("QmlCustomPlot", 1, 0, "QmlCustomPlot");

    auto pixelsPlot = new QCustomPlot();
#ifdef QCUSTOMPLOT_USE_OPENGL
    pixelsPlot->setOpenGl(true);
#endif

    auto profilePlot = new QCustomPlot();
#ifdef QCUSTOMPLOT_USE_OPENGL
    profilePlot->setOpenGl(true);
#endif

    engine.rootContext()->setContextProperty("pixelsPlot", pixelsPlot);
    engine.rootContext()->setContextProperty("profilePlot", profilePlot);
    engine.rootContext()->setContextProperty("max_diff", 0.0);
    engine.rootContext()->setContextProperty("avg_diff", 0.0);
    engine.rootContext()->setContextProperty("median_diff", 0.0);

    QVector<qreal> x_pixels;
    QVector<qreal> y_pixels;

    QVector<qreal> prev_y_profile;

    for (int x = -640; x < 640; ++x) {
        double y = double(QRandomGenerator::global()->bounded(0, 80000)) / 100.;

        x_pixels << x;
        y_pixels << y;
    }
    prev_y_profile = y_pixels;

    auto pixelsGraph = pixelsPlot->addGraph();
    pixelsGraph->setPen(QPen(QBrush(Qt::red), 2));
    pixelsGraph->setLineStyle(QCPGraph::lsNone);
    pixelsGraph->setScatterStyle(QCPScatterStyle::ssDot);
    pixelsGraph->setData(x_pixels, y_pixels);

    auto profileGraph = profilePlot->addGraph();
    profileGraph->setPen(QPen(QBrush(Qt::red), 2));
    profileGraph->setLineStyle(QCPGraph::lsNone);
    profileGraph->setScatterStyle(QCPScatterStyle::ssDot);
    profileGraph->setData(x_pixels, y_pixels);

    // QNetworkRequest pixelsRequest(QUrl("http://rpi5:8081/v1/pixels"));
    // QNetworkRequest profileRequest(QUrl("http://rpi5:8081/v1/profile"));
    QNetworkRequest pixelsRequest(QUrl("http://rpizero:8081/v1/pixels"));
    QNetworkRequest profileRequest(QUrl("http://rpizero:8081/v1/profile"));
    auto manager = new QNetworkAccessManager(&app);

    QTimer pixelsAutoRestartTimer(&app);
    pixelsAutoRestartTimer.setInterval(500);
    pixelsAutoRestartTimer.setSingleShot(false);
    QObject::connect(&pixelsAutoRestartTimer, &QTimer::timeout, [&]() {
        manager->get(pixelsRequest);
    });

    QTimer profileAutoRestartTimer(&app);
    profileAutoRestartTimer.setInterval(500);
    profileAutoRestartTimer.setSingleShot(false);
    QObject::connect(&profileAutoRestartTimer, &QTimer::timeout, [&]() {
        manager->get(profileRequest);
    });

    QObject::connect(
        manager, &QNetworkAccessManager::finished, [&](QNetworkReply *reply) {
            // qDebug() << "replyFinished";
            if (reply->error()) {
                qDebug() << "replyFinished:" << reply->errorString();
                qDebug() << "url was:" << reply->request().url();
                reply->deleteLater();

                return;
            }

            if (reply->url().toString().endsWith("pixels")) {
                qDebug() << "got pixels";
                auto json = QJsonDocument::fromJson(reply->readAll()).object();
                auto jsonPixels = json["pixels"].toArray();
                auto encoderPosition = json["encoderPosition"].toInteger();
                auto measurementCounter = json["measurementCounter"].toInteger();
                auto timestampUs = json["timestampUs"].toInteger();

                // y_profile.clear();

                for (int i = 0; i < jsonPixels.count(); ++i) {
                    y_pixels[i] = jsonPixels.at(i).toDouble();
                }

                QVector<qreal> y_diff(y_pixels.count());
                qreal max_diff{0.};
                qreal min_diff{1000000.};
                size_t max_diff_idx = 0;
                size_t min_diff_idx = 0;
                qreal avg_diff{0.};

                for (size_t i = 0; i < y_pixels.count(); ++i) {
                    y_diff[i] = y_pixels.at(i) - prev_y_profile.at(i);

                    if (y_diff.at(i) > max_diff) {
                        max_diff = y_diff.at(i);
                        max_diff_idx = i;
                    }

                    if (y_diff.at(i) < min_diff) {
                        min_diff = y_diff.at(i);
                        min_diff_idx = i;
                    }

                    avg_diff += fabs(y_diff.at(i));
                }

                avg_diff /= y_diff.size();

                std::sort(y_diff.begin(), y_diff.end());
                const auto median_diff = y_diff.at(y_diff.size() * 3 / 4);

                pixelsGraph->setData(x_pixels, y_pixels);

                auto jsonLines = json["lines"].toArray();

                QList<QLineF> lines(jsonLines.count());

                // FIXME: validate
                // WARNING
                // AHTUNG
                // DANGER
                std::transform(
                    // std::execution::par_unseq
                    jsonLines.cbegin(),
                    jsonLines.cend(),
                    lines.begin(),
                    [](const auto &jsonLine) -> QLineF {
                        const auto jsonPoints = jsonLine.toArray();
                        const auto jsonPoint0 = jsonPoints.at(0).toArray();
                        const auto jsonPoint1 = jsonPoints.at(1).toArray();
                        return {{jsonPoint0.at(0).toDouble(),
                                 jsonPoint0.at(1).toDouble()},
                                {jsonPoint1.at(0).toDouble(),
                                 jsonPoint1.at(1).toDouble()}};
                    });

                // lines.append({{6,780},{38,787}});

                auto pixelsCustomPlot
                    = engine.rootObjects().first()->findChild<QmlCustomPlot *>(
                        "pixelsCustomPlot");

                if (!pixelsCustomPlot) {
                    qWarning() << "no pixelsCustomPlot";
                } else {
                    // qDebug() << "set lines. count is" << lines.count();
                    pixelsCustomPlot->setLines(lines);
                }

                // 6 780
                // 38 787

                engine.rootContext()->setContextProperty("max_diff", max_diff);
                engine.rootContext()->setContextProperty("max_diff_idx",
                                                         int(max_diff_idx));
                engine.rootContext()->setContextProperty("min_diff", min_diff);
                engine.rootContext()->setContextProperty("min_diff_idx",
                                                         int(min_diff_idx));
                engine.rootContext()->setContextProperty("avg_diff", avg_diff);
                engine.rootContext()->setContextProperty("median_diff",
                                                         median_diff);
                engine.rootContext()->setContextProperty("encoderPosition",
                                                         encoderPosition);
                engine.rootContext()->setContextProperty("measurementCounter",
                                                         measurementCounter);
                engine.rootContext()->setContextProperty("timestampUs",
                                                         timestampUs);

                manager->get(pixelsRequest);
                pixelsAutoRestartTimer.start();

                prev_y_profile = y_pixels;
            } else if (reply->url().toString().endsWith("profile")) {
                qDebug() << "got profile";
                auto json = QJsonDocument::fromJson(reply->readAll()).object();
                auto jsonProfile = json["profile"].toObject();
                auto jsonPointsMm = jsonProfile["pointsMm"].toArray();

                QList<qreal> x_profile(size_t(1280), 0.);
                QList<qreal> y_profile(size_t(1280), 0.);

                static bool done{false};

                if (!done) {
                    qDebug() << "got profile result:";
                    qDebug() << jsonProfile;
                }

                for (int i = 0; i < jsonPointsMm.count(); ++i) {
                    // qDebug() << jsonPointsMm.at(i);
                    // continue;
                    const auto x = jsonPointsMm.at(i).toArray()[0].toDouble();
                    const auto z = jsonPointsMm.at(i).toArray()[1].toDouble();

                    if (qFuzzyIsNull(z) || std::isnan(z)) {
                        x_profile[i] = 0;
                        y_profile[i] = 0;
                        continue;
                    }

                    x_profile[i] = x;
                    y_profile[i] = z;

                    if (!done) {
                        qDebug() << '\t' << x_profile[i] << y_profile[i];
                    }
                }

                done = true;

                profileGraph->setData(x_profile, y_profile);

                // pixelsGraph->setData(x_profile, y_profile);
                manager->get(profileRequest);
                profileAutoRestartTimer.start();
            } else {
                qDebug() << "unknown reply type";
            }

            reply->deleteLater();
        });

    manager->get(pixelsRequest);
    pixelsAutoRestartTimer.start();

    manager->get(profileRequest);
    profileAutoRestartTimer.start();

    // auto pixelsRequestFuture = QtConcurrent::run([&](){
    //     QThread::sleep(1);
    //     // x_profile.clear();
    //     y_profile.clear();

    //     for(int x = -640; x < 640; ++x)
    //     {
    //         double y = double(QRandomGenerator::global()->bounded(0, 80000)) / 100.;

    //         // x_profile << x;
    //         y_profile << y;
    //     }

    //     graph->setData(x_profile, y_profile);
    // });

    QObject::connect(
        &engine,
        &QQmlApplicationEngine::objectCreationFailed,
        &app,
        []() { QCoreApplication::exit(-1); },
        Qt::QueuedConnection);
    engine.loadFromModule("eurydice", "Main");

    return app.exec();
}