#include "sensor_network.h"
#include <iostream>
#include <string>
#include <limits>
#include <thread>

// Standardkonfiguration
constexpr size_t DEFAULT_NUM_SENSORS = 3;
constexpr size_t DEFAULT_NUM_ANALYSERS = 2;
constexpr int DEFAULT_RUN_TIME = 30; // Sekunden
constexpr size_t DEFAULT_BUFFER_SIZE = 8;

/**
 * Führt die Simulation mit gegebenen Parametern aus
 * @tparam N Puffergröße
 */
template<size_t N>
void run_simulation(size_t num_sensors, size_t num_analysers, int run_time) {
    SensorNetwork<N> network;
    std::cout << "\n=== Simulation gestartet ===\n"
              << "Sensoren: " << num_sensors << "\n"
              << "Analysemodule: " << num_analysers << "\n"
              << "Puffergröße: " << N << "\n"
              << "Laufzeit: " << run_time << "s\n\n";

    network.start(num_sensors, num_analysers);
    std::this_thread::sleep_for(std::chrono::seconds(run_time));
    network.stop();

    std::cout << "\n=== Simulation beendet ===\n";
}

/**
 * Liest Benutzereingabe mit Standardwert
 * @param prompt Eingabeaufforderung
 * @param default_value Standardwert bei leerer Eingabe
 * @return Eingegebener oder Standardwert
 */
size_t get_input(const std::string& prompt, size_t default_value) {
    std::cout << prompt << " [" << default_value << "]: ";
    std::string input;
    std::getline(std::cin, input);

    // Verwende Standardwert bei leerer Eingabe
    if(input.empty()) return default_value;

    // Konvertiere Eingabe
    try {
        return std::stoul(input);
    } catch(...) {
        std::cout << "Ungültige Eingabe. Verwende Standardwert: "
                  << default_value << "\n";
        return default_value;
    }
}

int main() {
    std::cout << "=== Sensornetzwerk-Simulation ===\n"
              << "(Leere Eingabe verwendet Standardwerte)\n";

    // Interaktive Konfiguration
    size_t num_sensors = get_input("Anzahl Sensoren", DEFAULT_NUM_SENSORS);
    size_t num_analysers = get_input("Anzahl Analysemodule", DEFAULT_NUM_ANALYSERS);
    int run_time = static_cast<int>(
        get_input("Laufzeit (Sekunden)", DEFAULT_RUN_TIME)
    );
    size_t buffer_size = get_input("Puffergröße", DEFAULT_BUFFER_SIZE);

    // Starte Simulation basierend auf Puffergröße
    switch(buffer_size) {
        case 8:
            run_simulation<8>(num_sensors, num_analysers, run_time);
            break;
        case 16:
            run_simulation<16>(num_sensors, num_analysers, run_time);
            break;
        case 32:
            run_simulation<32>(num_sensors, num_analysers, run_time);
            break;
        default:
            std::cout << "Nicht unterstützte Puffergröße. Verwende Standard ("
                      << DEFAULT_BUFFER_SIZE << ")\n";
            run_simulation<DEFAULT_BUFFER_SIZE>(
                num_sensors, num_analysers, run_time
            );
    }

    std::cout << "Simulation erfolgreich abgeschlossen.\n";
    return 0;
}