// cpp and linux
#include <chrono>
#include <csignal>
#include <errno.h>
#include <fcntl.h>
#include <iostream>
#include <linux/videodev2.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>

// qt
#include <QCoreApplication>
#include <QDebug>
#include <QDir>
#include <QFile>
#include <QHttpServer>
#include <QImage>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QSerialPort>
#include <QTextStream>
#include <QTimer>
#include <QtConcurrent/QtConcurrent>

// orpheus
#include "LibCamera.h"
#include "calibration.h"
#include "camera/veyeimx287m.h"
#include "dumps.h"
#include "imagealgos.h"
#include "profile.h"
#include "protocols/httpserver.h"
#include "scanner.h"

//
#include "rapidjson/document.h"
#include "rapidjson/stringbuffer.h"
#include "rapidjson/writer.h"

extern uint8_t pgm_image[64 + img_width * img_height * sizeof(uint8_t)];
extern size_t pgm_image_size;
extern std::mutex pgm_image_mtx;

#define try_apply_config() \
    if (!applyConfig(config)) { \
        camera->release(); \
        cm->stop(); \
\
        return EXIT_FAILURE; \
    }

ScanningModeFlags scanningModeFlags{ScanningModeFlags::None};

QElapsedTimer calibrationTimer;

extern volatile int32_t positionSteps;

requested_params_t requested_params;

namespace {
Pixels pixels;
std::vector<Pixels> calibrationPixels;
QMutex calibrationPixelsMutex;
} // namespace

using namespace std::chrono_literals;

namespace {
CalibrationTablePtr calibrationTableZ;
CalibrationTablePtr calibrationTableX;
} // namespace

auto printPixels = [](const auto &pixels) {
    for (size_t i = (img_width - 10) / 2;
         i < img_width - ((img_width - 10) / 2);
         ++i) {
        std::cout << pixels[i] << " ";
    }
    std::cout << std::endl;
};

int main(int argc, char *argv[])
{
    auto sigHandler = [](int s) {
        std::cout << "got signal " << s << std::endl;
        std::signal(s, SIG_DFL);
    };

    std::signal(SIGINT, sigHandler);
    std::signal(SIGTERM, sigHandler);

    QCoreApplication app(argc, argv);

    QList<QFuture<void>> initializers;

    qDebug() << "size of raw profile" << sizeof(Pixels);
    if (false) {
        // open binary calibration table
        if (true) {
            initializers << QtConcurrent::run([&]() {
                if (!openCalibrationTable(
                        "/home/user/dumps/binz.calibration_table",
                        // "/tmp/binz.calibration_table",
                        ::calibrationTableZ)) {
                    exit(EXIT_FAILURE);
                }
            });

            initializers << QtConcurrent::run([&]() {
                if (!openCalibrationTable(
                        "/home/user/dumps/binx.calibration_table",
                        // "/tmp/binx.calibration_table",
                        ::calibrationTableX)) {
                    exit(EXIT_FAILURE);
                }
            });
        }

        if (false) {
            auto rawProfiles = openDump("/home/user/dumps/binx");
            qDebug() << "raw x-profiles count is" << rawProfiles.size();
            // qDebug() << "height" << calibrationColumnHeight;

            auto filteredRawProfiles = filter(std::move(rawProfiles));
            qDebug() << "filtered x-profiles count is"
                     << filteredRawProfiles.count();

            ::calibrationTableX = calibrateX(std::move(filteredRawProfiles));

            interpolate(::calibrationTableX);
        }

        // load binary calibration dumps and calibrate
        if (false) {
            if (true) {
                auto rawProfiles = openDump("/home/user/dumps/binz");
                qDebug() << "raw z-profiles count is" << rawProfiles.size();

                auto filteredRawProfiles = filter(std::move(rawProfiles));
                qDebug() << "filtered z-profiles count is"
                         << filteredRawProfiles.count();

                ::calibrationTableZ = calibrateZ(std::move(filteredRawProfiles),
                                                 requested_params.stepsPerMm);

                interpolate(::calibrationTableZ);

                if (!dump(::calibrationTableZ,
                          "/home/user/dumps/binz.calibration_table")) {
                    qApp->exit(EXIT_FAILURE);
                }
            }

            qDebug()
                << "--------------------------------------------------------";

            if (true) {
                auto rawProfiles = openDump("/home/user/dumps/binx");
                qDebug() << "raw x-profiles count is" << rawProfiles.size();

                auto filteredRawProfiles = filter(std::move(rawProfiles));
                qDebug() << "filtered x-profiles count is"
                         << filteredRawProfiles.count();

                ::calibrationTableX = calibrateX(std::move(filteredRawProfiles));

                interpolate(::calibrationTableX);

                if (!dump(::calibrationTableX,
                          "/home/user/dumps/binx.calibration_table")) {
                    qApp->exit(EXIT_FAILURE);
                }
            }
        }
    }

    QElapsedTimer t;
    t.start();

    // FIXME: don't use one var for everything
    int ret;

    auto cameras = VeyeIMX287m::search();

    if (cameras.empty()) {
        std::cerr << "No cameras were identified on the system." << std::endl;

        return EXIT_FAILURE;
    }

    auto camera = cameras.at(0);

    std::cout << "connect everything" << std::endl;

    for (auto &i : initializers)
        i.waitForFinished();
    std::cout << "loaded calibration tables" << std::endl;

    if (!camera->startStream()) {
        return EXIT_FAILURE;
    }

    auto httpServer = std::make_shared<HttpServer>(camera);

    const auto scanner
        = std::make_shared<Scanner>(camera,
                                    std::vector<std::shared_ptr<IProtocol>>{
                                        httpServer});

    QHttpServer qHttpServer;

    qHttpServer.route("/v1/profile", [&]() -> QHttpServerResponse {
        // std::cout << "http: profile" << std::endl;
        return QHttpServerResponse::StatusCode::ServiceUnavailable;
        std::lock_guard<std::mutex> lg(pgm_image_mtx);

        if (!::calibrationTableZ || !::calibrationTableX)
            return QHttpServerResponse::StatusCode::ServiceUnavailable;

        const Profile profile(::pixels,
                              ::calibrationTableZ,
                              ::calibrationTableX);

        const QJsonObject json{{"profile", QJsonObject(profile)}};

        return QHttpServerResponse(QJsonDocument(json).toJson());
    });

    qHttpServer
        .route("/v1/commands/resetEncoder",
               [&](const QHttpServerRequest &request) -> QHttpServerResponse {
                   std::cout << "http: resetEncoder" << std::endl;
                   if (request.method() != QHttpServerRequest::Method::Post) {
                       return QHttpServerResponse::StatusCode::NotFound;
                   }

                   qDebug() << "reset encoder";

                   positionSteps = 0;

                   return QHttpServerResponse::StatusCode::Ok;
               });

    qHttpServer
        .route("/v1/commands/startCalibration",
               [&](const QHttpServerRequest &request) -> QHttpServerResponse {
                   std::cout << "http: startCalibration" << std::endl;
                   if (request.method() != QHttpServerRequest::Method::Post) {
                       return QHttpServerResponse::StatusCode::NotFound;
                   }

                   qDebug() << "start calibration";

                   // TODO: use flags
                   scanningModeFlags = ScanningModeFlags::Calibration;
                   calibrationTimer.start();

                   return QHttpServerResponse::StatusCode::Ok;
               });

    qHttpServer
        .route("/v1/commands/gCode",
               [&](const QHttpServerRequest &request) -> QHttpServerResponse {
                   std::cout << "http: gCode" << std::endl;
                   if (request.method() != QHttpServerRequest::Method::Post) {
                       return QHttpServerResponse::StatusCode::NotFound;
                   }

                   const auto command = request.body();

                   qDebug() << "send gCode:" << command;

                   // printerClient.sendCommand(command);

                   return QHttpServerResponse::StatusCode::Ok;
               });

    qDebug() << "listen: " << qHttpServer.listen(QHostAddress::Any, 8081);

    ////////////////////////////////////////////////////////////////////////////
    std::clog << std::flush;
    std::cerr << std::flush;
    std::cout << "ok for now" << std::endl << std::flush;

    auto result = app.exec();

    return result;
}