#include "dumps.h"

#include <QDebug>
#include <QDir>
#include <QElapsedTimer>
#include <QFile>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>

#include <iostream>

QList<Pixels> openDump(
    const QString &dumpPath)
{
    QString dirToRead{dumpPath};
    qDebug() << "trying to open dump path:" << dirToRead;

    if (dirToRead.isEmpty()) {
        qDebug() << "dumpPath not specified. looking into" << dumpsRoot;

        QDir dumpsRootDir{dumpsRoot};

        const auto filter = QDir::Dirs | QDir::NoDotAndDotDot | QDir::Readable;
        // there is no battery in my rpi5 for now
        const auto sort = QDir::Name;
        const auto entries = dumpsRootDir.entryList(filter, sort);

        if (entries.isEmpty()) {
            qWarning() << "dumps root" << dumpsRoot << "contains no dumps. "
                       << "specify existing dump path";

            return {};
        }

        dirToRead = dumpsRoot + "/" + entries.last();
    }

    QDir dumpDir{dirToRead};

    // const QStringList nameFilters{"*.bin"};
    const QStringList nameFilters{};
    const auto filter = QDir::Files;
    const auto sort = QDir::Name;

    auto filenames = dumpDir.entryList(nameFilters, filter, sort);

    if (filenames.isEmpty()) {
        qDebug() << "no filenames found in" << dumpDir.path();
        return {};
    }

    qDebug() << "create results array" << filenames.size();
    auto resultOptionals = QScopedPointer(
        new QList<std::optional<Pixels>>(filenames.size()));
    qDebug() << "created results array";

    QElapsedTimer t;
    t.start();
    qDebug() << "open real files";
    std::cout << "here" << std::endl;

    std::transform(
        std::execution::par_unseq,
        filenames.begin(),
        filenames.end(),
        resultOptionals->begin(),
        [dirToRead](const auto &filename) {
            // std::cout << '.';
            // auto rawProfile = openRawProfile(dirToRead + "/" + filename);
            auto rawProfile = Pixels::load(dirToRead + "/" + filename);

            return rawProfile;
        });

    filenames.clear();
    filenames.squeeze();

    qDebug() << Q_FUNC_INFO << "open raw profiles: elapsed (ms)" << t.elapsed();
    // std::cout << std::endl;

    std::remove_if(std::execution::par,
                   resultOptionals->begin(),
                   resultOptionals->end(),
                   [](auto &a) { return !a.has_value(); });

    QList<Pixels> result(resultOptionals->size());

    std::transform(std::execution::par,
                   std::make_move_iterator(resultOptionals->begin()),
                   std::make_move_iterator(resultOptionals->end()),
                   result.begin(),
                   [](auto &p) { return p.value(); });

    qDebug() << Q_FUNC_INFO << "elapsed (ms)" << t.elapsed();

    return result;
}

std::optional<Pixels> openRawProfile(
    const QString &filePath)
{
    QFile f{filePath};

    if (!f.open(QFile::ReadOnly)) {
        qWarning() << "cannot open file for reading:" << f.fileName();
        qWarning() << "error string:" << f.errorString();

        return {};
    }

    // TODO: rewrite to remove manual serialization/deserialization
    const auto json = QJsonDocument::fromJson(f.readAll()).object();
    const auto jsonCounters = json["counters"].toObject();

    Pixels result;
    result.counters.timestampUs = jsonCounters["timestampUs"].toInteger();
    result.counters.measurementCounter = jsonCounters["measurementCounter"]
                                             .toInteger();
    result.counters.encoderPosition = jsonCounters["encoderPosition"].toInteger();

    const auto jsonPixels = json["pixels"].toArray();
    // TODO: check json pixels count
#ifdef FIRST_COLUMN_ONLY
    result.pixels[0] = jsonPixels.at(0).toDouble();
#else
    std::transform(
        // std::execution::par_unseq,
        jsonPixels.constBegin(),
        jsonPixels.constEnd(),
        result.pixels.begin(),
        [](const auto &jsonPixel) { return jsonPixel.toDouble(); });

// for (size_t i = 0; i < jsonPixels.count() && i < result.pixels.size();
// ++i)
// {
//     result.pixels[i] = jsonPixels[i].toDouble();
// }
#endif

    return result;
}