#include <QApplication>
#include <QElapsedTimer>
#include <QEventLoop>
#include <QThread>
#include <QTime>
#include <cmath>
#include <unordered_map>
#include "../Renderive/Axis/Axis.h"
#include "../Renderive/Axis/Frequency_Axis.h"
#include "../Renderive/Axis/Time_Axis.h"
#include "../Renderive/Axis/Time_Axis_p.h"
#include "../Renderive/architecture/Plot.h"
#include "../Renderive/architecture/Plot_p.h"
#include "../Renderive/base/Memory.h"
#include "../Renderive/plottable/Audio_Frequency.h"
#include "../Renderive/plottable/Audio_Frequency_p.h"
#include "../Renderive/plottable/Planisphere.h"
#include "../Renderive/plottable/Planisphere_p.h"
#include "../Renderive/plottable/Waterfall.h"
#include "../Renderive/plottable/Waterfall_p.h"
namespace {
void process_events(int milliseconds) {
    QElapsedTimer timer;
    timer.start();
    while (timer.elapsed() < milliseconds) {
        QApplication::processEvents(QEventLoop::AllEvents, 10);
        QThread::msleep(1);
    }
}
std::vector<double> make_frequency_data(int size, int frame) {
    std::vector<double> data(size);
    for (int i = 0; i < size; ++i)
        data[i] = -90.0 + 30.0 * std::sin(static_cast<double>(i + frame) * 0.017);
    return data;
}
bool wait_ready(const std::shared_ptr<renderive::Waterfall>& waterfall, const std::shared_ptr<renderive::Time_Axis>& time_axis, const std::shared_ptr<renderive::Audio_Frequency>& audio, const std::shared_ptr<renderive::Planisphere>& planisphere) {
    QElapsedTimer timer;
    timer.start();
    while (timer.elapsed() < 3000) {
        QApplication::processEvents(QEventLoop::AllEvents, 10);
        if (waterfall->ok() && time_axis->ok() && audio->ok() && planisphere->ok())
            return true;
        QThread::msleep(1);
    }
    return false;
}
bool wait_idle(renderive::Plot& plot) {
    QElapsedTimer timer;
    timer.start();
    while (timer.elapsed() < 3000) {
        QApplication::processEvents(QEventLoop::AllEvents, 10);
        if (!plot.is_rendering() && !plot.d->active_render_tasks.load(std::memory_order_acquire))
            return true;
        QThread::msleep(1);
    }
    return false;
}
int stress_data_paths() {
    renderive::Plot plot;
    plot.init();
    plot.resize(720, 420);
    auto data_node = plot.create_renderable_node(plot.get_root_renderable(), "Data_Renderable");
    auto axis_node = plot.create_renderable_node(plot.get_root_renderable(), "Axis_Renderable");
    auto frequency_axis = renderive::Frequency_Axis::Builder(axis_node, Qt::Horizontal).set_pixel_size(700).set_coord_range({0.0, 100.0}).build();
    auto time_axis = renderive::Time_Axis::Builder(axis_node, Qt::Vertical).set_pixel_size(400).set_time_point_size(32).build();
    auto value_axis = renderive::Axis::Builder(axis_node, Qt::Vertical).set_pixel_size(400).set_coord_range({-120.0, 0.0}).build();
    auto i_axis = renderive::Axis::Builder(axis_node, Qt::Horizontal).set_pixel_size(700).set_coord_range({-2.0, 2.0}).build();
    auto q_axis = renderive::Axis::Builder(axis_node, Qt::Vertical).set_pixel_size(400).set_coord_range({-2.0, 2.0}).build();
    auto waterfall = renderive::Waterfall::Builder(data_node, frequency_axis, time_axis).set_frequency_range({0.0, 100.0}).set_power_range({-120.0, 0.0}).set_frequency_point_size(64).build();
    auto audio = renderive::Audio_Frequency::Builder(data_node, time_axis, value_axis).set_time_point_size(32).set_key_range({-120.0, 0.0}).build();
    auto planisphere = renderive::Planisphere::Builder(data_node, i_axis, q_axis).set_i_range({-2.0, 2.0}).set_q_range({-2.0, 2.0}).set_continue_millisecond(500).build();
    plot.show();
    plot.start_render(240);
    if (!wait_ready(waterfall, time_axis, audio, planisphere))
        return 1;
    const int frequency_sizes[] = {64, 512, 8192, 8193, 128};
    const int time_sizes[] = {32, 96, 48, 64, 24};
    const renderive::Waterfall_Update_Mode update_modes[] = {
        renderive::Waterfall_Update_Mode::Batch,
        renderive::Waterfall_Update_Mode::Single_Line,
        renderive::Waterfall_Update_Mode::Timed_Latest,
        renderive::Waterfall_Update_Mode::Single_Line,
        renderive::Waterfall_Update_Mode::Batch
    };
    for (int stage = 0; stage < 5; ++stage) {
        waterfall->set_frequency_point_size(frequency_sizes[stage]);
        waterfall->set_update_mode(update_modes[stage]);
        waterfall->set_update_interval_ms(2);
        time_axis->set_time_point_size(time_sizes[stage]);
        audio->set_time_point_size(time_sizes[stage]);
        process_events(100);
        std::unordered_map<int, double> expected_frequency;
        QTime expected_time;
        double expected_power{};
        QPointF expected_position;
        for (int frame = 0; frame < time_sizes[stage] * 2; ++frame) {
            std::vector<double> frequency_data = make_frequency_data(frequency_sizes[stage], frame);
            expected_time = QTime::fromMSecsSinceStartOfDay((stage * 10000 + frame * 4) % 86400000);
            int tick = time_axis->give_data(expected_time);
            waterfall->give_data(tick, frequency_data);
            expected_frequency[tick] = frequency_data.front();
            expected_power = frequency_data[frame % frequency_data.size()];
            audio->give_data(tick, expected_power);
            double phase = static_cast<double>(frame) * 0.13;
            expected_position = {1.5 * std::cos(phase), 1.5 * std::sin(phase)};
            planisphere->give_data(expected_position);
            if ((frame & 3) == 3)
                process_events(8);
        }
        process_events(60);
        plot.pause_render();
        if (!wait_idle(plot))
            return 2;
        auto* waterfall_data = waterfall->d();
        if (waterfall_data->ring_buffer.col_count != frequency_sizes[stage] || waterfall_data->ring_buffer.row_count != time_sizes[stage])
            return 3;
        if (waterfall_data->image.width() != frequency_sizes[stage] || waterfall_data->image.height() != time_sizes[stage])
            return 4;
        int row_count = waterfall_data->ring_buffer.snapshot();
        int previous_tick{};
        for (int row = 0; row < row_count; ++row) {
            int tick = waterfall_data->ring_buffer.tick(row);
            auto expected = expected_frequency.find(tick);
            if (expected == expected_frequency.end())
                return 5;
            if (std::abs(waterfall_data->ring_buffer.frequency_data(row, 0, 0)[0] - expected->second) > 0.000001)
                return 6;
            if (row && tick >= previous_tick)
                return 7;
            previous_tick = tick;
        }
        auto* time_data = time_axis->d();
        if (time_data->time_ticker.time_point_size != time_sizes[stage] || time_data->time_snapshot.size() != static_cast<std::size_t>(time_sizes[stage]))
            return 8;
        if (!time_data->time_data_count || time_data->time_snapshot[time_data->time_data_count - 1] != expected_time)
            return 9;
        int lower = qMin(time_data->time_ticker.lower, time_data->time_ticker.upper());
        int upper = qMax(time_data->time_ticker.lower, time_data->time_ticker.upper());
        for (const renderive::Time_Tick& tick : time_data->data) {
            if (tick.tick < lower || tick.tick > upper)
                return 10;
        }
        auto* audio_data = audio->d();
        if (audio_data->point_count != time_sizes[stage] || audio_data->power_snapshot.size() != static_cast<std::size_t>(time_sizes[stage]))
            return 11;
        if (!audio_data->data_count || std::abs(audio_data->power_snapshot[audio_data->data_count - 1] - expected_power) > 0.000001)
            return 12;
        auto* planisphere_data = planisphere->d();
        if (planisphere_data->data_list.empty())
            return 13;
        QPointF actual_position = planisphere_data->data_list.back().pos;
        if (std::abs(actual_position.x() - expected_position.x()) > 0.000001 || std::abs(actual_position.y() - expected_position.y()) > 0.000001)
            return 14;
        plot.start_render(240);
    }
    for (int frame = 0; frame < 180; ++frame) {
        planisphere->set_continue_millisecond(500 + (frame & 1));
        process_events(8);
    }
    plot.pause_render();
    if (!wait_idle(plot))
        return 15;
    if (!planisphere->d()->data_list.empty())
        return 16;
    renderive::Memory_Stats stats = renderive::memory_stats();
    return stats.upstream_allocation_count && stats.upstream_peak_bytes ? 0 : 17;
}
}
int main(int argc, char** argv) {
    QApplication app(argc, argv);
    renderive::start_render_scheduler();
    return stress_data_paths();
}