#include "dumps.h"

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

#include "fuck_intel.h"

#include "calibration.h"

#include <chrono>
#include <execution>
#include <iostream>

QList<Pixels> openDump(
    const QString &dumpPath)
{
    QString dirToRead{dumpPath};
    qDebug() << __func__ << "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);
    qDebug() << __func__ << "dump path" << dumpPath << "has" << filenames.size() << "files";

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

    if (false) {
        filenames = filenames.first(1000);
    }

    using mc_t = decltype(Counters::measurementCounter);
    using ep_t = decltype(Counters::encoderPosition);
    using counters_tuple_t = std::tuple<mc_t, ep_t>;
    std::vector<counters_tuple_t> metaFilenames{static_cast<size_t>(filenames.size())};

    const auto fn2meta = [](const QString &filename) -> counters_tuple_t {
        const auto splitted = filename.split('_');
        const auto mc = splitted.at(3).toUInt();
        const auto ep = splitted.at(5).toUInt();
        return std::make_tuple(mc, ep);
    };

    const auto meta2fn = [](const counters_tuple_t &meta) {
        const auto &[mc, ep] = meta;
        const auto tmp = QStringLiteral("raw_profile_meas_%1_enc_%2").arg(mc).arg(ep);
        return tmp;
    };

    std::transform(filenames.cbegin(), filenames.cend(), metaFilenames.begin(), fn2meta);

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

    std::sort(metaFilenames.begin(), metaFilenames.end(), [](const auto &a, const auto &b) {
        const auto &[mca, epa] = a;
        const auto &[mcb, epb] = b;
        return mca < mcb;
    });

    // std::multimap<ep_t, mc_t> enc_meas;
    std::map<ep_t, std::vector<mc_t>> enc_meas;

    for (const auto &mf : metaFilenames) {
        const auto &[mc, ep] = mf;
        enc_meas[ep].push_back(mc);
    }

    metaFilenames.clear();
    metaFilenames.shrink_to_fit();

    QList<Pixels> result;
    result.reserve(static_cast<qsizetype>(enc_meas.size()));

    QElapsedTimer t;
    t.start();
    qDebug() << __func__ << "open real files";
    uint8_t lastPercent{std::numeric_limits<decltype(lastPercent)>::max()};
    auto lastPercentTime = std::chrono::system_clock::now();

    // for (const auto &[ep, mcl] : enc_meas) {
    for (auto em = enc_meas.cbegin(); em != enc_meas.cend(); ++em) {
        const auto &[ep, mcl] = *em;
        std::vector<Pixels> toFilter;
        toFilter.reserve(mcl.size());

        for (const auto &mc : mcl) {
            const auto &filename = meta2fn(std::make_tuple(mc, ep));
            const auto pixelsOpt = Pixels::load(dirToRead + '/' + filename);

            if (pixelsOpt.has_value()) {
                toFilter.push_back(*pixelsOpt);
            }
        };

        // const auto filtered = op::avgFilterAtPos(std::move(toFilter));
        const auto filtered = op::medianFilterAtPos(std::move(toFilter));

        if (filtered.has_value()) {
            result.push_back(*filtered);
        }

        const uint8_t percent{
            static_cast<uint8_t>(std::distance(enc_meas.cbegin(), em) * 100 / enc_meas.size())};

        if (percent != lastPercent) {
            lastPercent = percent;
            const auto now = std::chrono::system_clock::now();
            const auto diffMs = std::chrono::duration_cast<std::chrono::milliseconds>(
                                    now - lastPercentTime)
                                    .count();
            lastPercentTime = std::chrono::system_clock::now();
            qDebug().nospace() << Q_FUNC_INFO << ": " << lastPercent
                               << "%; count: " << result.size() << "; ms (1%): " << diffMs;
        }
    }

    // std::sort(filenames.begin(), filenames.end(), [](const auto &a, const auto &b) {
    //     const auto mca = a.split('_').at(3).toInt();
    //     const auto mcb = b.split('_').at(3).toInt();
    //     return mca < mcb;
    // });

    // for (size_t i{0}; i < metaFilenames.size(); ++i) {
    //     const auto &meta = metaFilenames.at(i);
    //     const auto filename = meta2fn(meta);
    //     auto rawProfile = Pixels::load(dirToRead + '/' + filename);

    //     if (rawProfile.has_value()) {
    //         result << *rawProfile;
    //     }
    //     const uint8_t percent{static_cast<uint8_t>(i * 100 / metaFilenames.size())};

    //     if (percent != lastPercent) {
    //         lastPercent = percent;
    //         qDebug().nospace() << Q_FUNC_INFO << ": " << lastPercent << '%';
    //     }
    // }

    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;
}