#ifndef SCIQLOP_DATASERIESUTILS_H
#define SCIQLOP_DATASERIESUTILS_H

#include "CoreGlobal.h"

#include <QLoggingCategory>

Q_DECLARE_LOGGING_CATEGORY(LOG_DataSeriesUtils)

/**
 * Utility class with methods for data series
 */
struct SCIQLOP_CORE_EXPORT DataSeriesUtils {
    /**
     * Processes data from a data series to complete the data holes with a fill value.
     *
     * A data hole is determined by the resolution passed in parameter: if, between two continuous
     * data on the x-axis, the difference between these data is greater than the resolution, then
     * there is one or more holes between them. The holes are filled by adding:
     * - for the x-axis, new data corresponding to the 'step resolution' starting from the first
     * data;
     * - for values, a default value (fill value) for each new data added on the x-axis.
     *
     * For example, with :
     * - xAxisData =  [0,    1,    5,    7,    14  ]
     * - valuesData = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] (two components per x-axis data)
     * - fillValue = NaN
     * - and resolution = 2;
     *
     * For the x axis, we calculate as data holes: [3, 9, 11, 13]. These holes are added to the
     * x-axis data, and NaNs (two per x-axis data) are added to the values:
     * => xAxisData =  [0,    1,    3,        5,    7,    9,        11,       13,       14  ]
     * => valuesData = [0, 1, 2, 3, NaN, NaN, 4, 5, 6, 7, NaN, NaN, NaN, NaN, NaN, NaN, 8, 9]
     *
     * It is also possible to set bounds for the data series. If these bounds are defined and exceed
     * the limits of the data series, data holes are added to the series at the beginning and/or the
     * end.
     *
     * The generation of data holes at the beginning/end of the data series is performed starting
     * from the x-axis series limit and adding data holes at each 'resolution step' as long as the
     * new bound is not reached.
     *
     * For example, with :
     * - xAxisData =  [3,    4,    5,    6,    7  ]
     * - valuesData = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
     * - fillValue = NaN
     * - minBound = 0
     * - maxBound = 12
     * - and resolution = 2;
     *
     * => Starting from 3 and decreasing 2 by 2 until reaching 0 : a data hole at value 1 will be
     * added to the beginning of the series
     * => Starting from 7 and increasing 2 by 2 until reaching 12 : data holes at values 9 and 11
     * will be added to the end of the series
     *
     * So :
     * => xAxisData =  [1,        3,    4,    5,    6,    7,    9,        11      ]
     * => valuesData = [NaN, NaN, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, NaN, NaN, NaN, NaN]
     *
     * @param xAxisData the x-axis data of the data series
     * @param valuesData the values data of the data series
     * @param resolution the resoultion (on x-axis) used to determinate data holes
     * @param fillValue the fill value used for data holes in the values data
     * @param minBound the limit at which to start filling data holes for the series. If set to NaN,
     * the limit is not used
     * @param maxBound the limit at which to end filling data holes for the series. If set to NaN,
     * the limit is not used
     *
     * @remarks There is no control over the consistency between x-axis data and values data. The
     * method considers that the data is well formed (the total number of values data is a multiple
     * of the number of x-axis data)
     */
    static void fillDataHoles(std::vector<double> &xAxisData, std::vector<double> &valuesData,
                              double resolution,
                              double fillValue = std::numeric_limits<double>::quiet_NaN(),
                              double minBound = std::numeric_limits<double>::quiet_NaN(),
                              double maxBound = std::numeric_limits<double>::quiet_NaN());
};

#endif // SCIQLOP_DATASERIESUTILS_H