DataGenerator.h

#ifndef PATTERNMATCHING_DATAGENERATOR_H
#define PATTERNMATCHING_DATAGENERATOR_H

#include <vector>
#include <random>
#include <cmath>


// AoS - Array of Structures
struct DatabaseAoS {
    std::vector<std::vector<double>> series;

    size_t num_series() const { return series.size(); }
    const double* get_series(size_t idx) const { return series[idx].data(); }
    size_t get_length(size_t idx) const { return series[idx].size(); }
};

// SoA - Structure of Arrays
struct DatabaseSoA {
    std::vector<double> data;
    std::vector<size_t> offsets;
    std::vector<size_t> lengths;

    size_t num_series() const { return offsets.size(); }
    const double* get_series(size_t idx) const { return &data[offsets[idx]]; }
    size_t get_length(size_t idx) const { return lengths[idx]; }
};


inline DatabaseSoA to_soa(const DatabaseAoS& aos) {
    DatabaseSoA soa;

    // Calcola dimensione totale
    size_t total = 0;
    for (const auto& s : aos.series) total += s.size();
    soa.data.reserve(total);

    for (const auto& s : aos.series) {
        soa.offsets.push_back(soa.data.size());
        soa.lengths.push_back(s.size());
        soa.data.insert(soa.data.end(), s.begin(), s.end());
    }

    return soa;
}

inline DatabaseAoS to_aos(const DatabaseSoA& soa) {
    DatabaseAoS aos;

    for (size_t i = 0; i < soa.num_series(); ++i) {
        aos.series.emplace_back(
            soa.data.begin() + soa.offsets[i],
            soa.data.begin() + soa.offsets[i] + soa.lengths[i]
        );
    }

    return aos;
}

class DataGenerator {
public:

    static DatabaseAoS generate(size_t num_series, size_t series_length, unsigned seed = 42) {
        DatabaseAoS db;
        std::mt19937 gen(seed);
        std::uniform_real_distribution<double> dist(0.0, 100.0);

        for (size_t s = 0; s < num_series; ++s) {
            std::vector<double> series(series_length);
            for (size_t i = 0; i < series_length; ++i) {
                series[i] = dist(gen);
            }
            db.series.push_back(std::move(series));
        }

        return db;
    }

    static DatabaseSoA generate_soa(size_t num_series, size_t series_length, unsigned seed = 42) {
        DatabaseAoS aos = generate(num_series, series_length, seed);
        return to_soa(aos);
    }

    static std::vector<double> generate_pattern(size_t length, unsigned seed = 123) {
        std::vector<double> pattern(length);
        std::mt19937 gen(seed);
        std::uniform_real_distribution<double> dist(0.0, 100.0);

        for (size_t i = 0; i < length; ++i) {
            pattern[i] = dist(gen);
        }

        return pattern;
    }

    // Embed pattern per test
    static void embed_pattern(DatabaseAoS& db, size_t series_idx,
                              size_t position, const std::vector<double>& pattern) {
        for (size_t i = 0; i < pattern.size(); ++i) {
            db.series[series_idx][position + i] = pattern[i];
        }
    }

    static void embed_pattern(DatabaseSoA& db, size_t series_idx,
                              size_t position, const std::vector<double>& pattern) {
        size_t start = db.offsets[series_idx] + position;
        for (size_t i = 0; i < pattern.size(); ++i) {
            db.data[start + i] = pattern[i];
        }
    }
};

#endif //PATTERNMATCHING_DATAGENERATOR_H