Implemented grace period for toggle logic. (#233)

DevJasperNL · web-flow · commit 0bfa4cb72ca3 · 2026-06-08T15:27:21.000+02:00
* Cleanup casts

* Implemented LastChangedUtc and LastUpdatedUtc in ILight

* Implemented grace period in toggle logic.

* Fix in grace period logic.
diff --git a/src/CodeCasa.AutomationPipelines.Lights.NetDaemon/Extensions/LightTransitionPipelineConfiguratorExtensions.Scene.cs b/src/CodeCasa.AutomationPipelines.Lights.NetDaemon/Extensions/LightTransitionPipelineConfiguratorExtensions.Scene.cs
@@ -203,11 +203,11 @@ public static ILightTransitionPipelineConfigurator<NetDaemonLight> AddToggle<T>(
         IObservable<T> triggerObservable,
         params IEntityCore[] sceneEntities)
     {
-        return configurator.AddToggle(triggerObservable, (Action<ILightTransitionToggleConfigurator<NetDaemonLight>>)(c =>
+        return configurator.AddToggle(triggerObservable, c =>
         {
             foreach (var scene in sceneEntities)
                 c.AddScene(scene);
-        }));
+        });
     }
 
     // -------------------------------------------------------------------------
@@ -230,11 +230,11 @@ public static ILightTransitionPipelineConfigurator<NetDaemonLight> AddCycle<T>(
         IObservable<T> triggerObservable,
         params IEntityCore[] sceneEntities)
     {
-        return configurator.AddCycle(triggerObservable, (Action<ILightTransitionCycleConfigurator<NetDaemonLight>>)(c =>
+        return configurator.AddCycle(triggerObservable, c =>
         {
             foreach (var scene in sceneEntities)
                 c.AddScene(scene);
-        }));
+        });
     }
 
     }
diff --git a/src/CodeCasa.AutomationPipelines.Lights.NetDaemon/Extensions/LightTransitionReactiveNodeConfiguratorExtensions.Scene.cs b/src/CodeCasa.AutomationPipelines.Lights.NetDaemon/Extensions/LightTransitionReactiveNodeConfiguratorExtensions.Scene.cs
@@ -52,11 +52,11 @@ public static ILightTransitionReactiveNodeConfigurator<NetDaemonLight> AddToggle
         IObservable<T> triggerObservable,
         params IEntityCore[] sceneEntities)
     {
-        return configurator.AddToggle(triggerObservable, (Action<ILightTransitionToggleConfigurator<NetDaemonLight>>)(c =>
+        return configurator.AddToggle(triggerObservable, c =>
         {
             foreach (var scene in sceneEntities)
                 c.AddScene(scene);
-        }));
+        });
     }
 
     // -------------------------------------------------------------------------
@@ -79,11 +79,11 @@ public static ILightTransitionReactiveNodeConfigurator<NetDaemonLight> AddCycle<
         IObservable<T> triggerObservable,
         params IEntityCore[] sceneEntities)
     {
-        return configurator.AddCycle(triggerObservable, (Action<ILightTransitionCycleConfigurator<NetDaemonLight>>)(c =>
+        return configurator.AddCycle(triggerObservable, c =>
         {
             foreach (var scene in sceneEntities)
                 c.AddScene(scene);
-        }));
+        });
     }
 
     }
diff --git a/src/CodeCasa.AutomationPipelines.Lights/Extensions/ObservableExtensions.cs b/src/CodeCasa.AutomationPipelines.Lights/Extensions/ObservableExtensions.cs
@@ -35,7 +35,7 @@ public static IObservable<TValue> ToCycleObservable<TTrigger, TValue>(
 
     public static IObservable<TValue?> ToToggleObservable<TTrigger, TValue>(
         this IObservable<TTrigger> triggerObservable,
-        Func<bool> offCondition,
+        Func<DateTime?, bool> offCondition,
         Func<TValue> offValueFactory,
         IEnumerable<Func<TValue>> valueFactories,
         TimeSpan timeout,
@@ -55,19 +55,20 @@ public static IObservable<TValue> ToCycleObservable<TTrigger, TValue>(
             {
                 var utcNow = DateTime.UtcNow;
                 var consecutive = previousLastChanged != null && utcNow - previousLastChanged < timeout;
-                previousLastChanged = utcNow;
-
+                
                 if (!consecutive)
                 {
                     index = 0;
-                    if (offCondition())
+                    if (offCondition(previousLastChanged))
                     {
+                        previousLastChanged = utcNow;
                         return offValueFactory();
                     }
                 }
 
                 var value = index >= valueFactoryArray.Length ? offValueFactory() : valueFactoryArray[index]();
                 index = index < maxIndexValue ? index + 1 : 0;
+                previousLastChanged = utcNow;
                 return value;
             });
     }
diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.Reactive.Toggle.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.Reactive.Toggle.cs
@@ -90,6 +90,6 @@ public ILightTransitionPipelineConfigurator<TLight> AddToggle<T>(IObservable<T>
     public ILightTransitionPipelineConfigurator<TLight> AddToggle<T>(IObservable<T> triggerObservable,
         Action<ITimelineConfigurator> configure)
     {
-        return AddToggle(triggerObservable, (Action<ILightTransitionToggleConfigurator<TLight>>)(c => c.AddTimeline(configure)));
+        return AddToggle(triggerObservable, c => c.AddTimeline(configure));
     }
 }
diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/CompositeLightTransitionReactiveNodeConfigurator.Toggle.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/CompositeLightTransitionReactiveNodeConfigurator.Toggle.cs
@@ -65,20 +65,37 @@ public ILightTransitionReactiveNodeConfigurator<TLight> AddToggle<T>(IObservable
     {
         var toggleConfigurators = configurators.ToDictionary(kvp => kvp.Key,
             kvp => new LightTransitionToggleConfigurator<TLight>(kvp.Value.Light, scheduler));
-        var compositeCycleConfigurator = new CompositeLightTransitionToggleConfigurator<TLight>(toggleConfigurators, []);
-        configure(compositeCycleConfigurator);
+        var compositeToggleConfigurator = new CompositeLightTransitionToggleConfigurator<TLight>(toggleConfigurators, []);
+        configure(compositeToggleConfigurator);
         var shareableTriggerObservable = _observableSharingStrategy.Apply(triggerObservable);
-        configurators.ForEach(kvp => kvp.Value.AddNodeSource(shareableTriggerObservable.ToToggleObservable(
-            () => configurators.Values.Any(c => c.Light.IsOn()),
-            () => new TurnOffThenPassThroughNode(),
-            toggleConfigurators[kvp.Key].NodeFactories.Select(fact =>
-            {
-                return new Func<IPipelineNode<LightTransition>>(() => 
-                    fact.CreateScopedNode(kvp.Value.ServiceProvider) // Note: This service provider already has the light registered. We scope it further for node lifetime.
+
+        configurators.ForEach(kvp =>
+        {
+            var toggleConfig = toggleConfigurators[kvp.Key];
+            var gracePeriod = toggleConfig.GracePeriod ?? TimeSpan.FromSeconds(1);
+            kvp.Value.AddNodeSource(shareableTriggerObservable.ToToggleObservable(
+                lastActivationTime =>
+                {
+                    var utcNow = DateTime.UtcNow;
+                    if (utcNow - kvp.Value.Light.LastChangedUtc <= gracePeriod &&
+                        (!lastActivationTime.HasValue || utcNow - lastActivationTime > gracePeriod))
+                    {
+                        return !configurators.Values.Any(c => c.Light.IsOn());
+                    }
+
+                    return configurators.Values.Any(c => c.Light.IsOn());
+                },
+                () => new TurnOffThenPassThroughNode(),
+                toggleConfig.NodeFactories.Select(fact =>
+                {
+                    return new Func<IPipelineNode<LightTransition>>(() =>
+                            fact.CreateScopedNode(kvp.Value
+                                .ServiceProvider) // Note: This service provider already has the light registered. We scope it further for node lifetime.
                     );
-            }),
-            toggleConfigurators[kvp.Key].ToggleTimeout ?? TimeSpan.FromMilliseconds(1000),
-            toggleConfigurators[kvp.Key].IncludeOffValue)));
+                }),
+                toggleConfig.ToggleTimeout ?? TimeSpan.FromMilliseconds(1000),
+                toggleConfig.IncludeOffValue));
+        });
         return this;
     }
 
@@ -96,5 +113,5 @@ public ILightTransitionReactiveNodeConfigurator<TLight> AddToggle<T>(IObservable
     /// <inheritdoc/>
     public ILightTransitionReactiveNodeConfigurator<TLight> AddToggle<T>(IObservable<T> triggerObservable,
         Action<ITimelineConfigurator> configure)
-        => AddToggle(triggerObservable, (Action<ILightTransitionToggleConfigurator<TLight>>)(c => c.AddTimeline(configure)));
+        => AddToggle(triggerObservable, c => c.AddTimeline(configure));
 }
diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/LightTransitionReactiveNodeConfigurator.Toggle.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/LightTransitionReactiveNodeConfigurator.Toggle.cs
@@ -65,8 +65,20 @@ public ILightTransitionReactiveNodeConfigurator<TLight> AddToggle<T>(IObservable
     {
         var toggleConfigurator = new LightTransitionToggleConfigurator<TLight>(Light, _scheduler);
         configure(toggleConfigurator);
+
+        var gracePeriod = toggleConfigurator.GracePeriod ?? TimeSpan.FromSeconds(1);
         AddNodeSource(triggerObservable.ToToggleObservable(
-            () => Light.IsOn(),
+            lastActivationTime =>
+            {
+                var utcNow = DateTime.UtcNow;
+                if (utcNow - Light.LastChangedUtc <= gracePeriod &&
+                    (!lastActivationTime.HasValue || utcNow - lastActivationTime > gracePeriod))
+                {
+                    return !Light.IsOn();
+                }
+
+                return Light.IsOn();
+            },
             () => new TurnOffThenPassThroughNode(),
             toggleConfigurator.NodeFactories.Select(fact =>
             {
@@ -93,5 +105,5 @@ public ILightTransitionReactiveNodeConfigurator<TLight> AddToggle<T>(IObservable
     /// <inheritdoc/>
     public ILightTransitionReactiveNodeConfigurator<TLight> AddToggle<T>(IObservable<T> triggerObservable,
         Action<ITimelineConfigurator> configure)
-        => AddToggle(triggerObservable, (Action<ILightTransitionToggleConfigurator<TLight>>)(c => c.AddTimeline(configure)));
+        => AddToggle(triggerObservable, c => c.AddTimeline(configure));
 }
diff --git a/src/CodeCasa.AutomationPipelines.Lights/Toggle/CompositeLightTransitionToggleConfigurator.cs b/src/CodeCasa.AutomationPipelines.Lights/Toggle/CompositeLightTransitionToggleConfigurator.cs
@@ -34,6 +34,13 @@ public ILightTransitionToggleConfigurator<TLight> ExcludeOffFromToggleCycle()
         return this;
     }
 
+    public ILightTransitionToggleConfigurator<TLight> SetGracePeriod(TimeSpan gracePeriod)
+    {
+        activeConfigurators.Values.ForEach(c => c.SetGracePeriod(gracePeriod));
+        inactiveConfigurators.Values.ForEach(c => c.SetGracePeriod(gracePeriod));
+        return this;
+    }
+
     public ILightTransitionToggleConfigurator<TLight> AddOff()
     {
         return Add<TurnOffThenPassThroughNode>();
diff --git a/src/CodeCasa.AutomationPipelines.Lights/Toggle/ILightTransitionToggleConfigurator.cs b/src/CodeCasa.AutomationPipelines.Lights/Toggle/ILightTransitionToggleConfigurator.cs
@@ -31,6 +31,12 @@ public interface ILightTransitionToggleConfigurator<TLight> where TLight : ILigh
     /// <returns>The configurator instance for method chaining.</returns>
     ILightTransitionToggleConfigurator<TLight> ExcludeOffFromToggleCycle();
 
+    /// <summary>
+    /// Sets the grace period during which a manual interaction will use the light's 
+    /// previous state instead of its current state.
+    /// </summary>
+    ILightTransitionToggleConfigurator<TLight> SetGracePeriod(TimeSpan gracePeriod);
+
     /// <summary>
     /// Adds an "off" state to the toggle sequence.
     /// </summary>
diff --git a/src/CodeCasa.AutomationPipelines.Lights/Toggle/LightTransitionToggleConfigurator.cs b/src/CodeCasa.AutomationPipelines.Lights/Toggle/LightTransitionToggleConfigurator.cs
@@ -13,6 +13,7 @@ internal class LightTransitionToggleConfigurator<TLight>(TLight light, ISchedule
     public TLight Light { get; } = light;
     internal TimeSpan? ToggleTimeout { get; private set; }
     internal bool? IncludeOffValue { get; private set; }
+    internal TimeSpan? GracePeriod { get; private set; }
     internal List<Func<IServiceProvider, IPipelineNode<LightTransition>>> NodeFactories
     {
         get;
@@ -36,6 +37,12 @@ public ILightTransitionToggleConfigurator<TLight> ExcludeOffFromToggleCycle()
         return this;
     }
 
+    public ILightTransitionToggleConfigurator<TLight> SetGracePeriod(TimeSpan gracePeriod)
+    {
+        GracePeriod = gracePeriod;
+        return this;
+    }
+
     public ILightTransitionToggleConfigurator<TLight> AddOff()
     {
         return Add<TurnOffThenPassThroughNode>();
diff --git a/src/CodeCasa.Lights.NetDaemon/NetDaemonLight.cs b/src/CodeCasa.Lights.NetDaemon/NetDaemonLight.cs
@@ -71,4 +71,10 @@ public ILight[] GetChildren()
     public IObservable<Abstractions.StateChange<ILight, LightParameters>> StateChangesWithCurrent() =>
         _lightEntity.StateChangesWithCurrent().Select(sc => new Abstractions.StateChange<ILight, LightParameters>(this,
             sc.Old?.Attributes?.ToLightParameters(), sc.New?.Attributes?.ToLightParameters()));
+
+    /// <inheritdoc />
+    public DateTime? LastChangedUtc => _lightEntity.EntityState?.LastChanged?.ToUniversalTime();
+
+    /// <inheritdoc />
+    public DateTime? LastUpdatedUtc => _lightEntity.EntityState?.LastUpdated?.ToUniversalTime();
 }
diff --git a/src/CodeCasa.Lights/ILight.cs b/src/CodeCasa.Lights/ILight.cs
@@ -40,4 +40,28 @@ public interface ILight
     /// </summary>
     /// <returns>An <see cref="IObservable{T}"/> that emits <see cref="StateChange{ILight, LightParameters}"/> events.</returns>
     IObservable<StateChange<ILight, LightParameters>> StateChangesWithCurrent();
+
+    /// <summary>
+    /// Gets the UTC timestamp when the entity's actual state last changed (e.g., from 'off' to 'on').
+    /// </summary>
+    /// <value>
+    /// The <see cref="DateTime"/> in UTC of the last state change, or <see langword="null"/> if unavailable.
+    /// </value>
+    /// <remarks>
+    /// This value only updates when the primary state value changes. It does not update if only 
+    /// entity attributes (like brightness or temperature) change.
+    /// </remarks>
+    DateTime? LastChangedUtc { get; }
+
+    /// <summary>
+    /// Gets the UTC timestamp when the entity was last updated.
+    /// </summary>
+    /// <value>
+    /// The <see cref="DateTime"/> in UTC of the last update, or <see langword="null"/> if unavailable.
+    /// </value>
+    /// <remarks>
+    /// This value updates whenever the entity is processed by the system, including when 
+    /// attributes change (e.g., brightness, color) or when a sensor reports the exact same state again.
+    /// </remarks>
+    DateTime? LastUpdatedUtc { get; }
 }

Original file line number	Diff line number	Diff line change
`@@ -203,11 +203,11 @@ public static ILightTransitionPipelineConfigurator<NetDaemonLight> AddToggle<T>(`
`203`	`203`	`IObservable<T> triggerObservable,`
`204`	`204`	`params IEntityCore[] sceneEntities)`
`205`	`205`	`{`
`206`		`- return configurator.AddToggle(triggerObservable, (Action<ILightTransitionToggleConfigurator<NetDaemonLight>>)(c =>`
	`206`	`+ return configurator.AddToggle(triggerObservable, c =>`
`207`	`207`	`{`
`208`	`208`	`foreach (var scene in sceneEntities)`
`209`	`209`	`c.AddScene(scene);`
`210`		`- }));`
	`210`	`+ });`
`211`	`211`	`}`
`212`	`212`
`213`	`213`	`// -------------------------------------------------------------------------`
`@@ -230,11 +230,11 @@ public static ILightTransitionPipelineConfigurator<NetDaemonLight> AddCycle<T>(`
`230`	`230`	`IObservable<T> triggerObservable,`
`231`	`231`	`params IEntityCore[] sceneEntities)`
`232`	`232`	`{`
`233`		`- return configurator.AddCycle(triggerObservable, (Action<ILightTransitionCycleConfigurator<NetDaemonLight>>)(c =>`
	`233`	`+ return configurator.AddCycle(triggerObservable, c =>`
`234`	`234`	`{`
`235`	`235`	`foreach (var scene in sceneEntities)`
`236`	`236`	`c.AddScene(scene);`
`237`		`- }));`
	`237`	`+ });`
`238`	`238`	`}`
`239`	`239`
`240`	`240`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,11 +52,11 @@ public static ILightTransitionReactiveNodeConfigurator<NetDaemonLight> AddToggle`
`52`	`52`	`IObservable<T> triggerObservable,`
`53`	`53`	`params IEntityCore[] sceneEntities)`
`54`	`54`	`{`
`55`		`- return configurator.AddToggle(triggerObservable, (Action<ILightTransitionToggleConfigurator<NetDaemonLight>>)(c =>`
	`55`	`+ return configurator.AddToggle(triggerObservable, c =>`
`56`	`56`	`{`
`57`	`57`	`foreach (var scene in sceneEntities)`
`58`	`58`	`c.AddScene(scene);`
`59`		`- }));`
	`59`	`+ });`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`// -------------------------------------------------------------------------`
`@@ -79,11 +79,11 @@ public static ILightTransitionReactiveNodeConfigurator<NetDaemonLight> AddCycle<`
`79`	`79`	`IObservable<T> triggerObservable,`
`80`	`80`	`params IEntityCore[] sceneEntities)`
`81`	`81`	`{`
`82`		`- return configurator.AddCycle(triggerObservable, (Action<ILightTransitionCycleConfigurator<NetDaemonLight>>)(c =>`
	`82`	`+ return configurator.AddCycle(triggerObservable, c =>`
`83`	`83`	`{`
`84`	`84`	`foreach (var scene in sceneEntities)`
`85`	`85`	`c.AddScene(scene);`
`86`		`- }));`
	`86`	`+ });`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public static IObservable<TValue> ToCycleObservable<TTrigger, TValue>(`
`35`	`35`
`36`	`36`	`public static IObservable<TValue?> ToToggleObservable<TTrigger, TValue>(`
`37`	`37`	`this IObservable<TTrigger> triggerObservable,`
`38`		`- Func<bool> offCondition,`
	`38`	`+ Func<DateTime?, bool> offCondition,`
`39`	`39`	`Func<TValue> offValueFactory,`
`40`	`40`	`IEnumerable<Func<TValue>> valueFactories,`
`41`	`41`	`TimeSpan timeout,`
`@@ -55,19 +55,20 @@ public static IObservable<TValue> ToCycleObservable<TTrigger, TValue>(`
`55`	`55`	`{`
`56`	`56`	`var utcNow = DateTime.UtcNow;`
`57`	`57`	`var consecutive = previousLastChanged != null && utcNow - previousLastChanged < timeout;`
`58`		`- previousLastChanged = utcNow;`
`59`		`-`
	`58`	`+`
`60`	`59`	`if (!consecutive)`
`61`	`60`	`{`
`62`	`61`	`index = 0;`
`63`		`- if (offCondition())`
	`62`	`+ if (offCondition(previousLastChanged))`
`64`	`63`	`{`
	`64`	`+ previousLastChanged = utcNow;`
`65`	`65`	`return offValueFactory();`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`var value = index >= valueFactoryArray.Length ? offValueFactory() : valueFactoryArray[index]();`
`70`	`70`	`index = index < maxIndexValue ? index + 1 : 0;`
	`71`	`+ previousLastChanged = utcNow;`
`71`	`72`	`return value;`
`72`	`73`	`});`
`73`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -90,6 +90,6 @@ public ILightTransitionPipelineConfigurator<TLight> AddToggle<T>(IObservable<T>`
`90`	`90`	`public ILightTransitionPipelineConfigurator<TLight> AddToggle<T>(IObservable<T> triggerObservable,`
`91`	`91`	`Action<ITimelineConfigurator> configure)`
`92`	`92`	`{`
`93`		`- return AddToggle(triggerObservable, (Action<ILightTransitionToggleConfigurator<TLight>>)(c => c.AddTimeline(configure)));`
	`93`	`+ return AddToggle(triggerObservable, c => c.AddTimeline(configure));`
`94`	`94`	`}`
`95`	`95`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,13 @@ public ILightTransitionToggleConfigurator<TLight> ExcludeOffFromToggleCycle()`
`34`	`34`	`return this;`
`35`	`35`	`}`
`36`	`36`
	`37`	`+ public ILightTransitionToggleConfigurator<TLight> SetGracePeriod(TimeSpan gracePeriod)`
	`38`	`+ {`
	`39`	`+ activeConfigurators.Values.ForEach(c => c.SetGracePeriod(gracePeriod));`
	`40`	`+ inactiveConfigurators.Values.ForEach(c => c.SetGracePeriod(gracePeriod));`
	`41`	`+ return this;`
	`42`	`+ }`
	`43`	`+`
`37`	`44`	`public ILightTransitionToggleConfigurator<TLight> AddOff()`
`38`	`45`	`{`
`39`	`46`	`return Add<TurnOffThenPassThroughNode>();`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ internal class LightTransitionToggleConfigurator<TLight>(TLight light, ISchedule`
`13`	`13`	`public TLight Light { get; } = light;`
`14`	`14`	`internal TimeSpan? ToggleTimeout { get; private set; }`
`15`	`15`	`internal bool? IncludeOffValue { get; private set; }`
	`16`	`+ internal TimeSpan? GracePeriod { get; private set; }`
`16`	`17`	`internal List<Func<IServiceProvider, IPipelineNode<LightTransition>>> NodeFactories`
`17`	`18`	`{`
`18`	`19`	`get;`
`@@ -36,6 +37,12 @@ public ILightTransitionToggleConfigurator<TLight> ExcludeOffFromToggleCycle()`
`36`	`37`	`return this;`
`37`	`38`	`}`
`38`	`39`
	`40`	`+ public ILightTransitionToggleConfigurator<TLight> SetGracePeriod(TimeSpan gracePeriod)`
	`41`	`+ {`
	`42`	`+ GracePeriod = gracePeriod;`
	`43`	`+ return this;`
	`44`	`+ }`
	`45`	`+`
`39`	`46`	`public ILightTransitionToggleConfigurator<TLight> AddOff()`
`40`	`47`	`{`
`41`	`48`	`return Add<TurnOffThenPassThroughNode>();`