#include "Visualization/VisualizationGraphHelper.h"
#include "Visualization/qcustomplot.h"

#include <Data/ScalarTimeSerie.h>
#include <Data/SpectrogramTimeSerie.h>
#include <Data/TimeSeriesUtils.h>
#include <Data/VectorTimeSerie.h>

#include <cpp_utils.hpp>
#include <Variable/Variable2.h>
#include <algorithm>
#include <cmath>

Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")

namespace
{

class SqpDataContainer : public QCPGraphDataContainer
{
public:
    void appendGraphData(const QCPGraphData& data) { mData.append(data); }
};

/**
 * Struct used to create plottables, depending on the type of the data series from which to create
 * them
 * @tparam T the data series' type
 * @remarks Default implementation can't create plottables
 */
template <typename T, typename Enabled = void>
struct PlottablesCreator
{
    static PlottablesMap createPlottables(QCustomPlot&, const std::shared_ptr<T>& dataSeries)
    {
        return {};
    }
};

PlottablesMap createGraphs(QCustomPlot& plot, int nbGraphs)
{
    PlottablesMap result {};

    // Creates {nbGraphs} QCPGraph to add to the plot
    for (auto i = 0; i < nbGraphs; ++i)
    {
        auto graph = plot.addGraph();
        result.insert({ i, graph });
    }

    plot.replot();

    return result;
}

/**
 * Specialization of PlottablesCreator for scalars
 * @sa ScalarSeries
 */
template <typename T>
struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<ScalarTimeSerie, T>::value>>
{
    static PlottablesMap createPlottables(QCustomPlot& plot, const std::shared_ptr<T>& dataSeries)
    {
        return createGraphs(plot, 1);
    }
};

/**
 * Specialization of PlottablesCreator for vectors
 * @sa VectorSeries
 */
template <typename T>
struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<VectorTimeSerie, T>::value>>
{
    static PlottablesMap createPlottables(QCustomPlot& plot, const std::shared_ptr<T>& dataSeries)
    {
        return createGraphs(plot, 3);
    }
};

/**
 * Specialization of PlottablesCreator for MultiComponentTimeSeries
 * @sa VectorSeries
 */
template <typename T>
struct PlottablesCreator<T,
    typename std::enable_if_t<std::is_base_of<MultiComponentTimeSerie, T>::value>>
{
    static PlottablesMap createPlottables(QCustomPlot& plot, const std::shared_ptr<T>& dataSeries)
    {
        return createGraphs(plot, dataSeries->size(1));
    }
};

/**
 * Specialization of PlottablesCreator for spectrograms
 * @sa SpectrogramSeries
 */
template <typename T>
struct PlottablesCreator<T,
    typename std::enable_if_t<std::is_base_of<SpectrogramTimeSerie, T>::value>>
{
    static PlottablesMap createPlottables(QCustomPlot& plot, const std::shared_ptr<T>& dataSeries)
    {
        PlottablesMap result {};
        result.insert({ 0, new QCPColorMap { plot.xAxis, plot.yAxis } });

        plot.replot();

        return result;
    }
};

/**
 * Struct used to update plottables, depending on the type of the data series from which to update
 * them
 * @tparam T the data series' type
 * @remarks Default implementation can't update plottables
 */
template <typename T, typename Enabled = void>
struct PlottablesUpdater
{
    static void setPlotYAxisRange(T&, const DateTimeRange&, QCustomPlot&)
    {
        qCCritical(LOG_VisualizationGraphHelper())
            << QObject::tr("Can't set plot y-axis range: unmanaged data series type");
    }

    static void updatePlottables(T&, PlottablesMap&, const DateTimeRange&, bool)
    {
        qCCritical(LOG_VisualizationGraphHelper())
            << QObject::tr("Can't update plottables: unmanaged data series type");
    }
};

/**
 * Specialization of PlottablesUpdater for scalars and vectors
 * @sa ScalarSeries
 * @sa VectorSeries
 */
template <typename T>
struct PlottablesUpdater<T, typename std::enable_if_t<std::is_base_of<ScalarTimeSerie, T>::value>>
{
    static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
    {
        auto minValue = 0., maxValue = 0.;
        if (auto serie = dynamic_cast<ScalarTimeSerie*>(&dataSeries))
        {
            if (serie->size())
            {
                maxValue = (*std::max_element(std::begin(*serie), std::end(*serie))).v();
                minValue = (*std::min_element(std::begin(*serie), std::end(*serie))).v();
            }
        }
        plot.yAxis->setRange(QCPRange { minValue, maxValue });
    }

    static void updatePlottables(
        T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
    {

        // For each plottable to update, resets its data
        for (const auto& plottable : plottables)
        {
            if (auto graph = dynamic_cast<QCPGraph*>(plottable.second))
            {
                auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                if (auto serie = dynamic_cast<ScalarTimeSerie*>(&dataSeries))
                {
                    std::for_each(
                        std::begin(*serie), std::end(*serie), [&dataContainer](const auto& value) {
                            dataContainer->appendGraphData(QCPGraphData(value.t(), value.v()));
                        });
                }
                graph->setData(dataContainer);
            }
        }

        if (!plottables.empty())
        {
            auto plot = plottables.begin()->second->parentPlot();

            if (rescaleAxes)
            {
                plot->rescaleAxes();
            }
        }
    }
};


template <typename T>
struct PlottablesUpdater<T, typename std::enable_if_t<std::is_base_of<VectorTimeSerie, T>::value>>
{
    static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
    {
        double minValue = 0., maxValue = 0.;
        if (auto serie = dynamic_cast<VectorTimeSerie*>(&dataSeries))
        {
            std::for_each(
                std::begin(*serie), std::end(*serie), [&minValue, &maxValue](const auto& v) {
                    minValue = std::min({ minValue, v.v().x, v.v().y, v.v().z });
                    maxValue = std::max({ maxValue, v.v().x, v.v().y, v.v().z });
                });
        }

        plot.yAxis->setRange(QCPRange { minValue, maxValue });
    }

    static void updatePlottables(
        T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
    {

        // For each plottable to update, resets its data
        for (const auto& plottable : plottables)
        {
            if (auto graph = dynamic_cast<QCPGraph*>(plottable.second))
            {
                auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                if (auto serie = dynamic_cast<VectorTimeSerie*>(&dataSeries))
                {
                    switch (plottable.first)
                    {
                        case 0:
                            std::for_each(std::begin(*serie), std::end(*serie),
                                [&dataContainer](const auto& value) {
                                    dataContainer->appendGraphData(
                                        QCPGraphData(value.t(), value.v().x));
                                });
                            break;
                        case 1:
                            std::for_each(std::begin(*serie), std::end(*serie),
                                [&dataContainer](const auto& value) {
                                    dataContainer->appendGraphData(
                                        QCPGraphData(value.t(), value.v().y));
                                });
                            break;
                        case 2:
                            std::for_each(std::begin(*serie), std::end(*serie),
                                [&dataContainer](const auto& value) {
                                    dataContainer->appendGraphData(
                                        QCPGraphData(value.t(), value.v().z));
                                });
                            break;
                        default:
                            break;
                    }
                }
                graph->setData(dataContainer);
            }
        }

        if (!plottables.empty())
        {
            auto plot = plottables.begin()->second->parentPlot();

            if (rescaleAxes)
            {
                plot->rescaleAxes();
            }
        }
    }
};


template <typename T>
struct PlottablesUpdater<T,
    typename std::enable_if_t<std::is_base_of<MultiComponentTimeSerie, T>::value>>
{
    static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
    {
        double minValue = 0., maxValue = 0.;
        if (auto serie = dynamic_cast<MultiComponentTimeSerie*>(&dataSeries))
        {
            std::for_each(std::begin(*serie), std::end(*serie), [&minValue, &maxValue](auto& v) {
                minValue = std::min(minValue, std::min_element(v.begin(), v.end())->v());
                maxValue = std::max(maxValue, std::max_element(v.begin(), v.end())->v());
            });
        }
        plot.yAxis->setRange(QCPRange { minValue, maxValue });
    }

    static void updatePlottables(
        T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
    {
        for (const auto& plottable : plottables)
        {
            if (auto graph = dynamic_cast<QCPGraph*>(plottable.second))
            {
                auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                if (auto serie = dynamic_cast<MultiComponentTimeSerie*>(&dataSeries))
                {
                    // TODO
                    std::for_each(std::begin(*serie), std::end(*serie),
                        [&dataContainer, component = plottable.first](const auto& value) {
                            dataContainer->appendGraphData(
                                QCPGraphData(value.t(), value[component]));
                        });
                }
                graph->setData(dataContainer);
            }
        }

        if (!plottables.empty())
        {
            auto plot = plottables.begin()->second->parentPlot();

            if (rescaleAxes)
            {
                plot->rescaleAxes();
            }
        }
    }
};

/*=============================================================*/
// TODO move this to dedicated srcs
/*=============================================================*/
struct ColomapProperties
{
    int h_size_px;
    int v_size_px;
    double h_resolutuon;
    double v_resolutuon;
};

inline ColomapProperties CMAxisAnalysis(const TimeSeriesUtils::axis_properties& xAxisProperties,
    const TimeSeriesUtils::axis_properties& yAxisProperties)
{
    int colormap_h_size
        = std::min(32000, static_cast<int>(xAxisProperties.range / xAxisProperties.max_resolution));
    int colormap_v_size = static_cast<int>(yAxisProperties.range / yAxisProperties.max_resolution);
    double colormap_h_resolution = xAxisProperties.range / static_cast<double>(colormap_h_size);
    double colormap_v_resolution = yAxisProperties.range / static_cast<double>(colormap_v_size);
    return ColomapProperties { colormap_h_size, colormap_v_size, colormap_h_resolution,
        colormap_v_resolution };
}


template <bool condition, typename T, typename U>
std::enable_if_t<condition, T> constexpr conditional_v(T first, U second)
{
    return first;
}

template <bool condition, typename T, typename U>
std::enable_if_t<!condition, U> constexpr conditional_v(T first, U second)
{
    return second;
}

template <bool reversedAxis = true, bool reversedData = true>
inline std::vector<std::pair<int, int>> build_access_pattern(const std::vector<double>& axis,
    const TimeSeriesUtils::axis_properties& axisProperties,
    const ColomapProperties& colormap_properties)
{
    std::vector<std::pair<int, int>> access_pattern;
    for (int index = 0, axis_index = conditional_v<reversedAxis>(axis.size() - 1, 0),
             data_index = conditional_v<reversedData>(axis.size() - 1, 0);
         index < colormap_properties.v_size_px; index++)
    {
        double current_y = (axisProperties.max_resolution * index) + axisProperties.min;
        if (current_y > axis[axis_index])
        {
            conditional_v<reversedAxis>(
                [&axis_index]() { axis_index--; }, [&axis_index]() { axis_index++; })();
            conditional_v<reversedData>(
                [&data_index]() { data_index--; }, [&data_index]() { data_index++; })();
        }
        access_pattern.push_back({ index, data_index });
    }
    return access_pattern;
}

inline bool is_log(const std::vector<double>& axis)
{
    if (axis.size() > 2)
    {
        auto first = axis.front(), midle = axis[axis.size() / 2], last = axis.back();
        auto error_linear = (midle - (last + first) / 2) / midle;
        first = log10(first);
        midle = log10(midle);
        last = log10(last);
        auto error_log = (midle - (last + first) / 2) / midle;
        return error_log < error_linear;
    }
    return false;
}

template <typename accessPattern_t, typename colomapT, typename axProp_t, typename cmProp_t>
inline void fill_data(SpectrogramTimeSerie* serie, colomapT* colormap,
    const accessPattern_t& y_access_pattern, const axProp_t& xAxisProperties,
    const cmProp_t& colormap_properties)
{
    auto line = serie->begin();
    auto next_line = line + 1;
    double current_time = xAxisProperties.min;
    int x_index = 0;
    auto x_min_resolution
        = std::fmin(2. * serie->max_sampling, xAxisProperties.max_resolution * 100.);
    std::vector<double> line_values(serie->size(1));
    double avg_coef = 0.;
    while (x_index < colormap_properties.h_size_px)
    {
        if (next_line != std::end(*serie) and current_time >= next_line->t())
        {
            line = next_line;
            next_line++;
        }
        if ((current_time - xAxisProperties.min)
            > (static_cast<double>(x_index + 1) * colormap_properties.h_resolutuon))
        {
            std::for_each(std::cbegin(y_access_pattern), std::cend(y_access_pattern),
                [&colormap, &line_values, x_index, avg_coef](const auto& acc) {
                    colormap->data()->setCell(
                        x_index, acc.first, line_values[acc.second] / avg_coef);
                });
            std::fill(std::begin(line_values), std::end(line_values), 0.);
            x_index++;
            avg_coef = 0.;
        }
        if (line->t() + x_min_resolution > current_time)
        {
            {
                std::transform(std::begin(*line), std::end(*line), std::cbegin(line_values),
                    std::begin(line_values),
                    [](const auto& input, auto output) { return input.v() + output; });
            }
            avg_coef += 1.;
        }
        else
        {
            for (int y_index = 0; y_index < colormap_properties.v_size_px; y_index++)
            {
                if (avg_coef > 0.)
                {
                    std::fill(std::begin(line_values), std::end(line_values), 0);
                }
            }
        }
        current_time += xAxisProperties.max_resolution * 0.9;
    }
}

/*=============================================================*/

/**
 * Specialization of PlottablesUpdater for spectrograms
 * @sa SpectrogramSeries
 */
template <typename T>
struct PlottablesUpdater<T,
    typename std::enable_if_t<std::is_base_of<SpectrogramTimeSerie, T>::value>>
{
    static void setPlotYAxisRange(T& dataSeries, const DateTimeRange& xAxisRange, QCustomPlot& plot)
    {
        auto [minValue, maxValue] = dataSeries.axis_range(1);
        plot.yAxis->setRange(QCPRange { minValue, maxValue });
    }

    static void updatePlottables(
        T& dataSeries, PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes)
    {
        if (plottables.empty())
        {
            qCDebug(LOG_VisualizationGraphHelper())
                << QObject::tr("Can't update spectrogram: no colormap has been associated");
            return;
        }

        // Gets the colormap to update (normally there is only one colormap)
        Q_ASSERT(plottables.size() == 1);
        auto colormap = dynamic_cast<QCPColorMap*>(plottables.at(0));
        Q_ASSERT(colormap != nullptr);
        auto plot = colormap->parentPlot();
        auto [minValue, maxValue] = dataSeries.axis_range(1);
        plot->yAxis->setRange(QCPRange { minValue, maxValue });
        if (auto serie = dynamic_cast<SpectrogramTimeSerie*>(&dataSeries))
        {
            if (serie->size(0) > 2)
            {
                if (serie->y_is_log)
                    colormap->setDataScaleType(QCPAxis::stLogarithmic);
                else
                    colormap->setDataScaleType(QCPAxis::stLinear);
                const auto& xAxis = serie->axis(0);
                auto yAxis = serie->axis(1); // copy for in place reverse order
                auto y_is_log = is_log(yAxis);
                std::reverse(std::begin(yAxis), std::end(yAxis));
                auto xAxisProperties = TimeSeriesUtils::axis_analysis<TimeSeriesUtils::IsLinear,
                    TimeSeriesUtils::CheckMedian>(xAxis, serie->min_sampling);
                auto yAxisProperties = TimeSeriesUtils::axis_analysis<TimeSeriesUtils::IsLog,
                    TimeSeriesUtils::DontCheckMedian>(yAxis);
                auto colormap_properties = CMAxisAnalysis(xAxisProperties, yAxisProperties);

                colormap->data()->setSize(
                    colormap_properties.h_size_px, colormap_properties.v_size_px);
                colormap->data()->setRange(
                    QCPRange { xAxisProperties.min, xAxisProperties.max }, { minValue, maxValue });

                auto y_access_pattern = build_access_pattern<false, true>(
                    yAxis, yAxisProperties, colormap_properties);
                fill_data(serie, colormap, y_access_pattern, xAxisProperties, colormap_properties);
            }
            colormap->rescaleDataRange(true);
            if (rescaleAxes)
            {
                plot->rescaleAxes();
            }
        }
    }
};

/**
 * Helper used to create/update plottables
 */
struct IPlottablesHelper
{
    virtual ~IPlottablesHelper() noexcept = default;
    virtual PlottablesMap create(QCustomPlot& plot) const = 0;
    virtual void setYAxisRange(const DateTimeRange& xAxisRange, QCustomPlot& plot) const = 0;
    virtual void update(
        PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes = false) const = 0;
};

/**
 * Default implementation of IPlottablesHelper, which takes data series to create/update
 * plottables
 * @tparam T the data series' type
 */
template <typename T>
struct PlottablesHelper : public IPlottablesHelper
{
    explicit PlottablesHelper(std::shared_ptr<T> dataSeries) : m_DataSeries { dataSeries } {}

    PlottablesMap create(QCustomPlot& plot) const override
    {
        return PlottablesCreator<T>::createPlottables(plot, m_DataSeries);
    }

    void update(
        PlottablesMap& plottables, const DateTimeRange& range, bool rescaleAxes) const override
    {
        if (m_DataSeries)
        {
            PlottablesUpdater<T>::updatePlottables(*m_DataSeries, plottables, range, rescaleAxes);
        }
        else
        {
            qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "
                                                          "between the type of data series and the "
                                                          "type supposed";
        }
    }

    void setYAxisRange(const DateTimeRange& xAxisRange, QCustomPlot& plot) const override
    {
        if (m_DataSeries)
        {
            PlottablesUpdater<T>::setPlotYAxisRange(*m_DataSeries, xAxisRange, plot);
        }
        else
        {
            qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "
                                                          "between the type of data series and the "
                                                          "type supposed";
        }
    }

    std::shared_ptr<T> m_DataSeries;
};

/// Creates IPlottablesHelper according to the type of data series a variable holds
std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<Variable2> variable) noexcept
{
    switch (variable->type())
    {
        case DataSeriesType::SCALAR:
            return std::make_unique<PlottablesHelper<ScalarTimeSerie>>(
                std::dynamic_pointer_cast<ScalarTimeSerie>(variable->data()));
        case DataSeriesType::SPECTROGRAM:
            return std::make_unique<PlottablesHelper<SpectrogramTimeSerie>>(
                std::dynamic_pointer_cast<SpectrogramTimeSerie>(variable->data()));
        case DataSeriesType::VECTOR:
            return std::make_unique<PlottablesHelper<VectorTimeSerie>>(
                std::dynamic_pointer_cast<VectorTimeSerie>(variable->data()));
        case DataSeriesType::MULTICOMPONENT:
            return std::make_unique<PlottablesHelper<MultiComponentTimeSerie>>(
                std::dynamic_pointer_cast<MultiComponentTimeSerie>(variable->data()));
        default:
            // Creates default helper
            break;
    }

    return std::make_unique<PlottablesHelper<TimeSeries::ITimeSerie>>(nullptr);
}

} // namespace

PlottablesMap VisualizationGraphHelper::create(
    std::shared_ptr<Variable2> variable, QCustomPlot& plot) noexcept
{
    if (variable)
    {
        auto helper = createHelper(variable);
        auto plottables = helper->create(plot);
        return plottables;
    }
    else
    {
        qCDebug(LOG_VisualizationGraphHelper())
            << QObject::tr("Can't create graph plottables : the variable is null");
        return PlottablesMap {};
    }
}

void VisualizationGraphHelper::setYAxisRange(
    std::shared_ptr<Variable2> variable, QCustomPlot& plot) noexcept
{
    if (variable)
    {
        auto helper = createHelper(variable);
        helper->setYAxisRange(variable->range(), plot);
    }
    else
    {
        qCDebug(LOG_VisualizationGraphHelper())
            << QObject::tr("Can't set y-axis range of plot: the variable is null");
    }
}

void VisualizationGraphHelper::updateData(
    PlottablesMap& plottables, std::shared_ptr<Variable2> variable, const DateTimeRange& dateTime)
{
    auto helper = createHelper(variable);
    helper->update(plottables, dateTime);
}