// =========================================================
// ARRAY MATH (Mathematische Auswertungen für Tabellen)
// =========================================================

Blockly.defineBlocksWithJsonArray([
    // 1. Summe aller Werte
    {
        "type": "array_sum",
        "message0": "➕ Summe aller Werte in Tabelle: %1",
        "args0": [
            {"type": "field_input", "name": "ARRAY_NAME", "text": "MeineWerte"}
        ],
        "output": "Number",
        "colour": 315,
        "tooltip": "Addiert alle Elemente der Tabelle auf."
    },
    // 2. Suchen & Ersetzen
    {
        "type": "array_replace",
        "message0": "🔄 In Tabelle: %1 ersetze Wert %2 durch %3",
        "args0": [
            {"type": "field_input", "name": "ARRAY_NAME", "text": "MeineWerte"},
            {"type": "input_value", "name": "OLD_VAL"},
            {"type": "input_value", "name": "NEW_VAL"}
        ],
        "previousStatement": null,
        "nextStatement": null,
        "colour": 315,
        "tooltip": "Sucht einen bestimmten Wert und ersetzt ihn durch einen neuen."
    },
    // 3. Skalieren & Offset (Mathe auf alle anwenden)
    {
        "type": "array_scale_offset",
        "message0": "📈 Tabelle: %1 verändern ➔ (Wert * %2) + %3",
        "args0": [
            {"type": "field_input", "name": "ARRAY_NAME", "text": "MeineWerte"},
            {"type": "input_value", "name": "FAKTOR"},
            {"type": "input_value", "name": "OFFSET"}
        ],
        "previousStatement": null,
        "nextStatement": null,
        "colour": 315,
        "tooltip": "Wendet Faktor und Offset auf jedes einzelne Element der Tabelle an."
    },
    // 4. Zählen nach Bedingung
    {
        "type": "array_count_cond",
        "message0": "🔢 In Tabelle: %1 zähle Werte %2 %3",
        "args0": [
            {"type": "field_input", "name": "ARRAY_NAME", "text": "MeineWerte"},
            {"type": "field_dropdown", "name": "OP", "options": [
                [">", ">"],
                ["<", "<"],
                ["==", "=="],
                [">=", ">="],
                ["<=", "<="]
            ]},
            {"type": "input_value", "name": "THRESH"}
        ],
        "output": "Number",
        "colour": 315,
        "tooltip": "Zählt, wie oft ein Schwellenwert über/unterschritten wird."
    }
]);

// --- GENERATOREN ---

ArduinoGenerator.forBlock['array_sum'] = function(block) {
    const name = block.getFieldValue('ARRAY_NAME').replace(/[^a-zA-Z0-9_]/g, '');
    
    ArduinoGenerator.globals_.add(`
template <typename T, size_t N>
T arr_sum(T (&arr)[N]) {
  T total = 0;
  for(size_t i = 0; i < N; i++) total += arr[i];
  return total;
}`);
    return [`arr_sum(${name})`, 0];
};

ArduinoGenerator.forBlock['array_replace'] = function(block) {
    const name = block.getFieldValue('ARRAY_NAME').replace(/[^a-zA-Z0-9_]/g, '');
    const oldVal = ArduinoGenerator.valueToCode(block, 'OLD_VAL', 0) || '0';
    const newVal = ArduinoGenerator.valueToCode(block, 'NEW_VAL', 0) || '0';
    
    ArduinoGenerator.globals_.add(`
template <typename T, size_t N>
void arr_replace(T (&arr)[N], T oldV, T newV) {
  for(size_t i = 0; i < N; i++) {
    if(arr[i] == oldV) arr[i] = newV;
  }
}`);
    return `  arr_replace(${name}, (decltype(${name}[0]))${oldVal}, (decltype(${name}[0]))${newVal});\n`;
};

ArduinoGenerator.forBlock['array_scale_offset'] = function(block) {
    const name = block.getFieldValue('ARRAY_NAME').replace(/[^a-zA-Z0-9_]/g, '');
    const factor = ArduinoGenerator.valueToCode(block, 'FAKTOR', 0) || '1';
    const offset = ArduinoGenerator.valueToCode(block, 'OFFSET', 0) || '0';
    
    ArduinoGenerator.globals_.add(`
template <typename T, size_t N>
void arr_scale(T (&arr)[N], float factor, float offset) {
  for(size_t i = 0; i < N; i++) {
    arr[i] = (arr[i] * factor) + offset;
  }
}`);
    return `  arr_scale(${name}, ${factor}, ${offset});\n`;
};

ArduinoGenerator.forBlock['array_count_cond'] = function(block) {
    const name = block.getFieldValue('ARRAY_NAME').replace(/[^a-zA-Z0-9_]/g, '');
    const op = block.getFieldValue('OP');
    const thresh = ArduinoGenerator.valueToCode(block, 'THRESH', 0) || '0';
    
    // Da wir in C++ die Vergleichsoperatoren nicht als String übergeben können,
    // lösen wir das direkt im generierten Code über eine kleine inline for-Schleife.
    // Das spart uns ein extrem komplexes Template mit Funktionszeigern.
    
    // Wir erzeugen eine eindeutige Zähler-Variable für diesen Aufruf
    const counterVar = `cnt_${name}_${Math.floor(Math.random() * 10000)}`;
    
    const code = `([&]() -> int {
    int ${counterVar} = 0;
    for(size_t i = 0; i < (sizeof(${name})/sizeof(${name}[0])); i++) {
      if(${name}[i] ${op} ${thresh}) ${counterVar}++;
    }
    return ${counterVar};
  })()`;
    
    return [code, 0]; // Lambda-Aufruf, der sofort ausgeführt wird und int zurückgibt
};