Dynamische Szenen mit Zigbee2MQTT, OpenHAB, Hue und anderen Leuchtmitteln

/**
 * Lightshow Automation for openHAB (JS Scripting Edition)
 */
const { rules, triggers, items, time } = require("openhab");

// Global state storage (replaces the global maps)
// cache.private stores data only within this script, but keeps it between executions.
const CACHE = cache.private; 

// Initialization of storage structures, if not already present
if (!CACHE.get("activeTimers")) CACHE.put("activeTimers", {});
if (!CACHE.get("colors")) CACHE.put("colors", {});

// Constants
const NEUTRAL_WHITE = '{"brightness":254,"color":{"hue":31,"saturation":84,"x":0.4682,"y":0.4123},"color_mode":"color_temp","color_temp":384,"state":"ON"}';

// --- HELPER FUNCTIONS ---

/**
 * Calculates the speed factor based on the dimmer value.
 * Logic: 10 * exp(-0.04605 * value)
 */
function getSpeedFactor(speedItem) {
  if (!speedItem || speedItem.state === "NULL" || speedItem.state === "UNDEF") {
    return 1.0;
  }
  const val = parseFloat(speedItem.state);
  return 10 * Math.exp(-0.04605 * val);
}

/**
 * Stops all running animations for a group.
 * Important: Replaces the "break conditions" and Thread::sleep loops from the DSL.
 */
function stopAnimation(groupName) {
  const timers = CACHE.get("activeTimers");
  
  if (timers[groupName]) {
    // It can be individual timers or arrays of timers (for individual modes)
    if (Array.isArray(timers[groupName])) {
      timers[groupName].forEach(id => clearTimeout(id));
    } else {
      clearTimeout(timers[groupName]);
    }
    delete timers[groupName];
  }
}

/**
 * Saves a timer handle to be able to cancel it later.
 */
function registerTimer(groupName, timerId, isArray = false) {
  const timers = CACHE.get("activeTimers");
  if (isArray) {
    if (!timers[groupName] || !Array.isArray(timers[groupName])) {
      timers[groupName] = [];
    }
    timers[groupName].push(timerId);
  } else {
    timers[groupName] = timerId;
  }
}


// --- MAIN RULE: Lightshow ---
rules.JSRule({
  name: "Lightshow Logic",
  description: "Steuert komplexe Licht-Szenen und Effekte",
  triggers: [triggers.GroupStateChangeTrigger("tgLightshow")],
  execute: (event) => {
    const triggeringItem = items.getItem(event.itemName);
    const newState = event.newState;
    
    // 1. Identify group
    // Searches for group names starting with "ig"
    const bulbGroupName = triggeringItem.groupNames.find(g => g.startsWith("ig"));
    if (!bulbGroupName) return; // No matching group found

    const bulbGroup = items.getItem(bulbGroupName);

    // 2. Stop existing animations for this group (Clean slate)
    stopAnimation(bulbGroupName);

    // If the new state is "NORMAL" or "OFF", we stop here (timers are already stopped)
    if (newState === "NORMAL" || newState === "OFF" || newState === "NULL" || newState === "UNDEF") {
      return;
    }

    // 3. Get items
    const members = bulbGroup.members;
    const interfaceItem = members.find(i => i.tags.includes("Control") && i.tags.includes("Interface"));
    const speedItem = members.find(i => i.tags.includes("Control") && i.tags.includes("DynamicSpeed"));
    
    // Safety check
    if (!interfaceItem) {
      console.warn(`Lightshow: Kein Interface-Item in Gruppe ${bulbGroupName} gefunden.`);
      return;
    }

    // 4. Scene logic
    // We define recursive functions for the loops.
    
    // === SCENES ===
    if (newState === "GD_SCENES") {
      // Define list (excerpt, rest can easily be added)
      let gradientList = [
        ["0000FF", "0000FF", "0000FF", "FF0000", "FF0000", "FF0000", "FF0000", "0000FF", "0000FF"], // blue-red
        ["FFFF00", "FFFF00", "FFFF00", "FFFF00", "00FF00", "00FF00", "FFFF00", "FFFF00", "FFFF00"], // green-yellow
        ["FF0000", "FF0000", "FF0000", "FFFFFF", "FFFFFF", "FFFFFF", "FF0000", "FF0000", "FF0000"], // red-white
        ["00FFFF", "00FFFF", "00FFFF", "FF00FF", "FF00FF", "FF00FF", "FF00FF", "00FFFF", "00FFFF"], // Cyberpunk
        ["000000", "000000", "000000", "00FF00", "00FF00", "00FF00", "00FF00", "000000", "000000"], // Matrix
        // ... insert more arrays here ...
      ];

      const runScene = () => {
        // Rotation of the list: First element to the end
        const currentGradient = gradientList.shift();
        gradientList.push(currentGradient);

        const speed = getSpeedFactor(speedItem);
        const sleepTime = Math.floor(60000 * speed);

        const gradientJson = JSON.stringify({ gradient: currentGradient });
        interfaceItem.sendCommand(gradientJson);

        // Plan next step
        const tId = setTimeout(runScene, sleepTime);
        registerTimer(bulbGroupName, tId);
      };
      
      runScene(); // Start
    }

    // === FLOATING ===
    else if (newState === "GD_FLOATING") {
      let colors = ["0000FF","0000FF","0000FF","FF0000","FF0000","FF0000","FF0000","0000FF","0000FF"];
      
      const runFloating = () => {
        const speed = getSpeedFactor(speedItem);
        const sleepTime = Math.floor(4000 * speed);
        const transition = Math.floor(3000 * speed);

        const json = JSON.stringify({ 
            gradient: colors, 
            transition: transition 
        });
        interfaceItem.sendCommand(json);

        // Rotate colors
        colors.push(colors.shift());

        const tId = setTimeout(runFloating, sleepTime);
        registerTimer(bulbGroupName, tId);
      };
      runFloating();
    }

    // === THUNDERSTORM ===
    else if (newState === "THUNDERSTORM") {
      const lightCmdStandby = JSON.stringify({brightness_percent: 40, transition: 0});
      interfaceItem.sendCommand(lightCmdStandby);

      const runThunder = () => {
        const speed = getSpeedFactor(speedItem);
        const sleepTime = Math.floor(1000 * speed);
        const randomVal = Math.random();

        // Lightning logic
        if (randomVal > 0.95) {
          interfaceItem.sendCommand(JSON.stringify({brightness_percent: 100, transition: 0}));
          setTimeout(() => interfaceItem.sendCommand(lightCmdStandby), 20); // Short lightning
        } else if (randomVal > 0.9) {
          // Double lightning
          interfaceItem.sendCommand(JSON.stringify({brightness_percent: 60, transition: 0}));
          setTimeout(() => {
             interfaceItem.sendCommand(lightCmdStandby);
             setTimeout(() => {
                interfaceItem.sendCommand(JSON.stringify({brightness_percent: 60, transition: 0}));
                setTimeout(() => interfaceItem.sendCommand(lightCmdStandby), 20);
             }, 100);
          }, 20);
        } else {
            // Ensure base light is on (in case packets were lost)
            interfaceItem.sendCommand(lightCmdStandby);
        }

        const tId = setTimeout(runThunder, sleepTime);
        registerTimer(bulbGroupName, tId);
      };
      runThunder();
    }

    // === ALARM ===
    else if (newState === "ALARM") {
      let stateToggle = true; // true = red, false = dark red
      
      const runAlarm = () => {
        if (stateToggle) {
            interfaceItem.sendCommand(JSON.stringify({color: {hsb: "18,100,100"}, transition: 1}));
        } else {
            interfaceItem.sendCommand(JSON.stringify({color: {hsb: "18,100,30"}, transition: 1}));
        }
        stateToggle = !stateToggle;

        const tId = setTimeout(runAlarm, 1500); // Sleep was 1400 + 100 Loop
        registerTimer(bulbGroupName, tId);
      };
      runAlarm();
    }

    // === REG_PULSATE ===
    else if (newState === "REG_PULSATE") {
      let stateToggle = false; 

      const runPulsate = () => {
        const speed = getSpeedFactor(speedItem);
        const transition = 3.0 * speed;
        const sleepTime = Math.floor(transition * 1000) + 200; // sleep + buffer

        if (!stateToggle) {
             interfaceItem.sendCommand(JSON.stringify({brightness_percent: 20, transition: transition}));
        } else {
             interfaceItem.sendCommand(JSON.stringify({brightness_percent: 100, transition: transition}));
        }
        stateToggle = !stateToggle;

        const tId = setTimeout(runPulsate, sleepTime);
        registerTimer(bulbGroupName, tId);
      };
      runPulsate();
    }

    // === UNREG_PULSATE ===
    else if (newState === "UNREG_PULSATE") {
        let stateToggle = false;
        
        const runUnregPulsate = () => {
            const speed = getSpeedFactor(speedItem);
            
            if (!stateToggle) {
                // Dim down phase
                const transition = (0.5 + Math.random() * 5.0) * speed;
                const sleepTime = Math.floor(transition * 1000) + 500;
                interfaceItem.sendCommand(JSON.stringify({brightness_percent: 20, transition: transition}));
                stateToggle = true;
                const tId = setTimeout(runUnregPulsate, sleepTime);
                registerTimer(bulbGroupName, tId);
            } else {
                // Dim up phase
                // Here transition was reused, but recalculated in the original loop? 
                // In the original DSL, transition is calculated at the beginning of the loop and used for both phases.
                // But sleep is recalculated for the Up-Phase.
                
                // We recalculate here to be close to the original, or cache the transition.
                // Simplification: Recalculate for dynamics
                const transition = (0.5 + Math.random() * 5.0) * speed; 
                const sleepTime = Math.floor((500 + Math.random() * 5000.0) * speed) + 500;
                
                interfaceItem.sendCommand(JSON.stringify({brightness_percent: 100, transition: transition}));
                stateToggle = false;
                const tId = setTimeout(runUnregPulsate, sleepTime);
                registerTimer(bulbGroupName, tId);
            }
        };
        runUnregPulsate();
    }
    
    // === CANDLE ===
    else if (newState === "CANDLE") {
        interfaceItem.sendCommand('{"color":{"h":30,"s":100},"brightness_percent":100,"transition":0.1}');
        
        const runCandle = () => {
            const speed = getSpeedFactor(speedItem); // Optional, was commented out in the original, but used here in formulas
            
            // High Phase
            const hi_sleep = Math.floor((100.0 + Math.random() * 40.0) * speed);
            const hi_power = Math.floor(60.0 + Math.random() * 22.0);
            
            interfaceItem.sendCommand(JSON.stringify({brightness_percent: hi_power, transition: 0.1}));
            
            // We use nested timeouts for the "High then Low" sequence
            const tId = setTimeout(() => {
                // Low Phase
                const lo_sleep = Math.floor((100.0 + Math.random() * 40.0) * speed);
                const lo_power = Math.floor(50.0 + Math.random() * 10.0);
                
                interfaceItem.sendCommand(JSON.stringify({brightness_percent: lo_power, transition: 0.1}));
                
                // Next cycle after Low-Wait
                const tIdNext = setTimeout(runCandle, lo_sleep);
                registerTimer(bulbGroupName, tIdNext);
                
            }, hi_sleep);
            
            registerTimer(bulbGroupName, tId);
        };
        runCandle();
    }

    // === TV ===
    else if (newState === "TV") {
        const led_bright = "255";
        const led_half = "128";
        const led_min = "60";
        const transitions = [0.0, 0.0, 0.0, 0.0, 0.4, 0.4, 1.0, 2.0];
        const pictures = [
            `${led_half},${led_half},${led_half}`,
            `${led_min},${led_min},${led_min}`,
            `${led_bright},${led_bright},${led_half}`,
            // ... (Insert remaining combinations here) ...
            `${led_min},${led_min},${led_half}`
        ];

        const runTV = () => {
            const speed = getSpeedFactor(speedItem);
            const transition = transitions[Math.floor(Math.random() * transitions.length)];
            const sleepTime = transition + Math.floor((500 + Math.random() * 6000.0) * speed);
            const picture = pictures[Math.floor(Math.random() * pictures.length)];
            const brightness = Math.floor(Math.random() * 100);

            const json = JSON.stringify({
                color: { rgb: picture },
                brightness_percent: brightness,
                transition: transition
            });
            interfaceItem.sendCommand(json);

            const tId = setTimeout(runTV, sleepTime);
            registerTimer(bulbGroupName, tId);
        };
        runTV();
    }

    // === INDIVIDUAL CONTROL (AURORA / RANDOM) ===
    else {
        // Here it gets special: In the original, one timer per lamp is started.
        // We must use array timers here.
        
        members.forEach(entity => {
            if (entity.tags.includes("Lightbulb") && entity.tags.includes("Entity")) {
                // Set initial color for Aurora
                if (newState === "AURORA") {
                   const colorsMap = CACHE.get("colors");
                   // We just store a dummy object here or use HSB string
                   // JS has no native HSBType, we use strings or small objects
                   if (!colorsMap[bulbGroupName]) colorsMap[bulbGroupName] = {h:210, s:100, b:100};
                }
                const runIndividual = () => {
                    const speed = getSpeedFactor(speedItem);

                    if (newState === "AURORA") {
                        const colorsMap = CACHE.get("colors");
                        let baseH = 210;
                        if(colorsMap[bulbGroupName] && colorsMap[bulbGroupName].h) baseH = colorsMap[bulbGroupName].h;
                        
                        const H = (baseH + 310) % 360 + Math.floor(Math.random() * 100);
                        const B = 60 + Math.floor(Math.random() * 40);
                        const sleep = Math.floor((1000.0 + Math.random() * 5000.0) * speed);
                        const transition = sleep / 1000.0;

                        entity.sendCommand(JSON.stringify({
                            color: { hsb: `${H},100,${B}` },
                            transition: transition
                        }));

                        const tId = setTimeout(runIndividual, sleep + 500);
                        registerTimer(bulbGroupName, tId, true); // true = append to array
                    }
                    else if (newState === "RANDOM") {
                        const H = Math.floor(Math.random() * 360) + 1;
                        const sleep = Math.floor((750 + Math.random() * 1250.0) * speed);
                        const transition = sleep / 1000.0;

                        entity.sendCommand(JSON.stringify({
                            color: { hue: H },
                            transition: transition
                        }));
                        
                        const tId = setTimeout(runIndividual, sleep);
                        registerTimer(bulbGroupName, tId, true);
                    }
                };
                
                // Start the loop for this specific lamp
                // Small delay to start so they don't all start exactly at the same time (Thread::sleep(100) in the original)
                setTimeout(runIndividual, Math.random() * 100); 
            }
        });
    }
  }
});


// --- RULE: Lightshow Change ---
rules.JSRule({
  name: "Lightshow Change Color",
  triggers: [triggers.GroupCommandTrigger("tgLSchange")],
  execute: (event) => {
    const triggeringItem = items.getItem(event.itemName);
    const cmd = event.receivedCommand;
    const bulbGroupName = triggeringItem.groupNames.find(g => g.startsWith("ig"));
    
    if (bulbGroupName) {
        const colorsMap = CACHE.get("colors");
        if (cmd === "ON" || cmd === "OFF") {
             // White preset
             colorsMap[bulbGroupName] = {h:0, s:0, b:100};
        } else {
             // We assume that cmd is an HSB string "H,S,B"
             const parts = cmd.toString().split(",");
             if (parts.length === 3) {
                 colorsMap[bulbGroupName] = {
                     h: parseFloat(parts[0]),
                     s: parseFloat(parts[1]),
                     b: parseFloat(parts[2])
                 };
             }
        }
    }
  }
});


// --- RULE: Lightshow Interrupt ---
rules.JSRule({
  name: "Lightshow Interrupt",
  triggers: [triggers.GroupCommandTrigger("tgLSinterrupt")],
  execute: (event) => {
    const triggeringItem = items.getItem(event.itemName);
    const bulbGroupName = triggeringItem.groupNames.find(g => g.startsWith("ig"));
    
    if (bulbGroupName) {
        const bulbGroup = items.getItem(bulbGroupName);
        const lightshowItem = bulbGroup.members.find(i => i.tags.includes("Control") && i.tags.includes("DynamicScene"));
        if (lightshowItem) {
            lightshowItem.sendCommand("NORMAL");
        }
    }
  }
});


// --- RULE: Set Default Values ---
rules.JSRule({
  name: "Lightshow Defaults",
  triggers: [
    triggers.SystemStartlevelTrigger(100),
    //triggers.GenericCronTrigger("0 0 * * * ?"), // Hourly
    //triggers.GenericCronTrigger("0 * * * * ?")  // Every minute
  ],
  execute: (event) => {
    // Search items by tags
    // In JS Scripting we iterate over items.getItems() and filter
    items.getItems().forEach(item => {
        if (item.tags.includes("DynamicScene")) {
            if (item.state === "NULL" || item.state === "UNDEF") {
                item.sendCommand("NORMAL");
            }
        }
        if (item.tags.includes("DynamicSpeed")) {
            if (item.state === "NULL" || item.state === "UNDEF") {
                item.sendCommand("50");
            }
        }
    });
  }
});