#include "sensor_network.h"
#include <iostream>
#include <random>
#include <chrono>

/**
 * Startet das Sensornetzwerk
 * @param sensors Anzahl der Sensor-Threads
 * @param analysers Anzahl der Analyse-Threads
 */
template <size_t N>
void SensorNetwork<N>::start(size_t sensors, size_t analysers) {
    running = true;
    
    // Sensor-Threads erstellen
    for (size_t i = 0; i < sensors; ++i) {
        threads.emplace_back([this] {
            std::mt19937 gen(std::random_device{}());
            std::uniform_int_distribution<> dist(0, 100);
            
            while (running) {
                // Zufälliges Intervall (100-500ms)
                std::this_thread::sleep_for(
                    std::chrono::milliseconds(100 + gen() % 400));
                
                // Messwert generieren und speichern
                buffer.push(dist(gen));
            }
        });
    }

    // Analyse-Threads erstellen
    for (size_t i = 0; i < analysers; ++i) {
        threads.emplace_back([this] {
            while (running) {
                // Daten aus Puffer lesen
                int data = buffer.pop();
                
                // Analysemodell lesen
                int model_val = model.read();
                
                // Ausgabe (könnte auch analysieren)
                std::cout << "Data: " << data 
                          << " Model: " << model_val << "\n";
            }
        });
    }

    // Controller-Thread erstellen
    threads.emplace_back([this] {
        std::mt19937 gen(std::random_device{}());
        while (running) {
            // Zufälliges Update-Intervall (500-2000ms)
            std::this_thread::sleep_for(
                std::chrono::milliseconds(500 + gen() % 1500));
            
            // Analysemodell aktualisieren
            model.write(gen() % 100);
        }
    });
}

/**
 * Stoppt das Sensornetzwerk und wartet auf Threads
 */
template <size_t N>
void SensorNetwork<N>::stop() {
    running = false;  // Signal zum Stoppen
    
    // Auf alle Threads warten
    for (auto& t : threads) {
        if (t.joinable()) t.join();
    }
}

// Explizite Instanziierungen für gängige Puffergrößen
template class SensorNetwork<8>;
template class SensorNetwork<16>;
template class SensorNetwork<32>;