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

// #include <execution>

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

    QQmlApplicationEngine engine;

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

    auto plot = new QCustomPlot();
    plot->setOpenGl(true);
    engine.rootContext()->setContextProperty("myPlot", plot);
    engine.rootContext()->setContextProperty("max_diff", 0.0);
    engine.rootContext()->setContextProperty("avg_diff", 0.0);
    engine.rootContext()->setContextProperty("median_diff", 0.0);

    QVector<qreal> x_profile;
    QVector<qreal> y_profile;
    QVector<qreal> prev_y_profile;

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

        x_profile << x;
        y_profile << y;
    }
    prev_y_profile = y_profile;

    auto graph = plot->addGraph();
    graph->setPen(QPen(QBrush(Qt::red), 2));
    graph->setLineStyle(QCPGraph::lsNone);
    graph->setScatterStyle(QCPScatterStyle::ssDot);
    graph->setData(x_profile, y_profile);

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

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

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

            return;
        }

        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_profile[i] = jsonPixels.at(i).toDouble();
        }

        QVector<qreal> y_diff(y_profile.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_profile.count(); ++i) {
            y_diff[i] = y_profile.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();

        // for (size_t i = 0; i < y_profile.size(); ++i) {
        //     if
        // }

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

        // if (qFuzzyIsNull(max_diff)) {
        //     qDebug() << "max_diff is null";

        //     static bool done = [&]() -> bool {
        //         for (const auto & y : y_profile) {
        //             qDebug() << y;
        //         }
        //         return true;
        //     }();

        //     manager->get(request);

        //     return;
        // }

        graph->setData(x_profile, y_profile);

        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 qmlCustomPlot = engine.rootObjects().first()->findChild<QmlCustomPlot*>("qmlCustomPlot");

        if (!qmlCustomPlot)
        {
            qWarning() << "no qmlCustomPlot";
        }
        else
        {
            // qDebug() << "set lines. count is" << lines.count();
            qmlCustomPlot->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(request);
        pixelsAutoRestartTimer.start();

        prev_y_profile = y_profile;

        reply->deleteLater();
    });

    manager->get(request);
    pixelsAutoRestartTimer.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();
}