diff --git a/CodeCasa.sln b/CodeCasa.sln index 571957a..00c7ba1 100644 --- a/CodeCasa.sln +++ b/CodeCasa.sln @@ -31,6 +31,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CodeCasa.AutomationPipeline EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CodeCasa.Lights.NetDaemon", "src\CodeCasa.Lights.NetDaemon\CodeCasa.Lights.NetDaemon.csproj", "{FA32051C-0DFF-4FDE-9D9D-60F4ABA4D1A8}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CodeCasa.AutomationPipelines.Lights", "src\CodeCasa.AutomationPipelines.Lights\CodeCasa.AutomationPipelines.Lights.csproj", "{A66370F1-3944-4EAA-82EF-6A321BF273D1}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CodeCasa.AutomationPipelines.Lights.NetDaemon", "src\CodeCasa.AutomationPipelines.Lights.NetDaemon\CodeCasa.AutomationPipelines.Lights.NetDaemon.csproj", "{039D5B9D-F313-4DC5-9A12-FF2A1FDEB15C}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -89,6 +93,14 @@ Global {FA32051C-0DFF-4FDE-9D9D-60F4ABA4D1A8}.Debug|Any CPU.Build.0 = Debug|Any CPU {FA32051C-0DFF-4FDE-9D9D-60F4ABA4D1A8}.Release|Any CPU.ActiveCfg = Release|Any CPU {FA32051C-0DFF-4FDE-9D9D-60F4ABA4D1A8}.Release|Any CPU.Build.0 = Release|Any CPU + {A66370F1-3944-4EAA-82EF-6A321BF273D1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A66370F1-3944-4EAA-82EF-6A321BF273D1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A66370F1-3944-4EAA-82EF-6A321BF273D1}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A66370F1-3944-4EAA-82EF-6A321BF273D1}.Release|Any CPU.Build.0 = Release|Any CPU + {039D5B9D-F313-4DC5-9A12-FF2A1FDEB15C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {039D5B9D-F313-4DC5-9A12-FF2A1FDEB15C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {039D5B9D-F313-4DC5-9A12-FF2A1FDEB15C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {039D5B9D-F313-4DC5-9A12-FF2A1FDEB15C}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/src/CodeCasa.Abstractions/CodeCasa.Abstractions.csproj b/src/CodeCasa.Abstractions/CodeCasa.Abstractions.csproj index 08e387b..e3a53a6 100644 --- a/src/CodeCasa.Abstractions/CodeCasa.Abstractions.csproj +++ b/src/CodeCasa.Abstractions/CodeCasa.Abstractions.csproj @@ -32,9 +32,5 @@ \ - - - - diff --git a/src/CodeCasa.AutomationPipelines.Lights.NetDaemon/CodeCasa.AutomationPipelines.Lights.NetDaemon.csproj b/src/CodeCasa.AutomationPipelines.Lights.NetDaemon/CodeCasa.AutomationPipelines.Lights.NetDaemon.csproj new file mode 100644 index 0000000..573ba12 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights.NetDaemon/CodeCasa.AutomationPipelines.Lights.NetDaemon.csproj @@ -0,0 +1,41 @@ + + + + net10.0 + enable + enable + CodeCasa.AutomationPipelines.Lights.NetDaemon + Jasper Lammers + DevJasper + NetDaemon integration for light automation pipelines, enabling advanced reactive light control through CodeCasa.AutomationPipelines and CodeCasa.Lights abstractions. + https://github.com/DevJasperNL/CodeCasa + NetDaemon;Light Control;Lights;Home Automation;Home Assistant;HA Integration;Smart Home;Automation;Pipeline;Pipelines;Node;Nodes;Reactive;Rx;Reactive Extensions;C#;.NET;DotNet;Extension Methods + LICENSE + README.md + CodeCasa.AutomationPipelines.Lights.NetDaemon + True + ccnd_icon.png + https://github.com/DevJasperNL/CodeCasa/releases + + + + + True + \ + + + True + \ + + + True + \ + + + + + + + + + diff --git a/src/CodeCasa.AutomationPipelines.Lights.NetDaemon/Extensions/LightPipelineFactoryExtensions.cs b/src/CodeCasa.AutomationPipelines.Lights.NetDaemon/Extensions/LightPipelineFactoryExtensions.cs new file mode 100644 index 0000000..8c0240f --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights.NetDaemon/Extensions/LightPipelineFactoryExtensions.cs @@ -0,0 +1,25 @@ +using CodeCasa.AutomationPipelines.Lights.Pipeline; +using CodeCasa.Lights.NetDaemon.Extensions; +using NetDaemon.HassModel.Entities; + +namespace CodeCasa.AutomationPipelines.Lights.NetDaemon.Extensions +{ + /// + /// Extension methods for to work with NetDaemon light entities. + /// + public static class LightPipelineFactoryExtensions + { + /// + /// Sets up a light pipeline for a NetDaemon light entity. + /// + /// The light pipeline factory. + /// The NetDaemon light entity to set up the pipeline for. + /// An action to configure the pipeline behavior. + /// An async disposable representing the created pipeline(s) that can be disposed to clean up resources. + public static IAsyncDisposable SetupLightPipeline(this LightPipelineFactory lightPipelineFactory, ILightEntityCore lightEntity, + Action pipelineBuilder) + { + return lightPipelineFactory.SetupLightPipeline(lightEntity.AsLight(), pipelineBuilder); + } + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/CodeCasa.AutomationPipelines.Lights.csproj b/src/CodeCasa.AutomationPipelines.Lights/CodeCasa.AutomationPipelines.Lights.csproj new file mode 100644 index 0000000..eb95380 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/CodeCasa.AutomationPipelines.Lights.csproj @@ -0,0 +1,42 @@ + + + + net10.0 + enable + enable + CodeCasa.AutomationPipelines.Lights + Jasper Lammers + DevJasper + Light automation pipeline extensions for CodeCasa.AutomationPipelines, providing composable and reactive light control logic. + https://github.com/DevJasperNL/CodeCasa + Home Automation;Home Assistant;HA Integration;Smart Home;Automation;Lights;Light;Pipeline;Pipelines;Node;Nodes;Reactive;Rx;Reactive Extensions;C#;.NET;DotNet;Extension Methods + LICENSE + README.md + CodeCasa.AutomationPipelines.Lights + True + cc_icon.png + https://github.com/DevJasperNL/CodeCasa/releases + + + + + True + \ + + + True + \ + + + True + \ + + + + + + + + + + diff --git a/src/CodeCasa.AutomationPipelines.Lights/CompositeAsyncDisposable.cs b/src/CodeCasa.AutomationPipelines.Lights/CompositeAsyncDisposable.cs new file mode 100644 index 0000000..058f62b --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/CompositeAsyncDisposable.cs @@ -0,0 +1,60 @@ +namespace CodeCasa.AutomationPipelines.Lights +{ + /// + /// A composite disposable that manages both synchronous and asynchronous disposable resources. + /// + public sealed class CompositeAsyncDisposable : IAsyncDisposable + { + private readonly List _asyncDisposables = new(); + private readonly List _disposables = new(); + private bool _disposed; + + /// + /// Adds an asynchronous disposable resource to be disposed when this composite is disposed. + /// + /// The asynchronous disposable resource to add. + public void Add(IAsyncDisposable asyncDisposable) + { + _asyncDisposables.Add(asyncDisposable); + } + + /// + /// Adds a synchronous disposable resource to be disposed when this composite is disposed. + /// + /// The synchronous disposable resource to add. + public void Add(IDisposable disposable) + { + _disposables.Add(disposable); + } + + /// + /// Adds a range of synchronous disposable resources to be disposed when this composite is disposed. + /// + /// The collection of synchronous disposable resources to add. + public void AddRange(IEnumerable disposables) + { + _disposables.AddRange(disposables); + } + + /// + /// Disposes all managed asynchronous and synchronous resources. + /// + public async ValueTask DisposeAsync() + { + if (_disposed) + { + return; + } + _disposed = true; + + foreach (var d in _asyncDisposables) + { + await d.DisposeAsync(); + } + foreach (var d in _disposables) + { + d.Dispose(); + } + } + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/CompositeHelper.cs b/src/CodeCasa.AutomationPipelines.Lights/CompositeHelper.cs new file mode 100644 index 0000000..dcc56af --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/CompositeHelper.cs @@ -0,0 +1,60 @@ +using CodeCasa.Lights; +using CodeCasa.Lights.Extensions; + +namespace CodeCasa.AutomationPipelines.Lights +{ + internal static class CompositeHelper + { + public static string[] ValidateLightsSupported(IEnumerable lightIds, IEnumerable supportedLightIds) + { + var supportedLightIdsArray = supportedLightIds.ToArray(); + var lightIdsArray = lightIds.ToArray(); + if (!lightIdsArray.Any()) + { + throw new ArgumentException("At least one id should be provided.", nameof(lightIdsArray)); + } + + var unsupportedLightIds = lightIdsArray + .Where(id => !supportedLightIdsArray.Contains(id)) + .ToArray(); + + if (unsupportedLightIds.Any()) + { + throw new InvalidOperationException( + $"The following lights are not supported: {string.Join(", ", unsupportedLightIds)}."); + } + + return lightIdsArray.ToArray(); + } + + public static void ValidateLightSupported(IEnumerable lights, string supportedLightId) + { + var lightsArray = lights.ToArray(); + if (!lightsArray.Any()) + { + throw new ArgumentException("At least one id should be provided.", nameof(lightsArray)); + } + + var unsupportedLightIds = lightsArray + .Where(id => id != supportedLightId) + .ToArray(); + + if (unsupportedLightIds.Any()) + { + throw new InvalidOperationException( + $"The following lights are not supported: {string.Join(", ", unsupportedLightIds)}."); + } + } + + public static string[] ResolveGroupsAndValidateLightsSupported(IEnumerable lights, IEnumerable supportedLightIds) + { + return ValidateLightsSupported(lights.SelectMany(le => le.Flatten()).Select(l => l.Id).Distinct(), supportedLightIds); + } + + + public static void ResolveGroupsAndValidateLightSupported(IEnumerable lights, string supportedLightId) + { + ValidateLightSupported(lights.SelectMany(le => le.Flatten()).Select(l => l.Id).Distinct(), supportedLightId); + } + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Context/ILightPipelineContext.cs b/src/CodeCasa.AutomationPipelines.Lights/Context/ILightPipelineContext.cs new file mode 100644 index 0000000..14f0e94 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Context/ILightPipelineContext.cs @@ -0,0 +1,19 @@ +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Context; + +/// +/// Represents the context for a light pipeline, providing access to the service provider and the light being controlled. +/// +public interface ILightPipelineContext +{ + /// + /// Gets the service provider instance used to resolve dependencies in the pipeline. + /// + IServiceProvider ServiceProvider { get; } + + /// + /// Gets the light being controlled by the pipeline. + /// + ILight Light { get; } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Context/LightPipelineContext.cs b/src/CodeCasa.AutomationPipelines.Lights/Context/LightPipelineContext.cs new file mode 100644 index 0000000..d725d59 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Context/LightPipelineContext.cs @@ -0,0 +1,24 @@ +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Context; + +/// +public class LightPipelineContext : ILightPipelineContext +{ + /// + /// Initializes a new instance of the class. + /// + /// The service provider instance used to resolve dependencies in the pipeline. + /// The light being controlled by the pipeline. + internal LightPipelineContext(IServiceProvider serviceProvider, ILight light) + { + ServiceProvider = serviceProvider; + Light = light; + } + + /// + public IServiceProvider ServiceProvider { get; } + + /// + public ILight Light { get; } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Context/LightPipelineContextProvider.cs b/src/CodeCasa.AutomationPipelines.Lights/Context/LightPipelineContextProvider.cs new file mode 100644 index 0000000..fd2e978 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Context/LightPipelineContextProvider.cs @@ -0,0 +1,22 @@ +namespace CodeCasa.AutomationPipelines.Lights.Context +{ + internal class LightPipelineContextProvider + { + private ILightPipelineContext? _lightPipelineContext; + + public ILightPipelineContext GetLightPipelineContext() + { + return _lightPipelineContext ?? throw new InvalidOperationException("Current context not set."); + } + + public void SetLightPipelineContext(ILightPipelineContext context) + { + _lightPipelineContext = context; + } + + public void ResetLight() + { + _lightPipelineContext = null; + } + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Cycle/CompositeLightTransitionCycleConfigurator.cs b/src/CodeCasa.AutomationPipelines.Lights/Cycle/CompositeLightTransitionCycleConfigurator.cs new file mode 100644 index 0000000..df9b5e9 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Cycle/CompositeLightTransitionCycleConfigurator.cs @@ -0,0 +1,129 @@ +using System.Reactive.Concurrency; +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.Nodes; +using CodeCasa.Lights; +using CodeCasa.Lights.Extensions; +using Microsoft.Extensions.DependencyInjection; + +namespace CodeCasa.AutomationPipelines.Lights.Cycle; + +internal class CompositeLightTransitionCycleConfigurator( + Dictionary activeConfigurators, + Dictionary inactiveConfigurators) + : ILightTransitionCycleConfigurator +{ + public ILightTransitionCycleConfigurator AddOff() + { + var matchesNodeState = () => activeConfigurators.Values.All(c => c.Light.IsOff()); + activeConfigurators.Values.ForEach(c => c.Add(_ => matchesNodeState())); + inactiveConfigurators.Values.ForEach(c => c.AddPassThrough(_ => matchesNodeState())); + return this; + } + + public ILightTransitionCycleConfigurator AddOn() + { + return Add(LightTransition.On()); + } + + public ILightTransitionCycleConfigurator Add(LightParameters lightParameters, IEqualityComparer? comparer = null) + { + return Add(lightParameters.AsTransition(), comparer); + } + + public ILightTransitionCycleConfigurator Add(Func lightParametersFactory, Func matchesNodeState) + { + return Add(c => lightParametersFactory(c)?.AsTransition(), matchesNodeState); + } + + public ILightTransitionCycleConfigurator Add(Func lightParametersFactory, Func matchesNodeState) + { + return Add((c, t) => lightParametersFactory(c, t)?.AsTransition(), matchesNodeState); + } + + public ILightTransitionCycleConfigurator Add(LightTransition lightTransition, IEqualityComparer? comparer = null) + { + comparer ??= EqualityComparer.Default; + return Add( + _ => lightTransition, + _ => activeConfigurators.Values.All(c => comparer.Equals( + c.Light.GetParameters(), + lightTransition.LightParameters))); + } + + public ILightTransitionCycleConfigurator Add(Func lightTransitionFactory, Func matchesNodeState) + { + return Add(c => new StaticLightTransitionNode(lightTransitionFactory(c), c.ServiceProvider.GetRequiredService()), matchesNodeState); + } + + public ILightTransitionCycleConfigurator Add(Func lightTransitionFactory, Func matchesNodeState) + { + return Add(c => new FactoryNode(t => lightTransitionFactory(c, t)), matchesNodeState); + } + + public ILightTransitionCycleConfigurator Add(Func matchesNodeState) where TNode : IPipelineNode + { + activeConfigurators.Values.ForEach(c => c.Add(matchesNodeState)); + inactiveConfigurators.Values.ForEach(c => c.AddPassThrough(matchesNodeState)); + return this; + } + + public ILightTransitionCycleConfigurator Add(Func> nodeFactory, Func matchesNodeState) + { + activeConfigurators.Values.ForEach(c => c.Add(nodeFactory, matchesNodeState)); + inactiveConfigurators.Values.ForEach(c => c.AddPassThrough(matchesNodeState)); + return this; + } + + public ILightTransitionCycleConfigurator AddPassThrough(Func matchesNodeState) + { + activeConfigurators.Values.ForEach(c => c.AddPassThrough(matchesNodeState)); + inactiveConfigurators.Values.ForEach(c => c.AddPassThrough(matchesNodeState)); + return this; + } + + public ILightTransitionCycleConfigurator ForLight(string lightId, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None) => ForLights([lightId], configure, excludedLightBehaviour); + + public ILightTransitionCycleConfigurator ForLight(ILight light, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None) => ForLights([light], configure, excludedLightBehaviour); + + public ILightTransitionCycleConfigurator ForLights(IEnumerable lightIds, + Action configure, + ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None) + { + var lightIdArray = + CompositeHelper.ValidateLightsSupported(lightIds, activeConfigurators.Keys); + + if (lightIdArray.Length == activeConfigurators.Count) + { + configure(this); + return this; + } + + if (excludedLightBehaviour == ExcludedLightBehaviours.None) + { + if (lightIdArray.Length == 1) + { + configure(activeConfigurators[lightIdArray.First()]); + return this; + } + + configure(new CompositeLightTransitionCycleConfigurator( + activeConfigurators.Where(kvp => lightIdArray.Contains(kvp.Key)) + .ToDictionary(kvp => kvp.Key, kvp => kvp.Value), [])); + return this; + } + + configure(new CompositeLightTransitionCycleConfigurator( + activeConfigurators.Where(kvp => lightIdArray.Contains(kvp.Key)) + .ToDictionary(kvp => kvp.Key, kvp => kvp.Value), + activeConfigurators.Where(kvp => !lightIdArray.Contains(kvp.Key)) + .ToDictionary(kvp => kvp.Key, kvp => kvp.Value))); + return this; + } + + public ILightTransitionCycleConfigurator ForLights(IEnumerable lightEntities, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None) + { + var lightIds = CompositeHelper.ResolveGroupsAndValidateLightsSupported(lightEntities, activeConfigurators.Keys); + return ForLights(lightIds, configure, excludedLightBehaviour); + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Cycle/ILightTransitionCycleConfigurator.cs b/src/CodeCasa.AutomationPipelines.Lights/Cycle/ILightTransitionCycleConfigurator.cs new file mode 100644 index 0000000..17aa318 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Cycle/ILightTransitionCycleConfigurator.cs @@ -0,0 +1,142 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Cycle +{ + /// + /// Configurator for state-based cycle behavior. Cycles advance based on the current light state: + /// if the light matches a state in the cycle, it advances to the next state. + /// If the current state is not recognized, the cycle starts from the beginning. + /// + public interface ILightTransitionCycleConfigurator + { + /// + /// Adds an "off" state to the cycle. + /// + /// The configurator instance for method chaining. + ILightTransitionCycleConfigurator AddOff(); + + /// + /// Adds an "on" state to the cycle. + /// + /// The configurator instance for method chaining. + ILightTransitionCycleConfigurator AddOn(); + + /// + /// Adds light parameters to the cycle. The cycle will advance to these parameters when the current state matches the previous entry in the cycle. + /// + /// The light parameters to add to the cycle. + /// An optional equality comparer for determining if light parameters match. If null, the default equality comparison is used. + /// The configurator instance for method chaining. + ILightTransitionCycleConfigurator Add(LightParameters lightParameters, IEqualityComparer? comparer = null); + + /// + /// Adds light parameters created by a factory to the cycle, with a custom state matching function. + /// The function determines if the current light state matches this cycle entry. + /// + /// A factory function that creates light parameters based on the pipeline context. + /// A function that determines if the current state matches this cycle entry. + /// The configurator instance for method chaining. + ILightTransitionCycleConfigurator Add(Func lightParametersFactory, Func matchesNodeState); + + /// + /// Adds light parameters created by a factory to the cycle, with a custom state matching function. + /// The factory receives both the pipeline context and the current light transition. + /// The function determines if the current light state matches this cycle entry. + /// + /// A factory function that creates light parameters based on the pipeline context and current transition. + /// A function that determines if the current state matches this cycle entry. + /// The configurator instance for method chaining. + ILightTransitionCycleConfigurator Add(Func lightParametersFactory, Func matchesNodeState); + + /// + /// Adds a light transition to the cycle. The cycle will advance to this transition when the current state matches the previous entry in the cycle. + /// + /// The light transition to add to the cycle. + /// An optional equality comparer for determining if light parameters match. If null, the default equality comparison is used. + /// The configurator instance for method chaining. + ILightTransitionCycleConfigurator Add(LightTransition lightTransition, IEqualityComparer? comparer = null); + + /// + /// Adds a light transition created by a factory to the cycle, with a custom state matching function. + /// The function determines if the current light state matches this cycle entry. + /// + /// A factory function that creates a light transition based on the pipeline context. + /// A function that determines if the current state matches this cycle entry. + /// The configurator instance for method chaining. + ILightTransitionCycleConfigurator Add(Func lightTransitionFactory, Func matchesNodeState); + + /// + /// Adds a light transition created by a factory to the cycle, with a custom state matching function. + /// The factory receives both the pipeline context and the current light transition. + /// The function determines if the current light state matches this cycle entry. + /// + /// A factory function that creates a light transition based on the pipeline context and current transition. + /// A function that determines if the current state matches this cycle entry. + /// The configurator instance for method chaining. + ILightTransitionCycleConfigurator Add(Func lightTransitionFactory, Func matchesNodeState); + + /// + /// Adds a pipeline node of type to the cycle, with a custom state matching function. + /// The node is resolved from the service provider. + /// The function determines if the current light state matches this cycle entry. + /// + /// The type of the pipeline node to add to the cycle. + /// A function that determines if the current state matches this cycle entry. + /// The configurator instance for method chaining. + ILightTransitionCycleConfigurator Add(Func matchesNodeState) where TNode : IPipelineNode; + + /// + /// Adds a pipeline node created by a factory to the cycle, with a custom state matching function. + /// The function determines if the current light state matches this cycle entry. + /// + /// A factory function that creates a pipeline node based on the pipeline context. + /// A function that determines if the current state matches this cycle entry. + /// The configurator instance for method chaining. + ILightTransitionCycleConfigurator Add(Func> nodeFactory, Func matchesNodeState); + + /// + /// Adds a pass-through state to the cycle that maintains the current light state. + /// The function determines if the current light state matches this cycle entry. + /// + /// A function that determines if the current state matches this cycle entry. + /// The configurator instance for method chaining. + ILightTransitionCycleConfigurator AddPassThrough(Func matchesNodeState); + + /// + /// Creates a scoped cycle configuration for a specific light identified by its entity ID. + /// + /// The entity ID of the light to configure. + /// An action to configure the cycle for this specific light. + /// Specifies the behavior for lights not included in this scoped configuration. Defaults to . + /// The configurator instance for method chaining. + ILightTransitionCycleConfigurator ForLight(string lightId, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None); + + /// + /// Creates a scoped cycle configuration for a specific light. + /// + /// The light to configure. + /// An action to configure the cycle for this specific light. + /// Specifies the behavior for lights not included in this scoped configuration. Defaults to . + /// The configurator instance for method chaining. + ILightTransitionCycleConfigurator ForLight(ILight light, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None); + + /// + /// Creates a scoped cycle configuration for multiple light entities identified by their entity IDs. + /// + /// The entity IDs of the lights to configure. + /// An action to configure the cycle for these lights. + /// Specifies the behavior for lights not included in this scoped configuration. Defaults to . + /// The configurator instance for method chaining. + ILightTransitionCycleConfigurator ForLights(IEnumerable lightIds, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None); + + /// + /// Creates a scoped cycle configuration for multiple light entities. + /// + /// The light entities to configure. + /// An action to configure the cycle for these lights. + /// Specifies the behavior for lights not included in this scoped configuration. Defaults to . + /// The configurator instance for method chaining. + ILightTransitionCycleConfigurator ForLights(IEnumerable lightEntities, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None); + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Cycle/LightTransitionCycleConfigurator.cs b/src/CodeCasa.AutomationPipelines.Lights/Cycle/LightTransitionCycleConfigurator.cs new file mode 100644 index 0000000..8350ca1 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Cycle/LightTransitionCycleConfigurator.cs @@ -0,0 +1,98 @@ +using System.Reactive.Concurrency; +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.Nodes; +using CodeCasa.Lights; +using CodeCasa.Lights.Extensions; + +namespace CodeCasa.AutomationPipelines.Lights.Cycle; + +internal class LightTransitionCycleConfigurator(ILight light, IScheduler scheduler) : ILightTransitionCycleConfigurator +{ + public ILight Light { get; } = light; + + internal List<(Func> nodeFactory, Func matchesNodeState)> CycleNodeFactories + { + get; + } = []; + + public ILightTransitionCycleConfigurator AddOff() + { + return Add(_ => Light.IsOff()); + } + + public ILightTransitionCycleConfigurator AddOn() + { + return Add(LightTransition.On()); + } + + public ILightTransitionCycleConfigurator Add(LightParameters lightParameters, IEqualityComparer? comparer = null) + { + return Add(lightParameters.AsTransition(), comparer); + } + + public ILightTransitionCycleConfigurator Add(Func lightParametersFactory, Func matchesNodeState) + { + return Add(c => lightParametersFactory(c)?.AsTransition(), matchesNodeState); + } + + public ILightTransitionCycleConfigurator Add(Func lightParametersFactory, Func matchesNodeState) + { + return Add((c, t) => lightParametersFactory(c, t)?.AsTransition(), matchesNodeState); + } + + public ILightTransitionCycleConfigurator Add(LightTransition lightTransition, IEqualityComparer? comparer = null) + { + comparer ??= EqualityComparer.Default; + return Add(new StaticLightTransitionNode(lightTransition, scheduler), _ => comparer.Equals( + Light.GetParameters(), + lightTransition.LightParameters)); + } + + public ILightTransitionCycleConfigurator Add(Func lightTransitionFactory, Func matchesNodeState) + { + return Add(c => new StaticLightTransitionNode(lightTransitionFactory(c), scheduler), matchesNodeState); + } + + public ILightTransitionCycleConfigurator Add(Func lightTransitionFactory, Func matchesNodeState) + { + return Add(c => new FactoryNode(t => lightTransitionFactory(c, t)), matchesNodeState); + } + + public ILightTransitionCycleConfigurator Add(Func matchesNodeState) where TNode : IPipelineNode + { + return Add(c => c.ServiceProvider.CreateInstanceWithinContext(c), matchesNodeState); + } + + public ILightTransitionCycleConfigurator Add(IPipelineNode node, Func matchesNodeState) + { + return Add(_ => node, matchesNodeState); + } + + public ILightTransitionCycleConfigurator Add(Func> nodeFactory, Func matchesNodeState) + { + CycleNodeFactories.Add((nodeFactory, matchesNodeState)); + return this; + } + + public ILightTransitionCycleConfigurator AddPassThrough(Func matchesNodeState) + { + return Add(new PassThroughNode(), matchesNodeState); + } + + public ILightTransitionCycleConfigurator ForLight(string lightId, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None) => ForLights([lightId], configure, excludedLightBehaviour); + + public ILightTransitionCycleConfigurator ForLight(ILight light, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None) => ForLights([light], configure, excludedLightBehaviour); + + public ILightTransitionCycleConfigurator ForLights(IEnumerable lightIds, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None) + { + CompositeHelper.ValidateLightSupported(lightIds, Light.Id); + return this; + } + + public ILightTransitionCycleConfigurator ForLights(IEnumerable lightEntities, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None) + { + CompositeHelper.ResolveGroupsAndValidateLightSupported(lightEntities, Light.Id); + return this; + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/DimmerOptions.cs b/src/CodeCasa.AutomationPipelines.Lights/DimmerOptions.cs new file mode 100644 index 0000000..977319f --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/DimmerOptions.cs @@ -0,0 +1,43 @@ +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights; + +/// +/// Configuration options for dimmer behavior, including brightness levels, step sizes, and timing. +/// +public record DimmerOptions +{ + /// + /// Gets or sets the minimum brightness level. Defaults to 2. + /// + public int MinBrightness { get; set; } = 2; + + /// + /// Gets or sets the brightness step size for each dimming increment. Defaults to 51. + /// + public int BrightnessStep { get; set; } = 51; + + /// + /// Gets or sets the time delay between each brightness step. Defaults to 500 milliseconds. + /// + public TimeSpan TimeBetweenSteps { get; set; } = TimeSpan.FromMilliseconds(500); + + /// + /// Gets or sets the collection of light IDs that define the order for dimming operations. + /// + public IEnumerable? DimOrderLightEntities { get; set; } + + /// + /// Sets the light order for dimming operations based on the provided collection of light entities. + /// + /// The light entities that define the dimming order. + public void SetLightOrder(IEnumerable lightEntities) => + DimOrderLightEntities = lightEntities.Select(l => l.Id).ToArray(); + + /// + /// Sets the light order for dimming operations based on the provided light entities. + /// + /// The light entities that define the dimming order. + public void SetLightOrder(params ILight[] lightEntities) => + DimOrderLightEntities = lightEntities.Select(l => l.Id).ToArray(); +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/ExcludedLightBehaviours.cs b/src/CodeCasa.AutomationPipelines.Lights/ExcludedLightBehaviours.cs new file mode 100644 index 0000000..a2436e3 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/ExcludedLightBehaviours.cs @@ -0,0 +1,17 @@ +namespace CodeCasa.AutomationPipelines.Lights; + +/// +/// Specifies the behavior for lights that are excluded from specific pipeline operations. +/// +public enum ExcludedLightBehaviours +{ + /// + /// No behavior will be defined for excluded lights. + /// Either add behavior specifically, or they will be out of sync when toggling or cycling through behaviors. + /// + None, + /// + /// A simple pass-through node is added for excluded lights to ensure they stay in sync when toggling or cycling through behaviors. + /// + PassThrough +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Extensions/DimmerOptionsExtensions.cs b/src/CodeCasa.AutomationPipelines.Lights/Extensions/DimmerOptionsExtensions.cs new file mode 100644 index 0000000..c7ad5a7 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Extensions/DimmerOptionsExtensions.cs @@ -0,0 +1,45 @@ +namespace CodeCasa.AutomationPipelines.Lights.Extensions +{ + internal static class DimmerOptionsExtensions + { + public static void ValidateSingleLight(this DimmerOptions dimmerOptions, string lightId) + { + var dimOrderLightEntitiesArray = dimmerOptions.DimOrderLightEntities?.ToArray(); + if (dimOrderLightEntitiesArray != null && dimOrderLightEntitiesArray.Any()) + { + var extraEntities = dimOrderLightEntitiesArray.Where(l => l != lightId).ToArray(); + if (extraEntities.Any()) + { + throw new InvalidOperationException( + $"Builder only supports entity {lightId}. Please remove extra entities {string.Join(", ", extraEntities)}."); + } + } + } + + public static OrderedDictionary ValidateAndOrderMultipleLightTypes(this DimmerOptions dimmerOptions, Dictionary typesByLightIds) + { + var dimOrderLightEntitiesArray = dimmerOptions.DimOrderLightEntities?.ToArray(); + if (dimOrderLightEntitiesArray != null && dimOrderLightEntitiesArray.Any()) + { + var missingEntities = typesByLightIds.Keys.Except(dimOrderLightEntitiesArray).ToArray(); + if (missingEntities.Any()) + { + throw new InvalidOperationException( + $"When providing dim order, all entities should be provided. The following entities are missing: {string.Join(", ", missingEntities)}. Make sure to provide low level entities."); + } + + var extraEntities = dimOrderLightEntitiesArray.Except(typesByLightIds.Keys).ToArray(); + if (extraEntities.Any()) + { + throw new InvalidOperationException( + $"Pipeline does not contain the following entities: {string.Join(", ", extraEntities)}. Make sure to provide low level entities."); + } + + return new OrderedDictionary(dimOrderLightEntitiesArray + .Select(e => new KeyValuePair(e, typesByLightIds[e]))); + } + + return new OrderedDictionary(typesByLightIds); + } + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Extensions/EnumerableExtensions.cs b/src/CodeCasa.AutomationPipelines.Lights/Extensions/EnumerableExtensions.cs new file mode 100644 index 0000000..e4ead0a --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Extensions/EnumerableExtensions.cs @@ -0,0 +1,13 @@ +namespace CodeCasa.AutomationPipelines.Lights.Extensions +{ + internal static class EnumerableExtensions + { + public static void ForEach(this IEnumerable source, Action action) + { + foreach (var item in source) + { + action(item); + } + } + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Extensions/LightTransitionNodeExtensions.cs b/src/CodeCasa.AutomationPipelines.Lights/Extensions/LightTransitionNodeExtensions.cs new file mode 100644 index 0000000..7fc455e --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Extensions/LightTransitionNodeExtensions.cs @@ -0,0 +1,47 @@ +using System.Reactive; +using System.Reactive.Concurrency; +using System.Reactive.Linq; +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Nodes; +using CodeCasa.Lights; +using Microsoft.Extensions.DependencyInjection; + +namespace CodeCasa.AutomationPipelines.Lights.Extensions +{ + /// + /// Provides extension methods for instances. + /// These extensions enable adding timeout behavior to light transition nodes. + /// + public static class LightTransitionNodeExtensions + { + /// + /// Creates a timeout node that automatically turns off the light after the specified time span. + /// The timeout is not reset by any external events. + /// + /// The pipeline node to wrap with timeout behavior. + /// The duration after which the light will turn off. + /// The scheduler to use for timing operations. + /// A new pipeline node that wraps the original node with timeout behavior. + public static IPipelineNode TurnOffAfter(this IPipelineNode node, + TimeSpan timeSpan, IScheduler scheduler) + { + return new ResettableTimeoutNode(node, timeSpan, Observable.Empty(), scheduler); + } + + /// + /// Creates a timeout node that automatically turns off the light after the specified time span. + /// The timeout can be reset when the observable emits a value. + /// + /// The type of values emitted by the reset timer observable. + /// The pipeline node to wrap with timeout behavior. + /// The duration after which the light will turn off. + /// An observable that resets the timeout timer when it emits a value. + /// The scheduler to use for timing operations. + /// A new pipeline node that wraps the original node with resettable timeout behavior. + public static IPipelineNode TurnOffAfter(this IPipelineNode node, + TimeSpan timeSpan, IObservable resetTimerObservable, IScheduler scheduler) + { + return new ResettableTimeoutNode(node, timeSpan, resetTimerObservable, scheduler); + } + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Extensions/ObservableExtensions.cs b/src/CodeCasa.AutomationPipelines.Lights/Extensions/ObservableExtensions.cs new file mode 100644 index 0000000..d745840 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Extensions/ObservableExtensions.cs @@ -0,0 +1,75 @@ +using System.Reactive; +using System.Reactive.Concurrency; +using System.Reactive.Linq; + +namespace CodeCasa.AutomationPipelines.Lights.Extensions +{ + internal static class ObservableExtensions + { + public static IObservable ToPulsesWhenTrue(this IObservable source, TimeSpan timeBetweenPulses, IScheduler scheduler) + { + return source + .Select(b => + b + ? Observable.Timer(TimeSpan.Zero, timeBetweenPulses, scheduler).Select(_ => Unit.Default) + : Observable.Empty()) + .Switch(); + } + + public static IObservable ToCycleObservable( + this IObservable triggerObservable, + IEnumerable<(Func valueFactory, Func valueIsActiveFunc)> cycleValues) + { + var cycleValuesList = cycleValues.ToList(); + return triggerObservable.Select(_ => + { + var index = cycleValuesList.FindIndex(n => n.valueIsActiveFunc()) + 1; + if (index >= cycleValuesList.Count) + { + index = 0; + } + + return cycleValuesList[index].valueFactory(); + }); + } + + public static IObservable ToToggleObservable( + this IObservable triggerObservable, + Func offCondition, + Func offValueFactory, + IEnumerable> valueFactories, + TimeSpan timeout, + bool? includeOff) + { + var valueFactoryArray = valueFactories.ToArray(); + var includeOffBool = includeOff ?? valueFactoryArray.Length <= 1; + if (!includeOffBool && valueFactoryArray.Length <= 1) + { + throw new InvalidOperationException("When only supplying one factory, off should be included."); + } + DateTime? previousLastChanged = null; + var index = 0; + var maxIndexValue = includeOffBool ? valueFactoryArray.Length : valueFactoryArray.Length - 1; + return triggerObservable + .Select(_ => + { + var utcNow = DateTime.UtcNow; + var consecutive = previousLastChanged != null && utcNow - previousLastChanged < timeout; + previousLastChanged = utcNow; + + if (!consecutive) + { + index = 0; + if (offCondition()) + { + return offValueFactory(); + } + } + + var value = index >= valueFactoryArray.Length ? offValueFactory() : valueFactoryArray[index](); + index = index < maxIndexValue ? index + 1 : 0; + return value; + }); + } + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Extensions/SchedulerExtensions.cs b/src/CodeCasa.AutomationPipelines.Lights/Extensions/SchedulerExtensions.cs new file mode 100644 index 0000000..2659045 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Extensions/SchedulerExtensions.cs @@ -0,0 +1,65 @@ + +using System.Reactive.Concurrency; +using CodeCasa.Lights; +using CodeCasa.Lights.Extensions; + +namespace CodeCasa.AutomationPipelines.Lights.Extensions +{ + internal static class SchedulerExtensions + { + /// + /// Schedules a smooth light transition between two states, + /// optionally interpolating progress if the transition is already in progress. + /// + public static IDisposable? ScheduleInterpolatedLightTransition( + this IScheduler scheduler, + LightParameters? sourceLightParameters, + LightParameters? destinationLightParameters, + DateTime? startOfTransition, + DateTime? endOfTransition, + Action transitionAction, + int defaultTransitionTimeMs = 500) + { + if (destinationLightParameters == null) + { + transitionAction(null); + return null; + } + + if (endOfTransition == null) + { + // If there is no end of transition specified, we simply go to the destination state immediately. + transitionAction(destinationLightParameters.AsTransition()); + return null; + } + + var utcNow = DateTime.UtcNow; + // Note: this can be negative. + var timeToEndOfInputTransition = endOfTransition.Value - utcNow; + // For any transition under half a second we simply don't provide a transition. Lights will just smoothly go to the corresponding state. + if (timeToEndOfInputTransition <= TimeSpan.FromMilliseconds(defaultTransitionTimeMs)) + { + transitionAction(destinationLightParameters.AsTransition()); + return null; + } + + if (sourceLightParameters == null || startOfTransition == null) + { + // We don't know the original parameters or the start of this transition, so we simply transition from where we are towards the new. + transitionAction(destinationLightParameters.AsTransition(timeToEndOfInputTransition)); + return null; + } + + var total = (endOfTransition.Value - startOfTransition.Value).TotalSeconds; + var elapsed = (utcNow - startOfTransition.Value).TotalSeconds; + var progress = elapsed / total; + + var initialState = sourceLightParameters.Interpolate(destinationLightParameters, progress); + // First (re)set the lights to where they would have been. + transitionAction(initialState.AsTransition()); + // After the lights have been reset (default transition takes half a second), continue the rest of the transition. + return scheduler.Schedule(TimeSpan.FromMilliseconds(defaultTransitionTimeMs), + () => transitionAction(destinationLightParameters.AsTransition(timeToEndOfInputTransition - TimeSpan.FromMilliseconds(defaultTransitionTimeMs)))); + } + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Extensions/ServiceCollectionExtensions.cs b/src/CodeCasa.AutomationPipelines.Lights/Extensions/ServiceCollectionExtensions.cs new file mode 100644 index 0000000..50b27d8 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Extensions/ServiceCollectionExtensions.cs @@ -0,0 +1,27 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Pipeline; +using CodeCasa.AutomationPipelines.Lights.ReactiveNode; +using Microsoft.Extensions.DependencyInjection; + +namespace CodeCasa.AutomationPipelines.Lights.Extensions; + +/// +/// Extension methods for registering light pipeline services in the dependency injection container. +/// +public static class ServiceCollectionExtensions +{ + /// + /// Registers all required services for light pipelines in the service collection. + /// + /// The service collection to register services in. + /// The service collection for method chaining. + public static IServiceCollection AddLightPipelines(this IServiceCollection serviceCollection) + { + return serviceCollection + .AddTransient() + .AddTransient() + .AddSingleton() + .AddTransient(serviceProvider => + serviceProvider.GetRequiredService().GetLightPipelineContext()); + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Extensions/ServiceProviderExtensions.cs b/src/CodeCasa.AutomationPipelines.Lights/Extensions/ServiceProviderExtensions.cs new file mode 100644 index 0000000..f069930 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Extensions/ServiceProviderExtensions.cs @@ -0,0 +1,26 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.Lights; +using Microsoft.Extensions.DependencyInjection; + +namespace CodeCasa.AutomationPipelines.Lights.Extensions; + +internal static class ServiceProviderExtensions +{ + public static T + CreateInstanceWithinContext(this IServiceProvider serviceProvider, ILight light) => + serviceProvider.CreateInstanceWithinContext(new LightPipelineContext(serviceProvider, light)); + + public static T + CreateInstanceWithinContext(this IServiceProvider serviceProvider, ILightPipelineContext context) => + (T)serviceProvider.CreateInstanceWithinContext(typeof(T), context); + + public static object CreateInstanceWithinContext(this IServiceProvider serviceProvider, Type instanceType, + ILightPipelineContext context) + { + var contextProvider = serviceProvider.GetRequiredService(); + contextProvider.SetLightPipelineContext(context); + var instance = ActivatorUtilities.CreateInstance(serviceProvider, instanceType); + contextProvider.ResetLight(); + return instance; + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Nodes/CompositeDimmer.cs b/src/CodeCasa.AutomationPipelines.Lights/Nodes/CompositeDimmer.cs new file mode 100644 index 0000000..d009ed0 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Nodes/CompositeDimmer.cs @@ -0,0 +1,40 @@ +using System.Reactive.Linq; +using CodeCasa.Abstractions; + + +namespace CodeCasa.AutomationPipelines.Lights.Nodes +{ + /// + /// A composite dimmer that combines multiple dimmers and emits true when any of them are actively dimming or brightening. + /// + public class CompositeDimmer : IDimmer + { + /// + /// Initializes a new instance of the class. + /// + /// The collection of dimmers to combine. Must contain at least one dimmer. + /// Thrown when the dimmers collection is null or empty. + public CompositeDimmer(IEnumerable dimmers) + { + dimmers = dimmers.ToArray(); + if (dimmers == null || !dimmers.Any()) + throw new ArgumentException("At least one dimmer must be provided.", nameof(dimmers)); + + Dimming = dimmers + .Select(d => d.Dimming) + .CombineLatest(x => x.Any()) + .DistinctUntilChanged(); + + Brightening = dimmers + .Select(d => d.Brightening) + .CombineLatest(x => x.Any()) + .DistinctUntilChanged(); + } + + /// + public IObservable Dimming { get; } + + /// + public IObservable Brightening { get; } + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Nodes/DimHelper.cs b/src/CodeCasa.AutomationPipelines.Lights/Nodes/DimHelper.cs new file mode 100644 index 0000000..4e60596 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Nodes/DimHelper.cs @@ -0,0 +1,119 @@ +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Nodes; + +internal class DimHelper( + ILight subject, + IEnumerable lightsInDimOrder, + int minBrightness, + int brightnessStep) +{ + private readonly ILight[] _lightsInDimOrder = lightsInDimOrder.ToArray(); + + public LightTransition? DimStep() + { + var lightToTurnOff = ShouldTurnOffToDim(); + if (lightToTurnOff?.Id == subject.Id) + { + return LightTransition.Off(); + } + if (lightToTurnOff != null) + { + // Another node should act. We shouldn't do anything. + return null; + } + + var parameters = subject.GetParameters(); + var oldBrightness = parameters.Brightness ?? 0; + if (oldBrightness == 0) + { + return null; + } + var newBrightness = Math.Max(minBrightness, oldBrightness - brightnessStep); + if (newBrightness == oldBrightness) + { + return null; + } + + return (parameters with { Brightness = newBrightness }).AsTransition(); + } + + public LightTransition? BrightenStep() + { + var lightToTurnOn = ShouldTurnOnToBrighten(); + if (lightToTurnOn?.Id == subject.Id) + { + return (subject.GetParameters() with { Brightness = minBrightness }).AsTransition(); + } + if (lightToTurnOn != null) + { + // Another node should act. We shouldn't do anything. + return null; + } + + var parameters = subject.GetParameters(); + var oldBrightness = parameters.Brightness ?? 0; + if (oldBrightness == 0) + { + return null; + } + var newBrightness = Math.Min(255, oldBrightness + brightnessStep); + if (newBrightness == oldBrightness) + { + return null; + } + + return (parameters with { Brightness = newBrightness }).AsTransition(); + } + + private ILight? ShouldTurnOffToDim() + { + // todo: filter on availability + ILight? lightToTurnOff = null; + foreach (var light in _lightsInDimOrder) + { + var brightness = light.GetParameters().Brightness ?? 0; + if (brightness == 0) + { + continue; + } + if (brightness > minBrightness) + { + // If any light is brighter than MinBrightness, we don't turn anything off, we need to dim. + return null; + } + + lightToTurnOff ??= light; + } + + return lightToTurnOff; + } + + private ILight? ShouldTurnOnToBrighten() + { + Console.WriteLine($"What node for {subject.Id} sees:"); + foreach (var light in _lightsInDimOrder.Reverse()) + { + Console.WriteLine($"{light.Id}: {light.GetParameters()}"); + } + + // This method is a bit more specific: it will only return true if lights are turned on in the correct order. If not, we want to keep the lights that are off, off. + ILight? lightToTurnOn = null; + foreach (var light in _lightsInDimOrder.Reverse()) + { + var brightness = light.GetParameters().Brightness ?? 0; + if (brightness >= minBrightness) // On + { + if (lightToTurnOn != null || brightness > minBrightness) + { + return null; + } + continue; + } + + lightToTurnOn ??= light; + } + + return lightToTurnOn; + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Nodes/FactoryNode.cs b/src/CodeCasa.AutomationPipelines.Lights/Nodes/FactoryNode.cs new file mode 100644 index 0000000..267d579 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Nodes/FactoryNode.cs @@ -0,0 +1,11 @@ +namespace CodeCasa.AutomationPipelines.Lights.Nodes; + +internal class FactoryNode(Func lightTransitionFactory) + : PipelineNode +{ + /// + protected override void InputReceived(TState? input) + { + Output = lightTransitionFactory(input); + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Nodes/LightTransitionNode.cs b/src/CodeCasa.AutomationPipelines.Lights/Nodes/LightTransitionNode.cs new file mode 100644 index 0000000..f4179fc --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Nodes/LightTransitionNode.cs @@ -0,0 +1,169 @@ +using System.Reactive.Concurrency; +using System.Reactive.Linq; +using System.Reactive.Subjects; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Nodes +{ + /// + /// Base class for pipeline nodes that work with light transitions, extending IPipelineNode functionality. + /// Provides features for managing light transition states, scheduling, and pass-through behavior. + /// + public abstract class LightTransitionNode(IScheduler scheduler) : IPipelineNode + { + private readonly Subject _newOutputSubject = new(); + private LightTransition? _input; + private LightParameters? _inputLightDestinationParameters; + private DateTime? _inputStartOfTransition; + private DateTime? _inputEndOfTransition; + private LightTransition? _output; + private bool _passThroughNextInput; + private bool _passThrough; + private IDisposable? _scheduledAction; + + /// + /// Gets the source light parameters from the previous input, useful for interpolating transitions. + /// + protected LightParameters? InputLightSourceParameters { get; private set; } + + /// + public IObservable OnNewOutput => _newOutputSubject.AsObservable(); + + /// + public LightTransition? Input + { + get => _input; + set + { + _scheduledAction?.Dispose(); // Always cancel scheduled actions when the input changes. + // We save additional information on the light transition that we can later use to continue the transition if it would be interrupted. + InputLightSourceParameters = _inputLightDestinationParameters; + _input = value; + _inputLightDestinationParameters = value?.LightParameters; + var transitionTime = value?.TransitionTime; + _inputStartOfTransition = DateTime.UtcNow; + _inputEndOfTransition = transitionTime == null ? null : _inputStartOfTransition + transitionTime; + + if (_passThroughNextInput) + { + PassThrough = true; + return; + } + if (PassThrough) + { + SetOutputInternal(_input); + return; + } + InputReceived(_input); + } + } + + /// + /// Called when the input is received. Override this method to implement custom input handling logic. + /// + /// The light transition input that was received. + protected virtual void InputReceived(LightTransition? input) + { + // Ignore input by default. + } + + /// + /// Enables pass-through mode for the node, causing it to pass the input directly to the output without processing. + /// + protected void PassInputThrough() + { + PassThrough = true; + } + + /// + /// Gets or sets the output state of the node. + /// Setting this value will trigger output processing and disable pass-through mode. + /// + public LightTransition? Output + { + get => _output; + protected set + { + _scheduledAction?.Dispose(); // Always cancel scheduled actions when the output is changed directly. + PassThrough = false; + + SetOutputInternal(value); + } + } + + /// + /// Schedules an interpolated light transition that will animate from source to desired parameters using the input's transition time. + /// + /// The source light parameters to transition from. + /// The desired light parameters to transition to. + protected void ScheduleInterpolatedLightTransitionUsingInputTransitionTime(LightParameters? sourceLightParameters, LightParameters? desiredLightParameters) + { + PassThrough = false; + _scheduledAction = scheduler.ScheduleInterpolatedLightTransition(sourceLightParameters, + desiredLightParameters, _inputStartOfTransition, _inputEndOfTransition, SetOutputInternal); + } + + /// + /// Gets or sets a value indicating whether the node should pass its input directly to the output. + /// When true, the node does not call InputReceived and instead passes the input through unchanged. + /// + public bool PassThrough + { + get => _passThrough; + set + { + // Always reset _passThroughNextInput when PassThrough is explicitly called. + _passThroughNextInput = false; + + if (_passThrough == value) + { + return; + } + + _scheduledAction?.Dispose(); // Always cancel scheduled actions when the pass through value changes. + + _passThrough = value; + if (_passThrough) + { + _scheduledAction = scheduler.ScheduleInterpolatedLightTransition(InputLightSourceParameters, + _inputLightDestinationParameters, _inputStartOfTransition, _inputEndOfTransition, SetOutputInternal); + } + } + } + + /// + /// Changes the output state of the node and enables pass-through mode after the next input is received. + /// This is useful for nodes that should influence pipeline behavior once, such as light switches or motion sensors. + /// + /// The output light transition to set. + protected void ChangeOutputAndTurnOnPassThroughOnNextInput(LightTransition? output) + { + Output = output; + TurnOnPassThroughOnNextInput(); + } + + /// + /// Keeps the current output but enables pass-through mode after receiving the next input. + /// This is useful for nodes that should influence pipeline behavior once, such as light switches or motion sensors. + /// + protected void TurnOnPassThroughOnNextInput() + { + if (PassThrough) + { + return; + } + + _passThroughNextInput = true; + } + + private void SetOutputInternal(LightTransition? output) + { + _output = output; + _newOutputSubject.OnNext(output); + } + + /// + public override string ToString() => GetType().Name; + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Nodes/PassThroughNode.cs b/src/CodeCasa.AutomationPipelines.Lights/Nodes/PassThroughNode.cs new file mode 100644 index 0000000..370220a --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Nodes/PassThroughNode.cs @@ -0,0 +1,9 @@ +namespace CodeCasa.AutomationPipelines.Lights.Nodes; + +internal class PassThroughNode : PipelineNode +{ + public PassThroughNode() + { + PassThrough = true; + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Nodes/ResettableTimeoutNode.cs b/src/CodeCasa.AutomationPipelines.Lights/Nodes/ResettableTimeoutNode.cs new file mode 100644 index 0000000..a9da7a4 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Nodes/ResettableTimeoutNode.cs @@ -0,0 +1,29 @@ +using System.Reactive; +using System.Reactive.Concurrency; +using System.Reactive.Linq; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Nodes +{ + internal class ResettableTimeoutNode : LightTransitionNode{ + public ResettableTimeoutNode(IPipelineNode childNode, TimeSpan turnOffTime, + IObservable refreshObservable, IScheduler scheduler) : base(scheduler) + { + var serializedChild = childNode.OnNewOutput.Prepend(childNode.Output).ObserveOn(scheduler); + + var serializedTurnOff = + refreshObservable.Select(_ => Unit.Default) + .Prepend(Unit.Default) + .Throttle(turnOffTime, scheduler) + .Take(1) + .ObserveOn(scheduler); + + serializedChild + .TakeUntil(serializedTurnOff) + .Subscribe(output => { Output = output; }); + + serializedTurnOff + .Subscribe(_ => { ChangeOutputAndTurnOnPassThroughOnNextInput(LightTransition.Off()); }); + } + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Nodes/ScopedNode.cs b/src/CodeCasa.AutomationPipelines.Lights/Nodes/ScopedNode.cs new file mode 100644 index 0000000..b85eb2f --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Nodes/ScopedNode.cs @@ -0,0 +1,26 @@ +using CodeCasa.AutomationPipelines.Lights.Utils; +using Microsoft.Extensions.DependencyInjection; + +namespace CodeCasa.AutomationPipelines.Lights.Nodes +{ + internal class ScopedNode(IServiceScope serviceScope, IPipelineNode innerNode) + : IPipelineNode, IAsyncDisposable + { + public async ValueTask DisposeAsync() + { + await serviceScope.DisposeOrDisposeAsync(); + await innerNode.DisposeOrDisposeAsync(); + } + + public TState? Input + { + get => innerNode.Input; + set => innerNode.Input = value; + } + + public TState? Output => innerNode.Output; + public IObservable OnNewOutput => innerNode.OnNewOutput; + + public override string? ToString() => $"{innerNode} (scoped)"; + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Nodes/StaticLightTransitionNode.cs b/src/CodeCasa.AutomationPipelines.Lights/Nodes/StaticLightTransitionNode.cs new file mode 100644 index 0000000..bde921d --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Nodes/StaticLightTransitionNode.cs @@ -0,0 +1,12 @@ +using System.Reactive.Concurrency; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Nodes; + +internal class StaticLightTransitionNode : LightTransitionNode +{ + public StaticLightTransitionNode(LightTransition? output, IScheduler scheduler) : base(scheduler) + { + Output = output; + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Nodes/TurnOffThenPassThroughNode.cs b/src/CodeCasa.AutomationPipelines.Lights/Nodes/TurnOffThenPassThroughNode.cs new file mode 100644 index 0000000..3ad407e --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Nodes/TurnOffThenPassThroughNode.cs @@ -0,0 +1,18 @@ +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Nodes; + +internal class TurnOffThenPassThroughNode : PipelineNode +{ + public TurnOffThenPassThroughNode() + { + // Note: we cannot simply call ChangeOutputAndTurnOnPassThroughOnNextInput here, as the input will immediately be set when this node is added to the timeline. + Output = LightTransition.Off(); + } + + /// + protected override void InputReceived(LightTransition? input) + { + TurnOnPassThroughOnNextInput(); + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/CompositeLightTransitionPipelineConfigurator.Reactive.Cycle.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/CompositeLightTransitionPipelineConfigurator.Reactive.Cycle.cs new file mode 100644 index 0000000..8646086 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/CompositeLightTransitionPipelineConfigurator.Reactive.Cycle.cs @@ -0,0 +1,34 @@ +using CodeCasa.AutomationPipelines.Lights.Cycle; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Pipeline; + +internal partial class CompositeLightTransitionPipelineConfigurator +{ + public ILightTransitionPipelineConfigurator AddCycle(IObservable triggerObservable, IEnumerable lightParameters) + { + return AddReactiveNode(c => c.AddCycle(triggerObservable, lightParameters)); + } + + public ILightTransitionPipelineConfigurator AddCycle(IObservable triggerObservable, + params LightParameters[] lightParameters) + { + return AddReactiveNode(c => c.AddCycle(triggerObservable, lightParameters)); + } + + public ILightTransitionPipelineConfigurator AddCycle(IObservable triggerObservable, IEnumerable lightTransitions) + { + return AddReactiveNode(c => c.AddCycle(triggerObservable, lightTransitions)); + } + + public ILightTransitionPipelineConfigurator AddCycle(IObservable triggerObservable, + params LightTransition[] lightTransitions) + { + return AddReactiveNode(c => c.AddCycle(triggerObservable, lightTransitions)); + } + + public ILightTransitionPipelineConfigurator AddCycle(IObservable triggerObservable, Action configure) + { + return AddReactiveNode(c => c.AddCycle(triggerObservable, configure)); + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/CompositeLightTransitionPipelineConfigurator.Reactive.Toggle.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/CompositeLightTransitionPipelineConfigurator.Reactive.Toggle.cs new file mode 100644 index 0000000..ecdf339 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/CompositeLightTransitionPipelineConfigurator.Reactive.Toggle.cs @@ -0,0 +1,57 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Toggle; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Pipeline; + +internal partial class CompositeLightTransitionPipelineConfigurator +{ + /// + public ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + IEnumerable lightParameters) + { + return AddReactiveNode(c => c.AddToggle(triggerObservable, lightParameters)); + } + + /// + public ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + params LightParameters[] lightParameters) + { + return AddReactiveNode(c => c.AddToggle(triggerObservable, lightParameters)); + } + + /// + public ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + IEnumerable lightTransitions) + { + return AddReactiveNode(c => c.AddToggle(triggerObservable, lightTransitions)); + } + + /// + public ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + params LightTransition[] lightTransitions) + { + return AddReactiveNode(c => c.AddToggle(triggerObservable, lightTransitions)); + } + + /// + public ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + IEnumerable>> nodeFactories) + { + return AddReactiveNode(c => c.AddToggle(triggerObservable, nodeFactories)); + } + + /// + public ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + params Func>[] nodeFactories) + { + return AddReactiveNode(c => c.AddToggle(triggerObservable, nodeFactories)); + } + + /// + public ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + Action configure) + { + return AddReactiveNode(c => c.AddToggle(triggerObservable, configure)); + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/CompositeLightTransitionPipelineConfigurator.Switch.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/CompositeLightTransitionPipelineConfigurator.Switch.cs new file mode 100644 index 0000000..5bbdb00 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/CompositeLightTransitionPipelineConfigurator.Switch.cs @@ -0,0 +1,158 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.ReactiveNode; +using Microsoft.Extensions.DependencyInjection; + + +using System.Reactive.Linq; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Pipeline; + +internal partial class CompositeLightTransitionPipelineConfigurator +{ + /// + public ILightTransitionPipelineConfigurator Switch(LightParameters trueLightParameters, + LightParameters falseLightParameters) where TObservable : IObservable + { + NodeContainers.Values.ForEach(b => b.Switch(trueLightParameters, falseLightParameters)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator Switch(IObservable observable, LightParameters trueLightParameters, + LightParameters falseLightParameters) + { + NodeContainers.Values.ForEach(b => b.Switch(observable, trueLightParameters, falseLightParameters)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator Switch(Func trueLightParametersFactory, + Func falseLightParametersFactory) where TObservable : IObservable + { + NodeContainers.Values.ForEach(b => b.Switch(trueLightParametersFactory, falseLightParametersFactory)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator Switch(IObservable observable, Func trueLightParametersFactory, + Func falseLightParametersFactory) + { + NodeContainers.Values.ForEach(b => b.Switch(observable, trueLightParametersFactory, falseLightParametersFactory)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator Switch(LightTransition trueLightTransition, + LightTransition falseLightTransition) where TObservable : IObservable + { + NodeContainers.Values.ForEach(b => b.Switch(trueLightTransition, falseLightTransition)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator Switch(IObservable observable, LightTransition trueLightTransition, + LightTransition falseLightTransition) + { + NodeContainers.Values.ForEach(b => b.Switch(observable, trueLightTransition, falseLightTransition)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator Switch(Func trueLightTransitionFactory, + Func falseLightTransitionFactory) where TObservable : IObservable + { + NodeContainers.Values.ForEach(b => b.Switch(trueLightTransitionFactory, falseLightTransitionFactory)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator Switch(IObservable observable, Func trueLightTransitionFactory, + Func falseLightTransitionFactory) + { + NodeContainers.Values.ForEach(b => b.Switch(observable, trueLightTransitionFactory, falseLightTransitionFactory)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator Switch(Func> trueNodeFactory, Func> falseNodeFactory) where TObservable : IObservable + { + NodeContainers.Values.ForEach(b => b.Switch(trueNodeFactory, falseNodeFactory)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator Switch(IObservable observable, Func> trueNodeFactory, + Func> falseNodeFactory) + { + NodeContainers.Values.ForEach(b => b.Switch(observable, trueNodeFactory, falseNodeFactory)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator Switch() where TObservable : IObservable where TTrueNode : IPipelineNode where TFalseNode : IPipelineNode + { + NodeContainers.Values.ForEach(b => b.Switch()); + return this; + } + + /// + public ILightTransitionPipelineConfigurator Switch(IObservable observable) where TTrueNode : IPipelineNode where TFalseNode : IPipelineNode + { + NodeContainers.Values.ForEach(b => b.Switch(observable)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator AddReactiveNodeSwitch(Action trueConfigure, + Action falseConfigure) where TObservable : IObservable + { + /* + * For this implementation we can either instantiate the TObservable for each container and pass configure to them individual, breaking composite dimming behavior. + * Or we can create a single TObservable without light context. + * I decided to go with the latter to preserve composite dimming behavior. + */ + var observable = ActivatorUtilities.CreateInstance(serviceProvider); + return AddReactiveNodeSwitch(observable, trueConfigure, falseConfigure); + } + + /// + public ILightTransitionPipelineConfigurator AddReactiveNodeSwitch(IObservable observable, Action trueConfigure, + Action falseConfigure) + { + // Note: we use CompositeLightTransitionPipelineConfigurator.AddReactiveNode so configure is also applied on the composite context. + return AddReactiveNode(c => c + .On(observable.Where(x => x), trueConfigure) + .On(observable.Where(x => !x), falseConfigure)); + } + + /// + public ILightTransitionPipelineConfigurator AddPipelineSwitch(Action trueConfigure, Action falseConfigure) where TObservable : IObservable + { + var observable = ActivatorUtilities.CreateInstance(serviceProvider); + return AddPipelineSwitch(observable, trueConfigure, falseConfigure); + } + + /// + public ILightTransitionPipelineConfigurator AddPipelineSwitch(IObservable observable, Action trueConfigure, + Action falseConfigure) + { + // Note: we use CompositeLightTransitionPipelineConfigurator.AddReactiveNode so configure is also applied on the composite context. + return AddReactiveNode(c => c + .On(observable.Where(x => x), trueConfigure) + .On(observable.Where(x => x), falseConfigure)); + } + + /// + public ILightTransitionPipelineConfigurator TurnOnOff() where TObservable : IObservable + { + return Switch(LightTransition.On(), LightTransition.Off()); + } + + /// + public ILightTransitionPipelineConfigurator TurnOnOff(IObservable observable) + { + return Switch(observable, LightTransition.On(), LightTransition.Off()); + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/CompositeLightTransitionPipelineConfigurator.When.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/CompositeLightTransitionPipelineConfigurator.When.cs new file mode 100644 index 0000000..320c1a6 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/CompositeLightTransitionPipelineConfigurator.When.cs @@ -0,0 +1,172 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.ReactiveNode; +using Microsoft.Extensions.DependencyInjection; + + +using System.Reactive.Linq; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Pipeline; + +internal partial class CompositeLightTransitionPipelineConfigurator +{ + /// + public ILightTransitionPipelineConfigurator When(LightParameters lightParameters) + where TObservable : IObservable + { + NodeContainers.Values.ForEach(b => b.When(lightParameters)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator When(IObservable observable, + LightParameters lightParameters) + { + NodeContainers.Values.ForEach(b => b.When(observable, lightParameters)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator When( + Func lightParametersFactory) where TObservable : IObservable + { + NodeContainers.Values.ForEach(b => b.When(lightParametersFactory)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator When(IObservable observable, + Func lightParametersFactory) + { + NodeContainers.Values.ForEach(b => b.When(observable, lightParametersFactory)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator When(LightTransition lightTransition) + where TObservable : IObservable + { + NodeContainers.Values.ForEach(b => b.When(lightTransition)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator When(IObservable observable, + LightTransition lightTransition) + { + NodeContainers.Values.ForEach(b => b.When(observable, lightTransition)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator When( + Func lightTransitionFactory) where TObservable : IObservable + { + NodeContainers.Values.ForEach(b => b.When(lightTransitionFactory)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator When(IObservable observable, + Func lightTransitionFactory) + { + NodeContainers.Values.ForEach(b => b.When(observable, lightTransitionFactory)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator When( + Func> nodeFactory) where TObservable : IObservable + { + NodeContainers.Values.ForEach(b => b.When(nodeFactory)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator When(IObservable observable, + Func> nodeFactory) + { + NodeContainers.Values.ForEach(b => b.When(observable, nodeFactory)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator When() + where TObservable : IObservable where TNode : IPipelineNode + { + NodeContainers.Values.ForEach(b => b.When()); + return this; + } + + /// + public ILightTransitionPipelineConfigurator When(IObservable observable) + where TNode : IPipelineNode + { + NodeContainers.Values.ForEach(b => b.When(observable)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator AddReactiveNodeWhen(Action configure) where TObservable : IObservable + { + /* + * For this implementation we can either instantiate the TObservable for each container and pass configure to them individual, breaking composite dimming behavior. + * Or we can create a single TObservable without light context. + * I decided to go with the latter to preserve composite dimming behavior. + */ + var observable = ActivatorUtilities.CreateInstance(serviceProvider); + return AddReactiveNodeWhen(observable, configure); + } + + /// + public ILightTransitionPipelineConfigurator AddReactiveNodeWhen(IObservable observable, Action configure) + { + // Note: we use CompositeLightTransitionPipelineConfigurator.AddReactiveNode so configure is also applied on the composite context. + return AddReactiveNode(c => c + .On(observable.Where(x => x), configure) + .PassThroughOn(observable.Where(x => !x))); + } + + /// + public ILightTransitionPipelineConfigurator AddPipelineWhen(Action configure) where TObservable : IObservable + { + var observable = ActivatorUtilities.CreateInstance(serviceProvider); + return AddPipelineWhen(observable, configure); + } + + /// + public ILightTransitionPipelineConfigurator AddPipelineWhen(IObservable observable, Action configure) + { + // Note: we use CompositeLightTransitionPipelineConfigurator.AddReactiveNode so configure is also applied on the composite context. + return AddReactiveNode(c => c + .On(observable.Where(x => x), configure) + .PassThroughOn(observable.Where(x => !x))); + } + + /// + public ILightTransitionPipelineConfigurator TurnOffWhen() where TObservable : IObservable + { + NodeContainers.Values.ForEach(b => b.TurnOffWhen()); + return this; + } + + /// + public ILightTransitionPipelineConfigurator TurnOffWhen(IObservable observable) + { + NodeContainers.Values.ForEach(b => b.TurnOffWhen(observable)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator TurnOnWhen() where TObservable : IObservable + { + return When(LightTransition.On()); + } + + /// + public ILightTransitionPipelineConfigurator TurnOnWhen(IObservable observable) + { + return When(observable, LightTransition.On()); + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/CompositeLightTransitionPipelineConfigurator.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/CompositeLightTransitionPipelineConfigurator.cs new file mode 100644 index 0000000..dffa322 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/CompositeLightTransitionPipelineConfigurator.cs @@ -0,0 +1,117 @@ +using System.Reactive.Concurrency; +using CodeCasa.Abstractions; +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.ReactiveNode; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Pipeline +{ + /// + /// Configures light transition pipelines for multiple light entities as a composite. + /// This configurator applies configurations across all included lights and allows for selective scoping to subsets of lights. + /// + internal partial class CompositeLightTransitionPipelineConfigurator( + IServiceProvider serviceProvider, + LightPipelineFactory lightPipelineFactory, + ReactiveNodeFactory reactiveNodeFactory, + Dictionary nodeContainers) + : ILightTransitionPipelineConfigurator + { + public Dictionary NodeContainers { get; } = nodeContainers; + + /// + public ILightTransitionPipelineConfigurator SetName(string name) + { + NodeContainers.Values.ForEach(b => b.SetName(name)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator AddNode() where TNode : IPipelineNode + { + NodeContainers.Values.ForEach(b => b.AddNode()); + return this; + } + + /// + public ILightTransitionPipelineConfigurator AddNode(Func> nodeFactory) + { + NodeContainers.Values.ForEach(b => b.AddNode(nodeFactory)); + return this; + } + + /// + public ILightTransitionPipelineConfigurator AddReactiveNode( + Action configure) + { + var nodes = reactiveNodeFactory.CreateReactiveNodes(NodeContainers.Select(nc => nc.Value.Light), + configure); + NodeContainers.ForEach(kvp => kvp.Value.AddNode(nodes[kvp.Key])); + return this; + } + + /// + public ILightTransitionPipelineConfigurator AddPipeline(Action pipelineNodeOptions) + { + var pipelines = lightPipelineFactory.CreateLightPipelines(NodeContainers.Select(c => c.Value.Light), + pipelineNodeOptions); + NodeContainers.ForEach(kvp => kvp.Value.AddNode(pipelines[kvp.Key])); + return this; + } + + /// + public ILightTransitionPipelineConfigurator AddDimmer(IDimmer dimmer) + { + return AddDimmer(dimmer, _ => { }); + } + + /// + public ILightTransitionPipelineConfigurator AddDimmer(IDimmer dimmer, Action dimOptions) + { + return AddReactiveNode(c => + { + c.AddUncoupledDimmer(dimmer, dimOptions); + }); + } + + /// + public ILightTransitionPipelineConfigurator ForLight(string lightId, + Action compositeNodeBuilder) => ForLights([lightId], compositeNodeBuilder); + + /// + public ILightTransitionPipelineConfigurator ForLight(ILight light, + Action compositeNodeBuilder) => ForLights([light], compositeNodeBuilder); + + /// + public ILightTransitionPipelineConfigurator ForLights(IEnumerable lightIds, + Action compositeNodeBuilder) + { + var lightIdsArray = + CompositeHelper.ValidateLightsSupported(lightIds, NodeContainers.Keys); + + if (lightIdsArray.Length == NodeContainers.Count) + { + compositeNodeBuilder(this); + return this; + } + if (lightIdsArray.Length == 1) + { + compositeNodeBuilder(NodeContainers[lightIdsArray.First()]); + return this; + } + + compositeNodeBuilder(new CompositeLightTransitionPipelineConfigurator(serviceProvider, lightPipelineFactory, reactiveNodeFactory, NodeContainers + .Where(kvp => lightIdsArray.Contains(kvp.Key)).ToDictionary(kvp => kvp.Key, kvp => kvp.Value))); + return this; + } + + /// + public ILightTransitionPipelineConfigurator ForLights(IEnumerable lightEntities, + Action compositeNodeBuilder) + { + var lightIds = CompositeHelper.ResolveGroupsAndValidateLightsSupported(lightEntities, NodeContainers.Keys); + return ForLights(lightIds, compositeNodeBuilder); + } + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/ILightTransitionPipelineConfigurator.Reactive.Cycle.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/ILightTransitionPipelineConfigurator.Reactive.Cycle.cs new file mode 100644 index 0000000..cb13ff1 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/ILightTransitionPipelineConfigurator.Reactive.Cycle.cs @@ -0,0 +1,62 @@ +using CodeCasa.AutomationPipelines.Lights.Cycle; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Pipeline; + +public partial interface ILightTransitionPipelineConfigurator +{ + /// + /// Adds a cycle node that rotates through the specified light parameters when triggered by . + /// Each trigger cycles to the next set of parameters in the collection. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers cycling to the next parameters. + /// The collection of light parameters to cycle through. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddCycle(IObservable triggerObservable, + IEnumerable lightParameters); + + /// + /// Adds a cycle node that rotates through the specified light parameters when triggered by . + /// Each trigger cycles to the next set of parameters in the array. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers cycling to the next parameters. + /// The array of light parameters to cycle through. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddCycle(IObservable triggerObservable, + params LightParameters[] lightParameters); + + /// + /// Adds a cycle node that rotates through the specified light transitions when triggered by . + /// Each trigger cycles to the next transition in the collection. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers cycling to the next transition. + /// The collection of light transitions to cycle through. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddCycle(IObservable triggerObservable, + IEnumerable lightTransitions); + + /// + /// Adds a cycle node that rotates through the specified light transitions when triggered by . + /// Each trigger cycles to the next transition in the array. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers cycling to the next transition. + /// The array of light transitions to cycle through. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddCycle(IObservable triggerObservable, + params LightTransition[] lightTransitions); + + /// + /// Adds a cycle node configured by the specified action when triggered by . + /// Each trigger cycles to the next configured state. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers cycling to the next state. + /// An action to configure the cycle behavior. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddCycle(IObservable triggerObservable, + Action configure); +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/ILightTransitionPipelineConfigurator.Reactive.Toggle.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/ILightTransitionPipelineConfigurator.Reactive.Toggle.cs new file mode 100644 index 0000000..18b1399 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/ILightTransitionPipelineConfigurator.Reactive.Toggle.cs @@ -0,0 +1,85 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Toggle; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Pipeline; + +public partial interface ILightTransitionPipelineConfigurator +{ + /// + /// Adds a toggle node that switches between the specified light parameters when triggered by . + /// Each trigger toggles to the next set of parameters in the collection, wrapping back to the first after the last. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers toggling to the next parameters. + /// The collection of light parameters to toggle between. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + IEnumerable lightParameters); + + /// + /// Adds a toggle node that switches between the specified light parameters when triggered by . + /// Each trigger toggles to the next set of parameters in the array, wrapping back to the first after the last. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers toggling to the next parameters. + /// The array of light parameters to toggle between. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + params LightParameters[] lightParameters); + + /// + /// Adds a toggle node that switches between the specified light transitions when triggered by . + /// Each trigger toggles to the next transition in the collection, wrapping back to the first after the last. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers toggling to the next transition. + /// The collection of light transitions to toggle between. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + IEnumerable lightTransitions); + + /// + /// Adds a toggle node that switches between the specified light transitions when triggered by . + /// Each trigger toggles to the next transition in the array, wrapping back to the first after the last. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers toggling to the next transition. + /// The array of light transitions to toggle between. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + params LightTransition[] lightTransitions); + + /// + /// Adds a toggle node that switches between nodes created by the specified factory functions when triggered by . + /// Each trigger toggles to the next node factory in the collection, wrapping back to the first after the last. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers toggling to the next node. + /// The collection of factory functions that create pipeline nodes. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + IEnumerable>> nodeFactories); + + /// + /// Adds a toggle node that switches between nodes created by the specified factory functions when triggered by . + /// Each trigger toggles to the next node factory in the array, wrapping back to the first after the last. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers toggling to the next node. + /// The array of factory functions that create pipeline nodes. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + params Func>[] nodeFactories); + + /// + /// Adds a toggle node configured by the specified action when triggered by . + /// Each trigger toggles to the next configured state. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers toggling to the next state. + /// An action to configure the toggle behavior. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + Action configure); +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/ILightTransitionPipelineConfigurator.Switch.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/ILightTransitionPipelineConfigurator.Switch.cs new file mode 100644 index 0000000..f2f302b --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/ILightTransitionPipelineConfigurator.Switch.cs @@ -0,0 +1,254 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.ReactiveNode; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Pipeline; + +public partial interface ILightTransitionPipelineConfigurator +{ + /// + /// Registers a node that switches between two sets of light parameters based on a boolean observable. + /// When the observable of type emits , + /// the are applied; when it emits , + /// the are applied. + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// The light parameters to apply when the observable emits true. + /// The light parameters to apply when the observable emits false. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator Switch(LightParameters trueLightParameters, + LightParameters falseLightParameters) + where TObservable : IObservable; + + /// + /// Registers a node that switches between two sets of light parameters based on the . + /// When the observable emits , the are applied; + /// when it emits , the are applied. + /// + /// The observable that determines which parameters to apply. + /// The light parameters to apply when the observable emits true. + /// The light parameters to apply when the observable emits false. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator Switch(IObservable observable, + LightParameters trueLightParameters, LightParameters falseLightParameters); + + /// + /// Registers a node that switches between two sets of light parameters created by factory functions based on a boolean observable. + /// When the observable of type emits , + /// the parameters from are applied; when it emits , + /// the parameters from are applied. + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// A factory function that creates light parameters for true values. + /// A factory function that creates light parameters for false values. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator Switch( + Func trueLightParametersFactory, + Func falseLightParametersFactory) + where TObservable : IObservable; + + /// + /// Registers a node that switches between two sets of light parameters created by factory functions based on the . + /// When the observable emits , the parameters from are applied; + /// when it emits , the parameters from are applied. + /// + /// The observable that determines which parameters to apply. + /// A factory function that creates light parameters for true values. + /// A factory function that creates light parameters for false values. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator Switch(IObservable observable, + Func trueLightParametersFactory, + Func falseLightParametersFactory); + + /// + /// Registers a node that switches between two light transitions based on a boolean observable. + /// When the observable of type emits , + /// the is applied; when it emits , + /// the is applied. + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// The light transition to apply when the observable emits true. + /// The light transition to apply when the observable emits false. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator Switch(LightTransition trueLightTransition, + LightTransition falseLightTransition) + where TObservable : IObservable; + + /// + /// Registers a node that switches between two light transitions based on the . + /// When the observable emits , the is applied; + /// when it emits , the is applied. + /// + /// The observable that determines which transition to apply. + /// The light transition to apply when the observable emits true. + /// The light transition to apply when the observable emits false. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator Switch(IObservable observable, + LightTransition trueLightTransition, LightTransition falseLightTransition); + + /// + /// Registers a node that switches between two light transitions created by factory functions based on a boolean observable. + /// When the observable of type emits , + /// the transition from is applied; when it emits , + /// the transition from is applied. + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// A factory function that creates a light transition for true values. + /// A factory function that creates a light transition for false values. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator Switch( + Func trueLightTransitionFactory, + Func falseLightTransitionFactory) + where TObservable : IObservable; + + /// + /// Registers a node that switches between two light transitions created by factory functions based on the . + /// When the observable emits , the transition from is applied; + /// when it emits , the transition from is applied. + /// + /// The observable that determines which transition to apply. + /// A factory function that creates a light transition for true values. + /// A factory function that creates a light transition for false values. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator Switch(IObservable observable, + Func trueLightTransitionFactory, + Func falseLightTransitionFactory); + + /// + /// Registers a node that switches between two pipeline nodes created by factory functions based on a boolean observable. + /// When the observable of type emits , + /// the node from is applied; when it emits , + /// the node from is applied. + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// A factory function that creates a pipeline node for true values. + /// A factory function that creates a pipeline node for false values. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator Switch( + Func> trueNodeFactory, + Func> falseNodeFactory) + where TObservable : IObservable; + + /// + /// Registers a node that switches between two pipeline nodes created by factory functions based on the . + /// When the observable emits , the node from is applied; + /// when it emits , the node from is applied. + /// + /// The observable that determines which node to apply. + /// A factory function that creates a pipeline node for true values. + /// A factory function that creates a pipeline node for false values. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator Switch(IObservable observable, + Func> trueNodeFactory, + Func> falseNodeFactory); + + /// + /// Registers a node that switches between two pipeline node types based on a boolean observable. + /// When the observable of type emits , + /// a node of type is applied; when it emits , + /// a node of type is applied. + /// The observable and both node types are resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// The type of the pipeline node to apply for true values. + /// The type of the pipeline node to apply for false values. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator Switch() + where TObservable : IObservable + where TTrueNode : IPipelineNode + where TFalseNode : IPipelineNode; + + /// + /// Registers a node that switches between two pipeline node types based on the . + /// When the observable emits , a node of type is applied; + /// when it emits , a node of type is applied. + /// Both node types are resolved from the service provider. + /// + /// The type of the pipeline node to apply for true values. + /// The type of the pipeline node to apply for false values. + /// The observable that determines which node to apply. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator Switch(IObservable observable) + where TTrueNode : IPipelineNode + where TFalseNode : IPipelineNode; + + /// + /// Registers a reactive node that switches between two configurations based on a boolean observable. + /// When the observable of type emits , + /// the node is configured by ; when it emits , + /// the node is configured by . + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// An action to configure the reactive node for true values. + /// An action to configure the reactive node for false values. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddReactiveNodeSwitch( + Action trueConfigure, + Action falseConfigure) + where TObservable : IObservable; + + /// + /// Registers a reactive node that switches between two configurations based on the . + /// When the observable emits , the node is configured by ; + /// when it emits , the node is configured by . + /// + /// The observable that determines which configuration to apply. + /// An action to configure the reactive node for true values. + /// An action to configure the reactive node for false values. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddReactiveNodeSwitch(IObservable observable, + Action trueConfigure, + Action falseConfigure); + + /// + /// Registers a pipeline that switches between two configurations based on a boolean observable. + /// When the observable of type emits , + /// the pipeline is configured by ; when it emits , + /// the pipeline is configured by . + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// An action to configure the pipeline for true values. + /// An action to configure the pipeline for false values. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddPipelineSwitch( + Action trueConfigure, + Action falseConfigure) + where TObservable : IObservable; + + /// + /// Registers a pipeline that switches between two configurations based on the . + /// When the observable emits , the pipeline is configured by ; + /// when it emits , the pipeline is configured by . + /// + /// The observable that determines which configuration to apply. + /// An action to configure the pipeline for true values. + /// An action to configure the pipeline for false values. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddPipelineSwitch(IObservable observable, + Action trueConfigure, + Action falseConfigure); + + /// + /// Registers a node that turns the light on when the observable of type + /// emits , and turns it off when it emits . + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator TurnOnOff() where TObservable : IObservable; + + /// + /// Registers a node that turns the light on when the emits , + /// and turns it off when it emits . + /// + /// The observable that determines whether to turn the light on or off. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator TurnOnOff(IObservable observable); +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/ILightTransitionPipelineConfigurator.When.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/ILightTransitionPipelineConfigurator.When.cs new file mode 100644 index 0000000..16ecfe1 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/ILightTransitionPipelineConfigurator.When.cs @@ -0,0 +1,234 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.ReactiveNode; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Pipeline; + +public partial interface ILightTransitionPipelineConfigurator +{ + /// + /// Registers a node that applies the given when the observable + /// of type emits . + /// When the observable emits , inputs are passed through unchanged. + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// The light parameters to apply when the observable emits true. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator When(LightParameters lightParameters) + where TObservable : IObservable; + + /// + /// Registers a node that applies the given when the + /// emits . + /// When the observable emits , inputs are passed through unchanged. + /// + /// The observable that determines when to apply the light parameters. + /// The light parameters to apply when the observable emits true. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator When(IObservable observable, LightParameters lightParameters); + + /// + /// Registers a node that applies light parameters created by + /// when the observable of type emits . + /// When the observable emits , inputs are passed through unchanged. + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// A factory function that creates light parameters based on the pipeline context. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator When( + Func lightParametersFactory) + where TObservable : IObservable; + + /// + /// Registers a node that applies light parameters created by + /// when the emits . + /// When the observable emits , inputs are passed through unchanged. + /// + /// The observable that determines when to apply the light parameters. + /// A factory function that creates light parameters based on the pipeline context. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator When(IObservable observable, + Func lightParametersFactory); + + /// + /// Registers a node that applies the given when the observable + /// of type emits . + /// When the observable emits , inputs are passed through unchanged. + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// The light transition to apply when the observable emits true. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator When(LightTransition lightTransition) + where TObservable : IObservable; + + /// + /// Registers a node that applies the given when the + /// emits . + /// When the observable emits , inputs are passed through unchanged. + /// + /// The observable that determines when to apply the light transition. + /// The light transition to apply when the observable emits true. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator When(IObservable observable, LightTransition lightTransition); + + /// + /// Registers a node that applies the created by + /// when the observable of type + /// emits . + /// When the observable emits , inputs are passed through unchanged. + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// A factory function that creates a light transition based on the pipeline context. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator When( + Func lightTransitionFactory) + where TObservable : IObservable; + + /// + /// Registers a node that applies the created by + /// when the + /// emits . When the observable emits , + /// inputs are passed through unchanged. + /// + /// The observable that determines when to apply the light transition. + /// A factory function that creates a light transition based on the pipeline context. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator When(IObservable observable, + Func lightTransitionFactory); + + /// + /// Registers a node created by when the observable of type + /// emits . + /// When the observable emits , inputs are passed through unchanged. + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// A factory function that creates a pipeline node based on the pipeline context. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator When( + Func> nodeFactory) + where TObservable : IObservable; + + /// + /// Registers a node created by when the + /// emits . When the observable emits , + /// inputs are passed through unchanged. + /// + /// The observable that determines when to apply the node. + /// A factory function that creates a pipeline node based on the pipeline context. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator When(IObservable observable, + Func> nodeFactory); + + /// + /// Registers a node of type when the observable of type + /// emits . + /// When the observable emits , inputs are passed through unchanged. + /// Both the observable and the node are resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// The type of the pipeline node to resolve from the service provider. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator When() + where TObservable : IObservable + where TNode : IPipelineNode; + + /// + /// Registers a node of type when the + /// emits . When the observable emits , + /// inputs are passed through unchanged. The node is resolved from the service provider. + /// + /// The type of the pipeline node to resolve from the service provider. + /// The observable that determines when to apply the node. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator When(IObservable observable) + where TNode : IPipelineNode; + + /// + /// Registers a reactive node configured by when the observable of type + /// emits . + /// When the observable emits , inputs are passed through unchanged. + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// An action to configure the reactive node. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddReactiveNodeWhen( + Action configure) + where TObservable : IObservable; + + /// + /// Registers a reactive node configured by when the + /// emits . When the observable emits , + /// inputs are passed through unchanged. + /// + /// The observable that determines when to apply the reactive node. + /// An action to configure the reactive node. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddReactiveNodeWhen(IObservable observable, + Action configure); + + /// + /// Registers a pipeline configured by when the observable of type + /// emits . + /// When the observable emits , inputs are passed through unchanged. + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// An action to configure the nested pipeline. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddPipelineWhen( + Action configure) + where TObservable : IObservable; + + /// + /// Registers a pipeline configured by when the + /// emits . When the observable emits , + /// inputs are passed through unchanged. + /// + /// The observable that determines when to apply the pipeline. + /// An action to configure the nested pipeline. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddPipelineWhen(IObservable observable, + Action configure); + + /// + /// Registers a node that turns off the light when the observable + /// of type emits . + /// When the observable emits , inputs are passed through unchanged. + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator TurnOffWhen() where TObservable : IObservable; + + /// + /// Registers a node that turns off the light when the emits . + /// When the observable emits , inputs are passed through unchanged. + /// + /// The observable that determines when to turn off the light. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator TurnOffWhen(IObservable observable); + + /// + /// Registers a node that turns on the light when the observable + /// of type emits . + /// When the observable emits , inputs are passed through unchanged. + /// The observable is resolved from the service provider. + /// + /// The type of the observable to resolve from the service provider. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator TurnOnWhen() where TObservable : IObservable; + + /// + /// Registers a node that turns on the light when the emits . + /// When the observable emits , inputs are passed through unchanged. + /// + /// The observable that determines when to turn on the light. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator TurnOnWhen(IObservable observable); +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/ILightTransitionPipelineConfigurator.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/ILightTransitionPipelineConfigurator.cs new file mode 100644 index 0000000..c8a602d --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/ILightTransitionPipelineConfigurator.cs @@ -0,0 +1,96 @@ +using CodeCasa.Abstractions; +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.ReactiveNode; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Pipeline; + +/// +/// Configures a light transition pipeline for controlling light behavior through layered logic nodes. +/// Supports adding nodes, reactive nodes, dimmers, and conditional logic with When/Switch operators. +/// +public partial interface ILightTransitionPipelineConfigurator +{ + /// + /// Sets the name for the current pipeline configuration. + /// + /// The name to assign to the pipeline. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator SetName(string name); + + /// + /// Adds a pipeline node of type to the pipeline. + /// The node is resolved from the service provider. + /// + /// The type of the pipeline node to add. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddNode() where TNode : IPipelineNode; + + /// + /// Adds a pipeline node created by the specified to the pipeline. + /// + /// A factory function that creates a pipeline node based on the light pipeline context. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddNode(Func> nodeFactory); + + /// + /// Adds a reactive node to the pipeline configured by the specified action. + /// + /// An action to configure the reactive node. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddReactiveNode(Action configure); + + /// + /// Adds a nested pipeline to the current pipeline configured by the specified action. + /// + /// An action to configure the nested pipeline. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddPipeline(Action pipelineNodeOptions); + + /// + /// Adds a dimmer control to the pipeline. + /// + /// The dimmer device to add. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddDimmer(IDimmer dimmer); + + /// + /// Adds a dimmer control to the pipeline with custom configuration options. + /// + /// The dimmer device to add. + /// An action to configure the dimmer options. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator AddDimmer(IDimmer dimmer, Action dimOptions); + + /// + /// Creates a scoped pipeline configuration for a specific light identified by its entity ID. + /// + /// The entity ID of the light to configure. + /// An action to configure the pipeline for this specific light. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator ForLight(string lightId, Action compositeNodeBuilder); + + /// + /// Creates a scoped pipeline configuration for a specific light. + /// + /// The light to configure. + /// An action to configure the pipeline for this specific light. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator ForLight(ILight light, Action compositeNodeBuilder); + + /// + /// Creates a scoped pipeline configuration for multiple light entities identified by their entity IDs. + /// + /// The entity IDs of the lights to configure. + /// An action to configure the pipeline for these lights. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator ForLights(IEnumerable lightIds, Action compositeNodeBuilder); + + /// + /// Creates a scoped pipeline configuration for multiple light entities. + /// + /// The light entities to configure. + /// An action to configure the pipeline for these lights. + /// The configurator instance for method chaining. + ILightTransitionPipelineConfigurator ForLights(IEnumerable lightEntities, Action compositeNodeBuilder); +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightPipelineFactory.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightPipelineFactory.cs new file mode 100644 index 0000000..ae9f52c --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightPipelineFactory.cs @@ -0,0 +1,81 @@ +using Microsoft.Extensions.Logging; +using System.Reactive.Concurrency; +using CodeCasa.AutomationPipelines.Lights.ReactiveNode; +using CodeCasa.Lights; +using CodeCasa.Lights.Extensions; + +namespace CodeCasa.AutomationPipelines.Lights.Pipeline +{ + /// + /// Factory for creating and configuring light transition pipelines. + /// + public class LightPipelineFactory( + ILogger> logger, IServiceProvider serviceProvider, ReactiveNodeFactory reactiveNodeFactory) + { + /// + /// Sets up a light pipeline for the specified light and configures it with the provided builder action. + /// + /// The light to set up the pipeline for. + /// An action to configure the pipeline behavior. + /// An async disposable representing the created pipeline(s) that can be disposed to clean up resources. + public IAsyncDisposable SetupLightPipeline(ILight light, + Action pipelineBuilder) + { + var disposables = new CompositeAsyncDisposable(); + var pipelines = CreateLightPipelines(light.Flatten(), pipelineBuilder); + foreach (var pipeline in pipelines.Values) + { + disposables.Add(pipeline); + } + return disposables; + } + + /// + /// Creates a single light pipeline for the specified light. + /// + /// The light to create a pipeline for. + /// An action to configure the pipeline behavior. + /// A configured pipeline for controlling the specified light. + internal IPipeline CreateLightPipeline(ILight light, Action pipelineBuilder) + { + return CreateLightPipelines([light], pipelineBuilder)[light.Id]; + } + + /// + /// Creates light pipelines for multiple light entities. + /// + /// The light entities to create pipelines for. + /// An action to configure the pipeline behavior. + /// A dictionary mapping light IDs to their corresponding pipelines. + internal Dictionary> CreateLightPipelines(IEnumerable lightEntities, Action pipelineBuilder) + { + // Note: we simply assume that these are not groups. + var lightArray = lightEntities.ToArray(); + if (!lightArray.Any()) + { + return new Dictionary>(); + } + + var configurators = lightArray.ToDictionary(l => l.Id, l => new LightTransitionPipelineConfigurator(serviceProvider, this, reactiveNodeFactory, l)); + ILightTransitionPipelineConfigurator configurator = lightArray.Length == 1 + ? configurators[lightArray[0].Id] + : new CompositeLightTransitionPipelineConfigurator( + serviceProvider, + this, + reactiveNodeFactory, + configurators); + pipelineBuilder(configurator); + + return configurators.ToDictionary(kvp => kvp.Key, kvp => + { + var conf = kvp.Value; + return (IPipeline)new Pipeline( + conf.Name ?? conf.Light.Id, + LightTransition.Off(), + conf.Nodes, + conf.Light.ApplyTransition, + logger); + }); + } + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.Reactive.Cycle.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.Reactive.Cycle.cs new file mode 100644 index 0000000..064a965 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.Reactive.Cycle.cs @@ -0,0 +1,34 @@ +using CodeCasa.AutomationPipelines.Lights.Cycle; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Pipeline; + +internal partial class LightTransitionPipelineConfigurator +{ + public ILightTransitionPipelineConfigurator AddCycle(IObservable triggerObservable, IEnumerable lightParameters) + { + return AddReactiveNode(c => c.AddCycle(triggerObservable, lightParameters)); + } + + public ILightTransitionPipelineConfigurator AddCycle(IObservable triggerObservable, + params LightParameters[] lightParameters) + { + return AddReactiveNode(c => c.AddCycle(triggerObservable, lightParameters)); + } + + public ILightTransitionPipelineConfigurator AddCycle(IObservable triggerObservable, IEnumerable lightTransitions) + { + return AddReactiveNode(c => c.AddCycle(triggerObservable, lightTransitions)); + } + + public ILightTransitionPipelineConfigurator AddCycle(IObservable triggerObservable, + params LightTransition[] lightTransitions) + { + return AddReactiveNode(c => c.AddCycle(triggerObservable, lightTransitions)); + } + + public ILightTransitionPipelineConfigurator AddCycle(IObservable triggerObservable, Action configure) + { + return AddReactiveNode(c => c.AddCycle(triggerObservable, configure)); + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.Reactive.Toggle.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.Reactive.Toggle.cs new file mode 100644 index 0000000..c81a7d8 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.Reactive.Toggle.cs @@ -0,0 +1,57 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Toggle; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Pipeline; + +internal partial class LightTransitionPipelineConfigurator +{ + /// + public ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + IEnumerable lightParameters) + { + return AddReactiveNode(c => c.AddToggle(triggerObservable, lightParameters)); + } + + /// + public ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + params LightParameters[] lightParameters) + { + return AddReactiveNode(c => c.AddToggle(triggerObservable, lightParameters)); + } + + /// + public ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + IEnumerable lightTransitions) + { + return AddReactiveNode(c => c.AddToggle(triggerObservable, lightTransitions)); + } + + /// + public ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + params LightTransition[] lightTransitions) + { + return AddReactiveNode(c => c.AddToggle(triggerObservable, lightTransitions)); + } + + /// + public ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + IEnumerable>> nodeFactories) + { + return AddReactiveNode(c => c.AddToggle(triggerObservable, nodeFactories)); + } + + /// + public ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + params Func>[] nodeFactories) + { + return AddReactiveNode(c => c.AddToggle(triggerObservable, nodeFactories)); + } + + /// + public ILightTransitionPipelineConfigurator AddToggle(IObservable triggerObservable, + Action configure) + { + return AddReactiveNode(c => c.AddToggle(triggerObservable, configure)); + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.Switch.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.Switch.cs new file mode 100644 index 0000000..9294ed2 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.Switch.cs @@ -0,0 +1,146 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.Nodes; +using CodeCasa.AutomationPipelines.Lights.ReactiveNode; +using System.Reactive.Concurrency; +using System.Reactive.Linq; +using CodeCasa.Lights; +using Microsoft.Extensions.DependencyInjection; + +namespace CodeCasa.AutomationPipelines.Lights.Pipeline; + +internal partial class LightTransitionPipelineConfigurator +{ + /// + public ILightTransitionPipelineConfigurator Switch(LightParameters trueLightParameters, + LightParameters falseLightParameters) where TObservable : IObservable + { + return Switch(trueLightParameters.AsTransition(), falseLightParameters.AsTransition()); + } + + /// + public ILightTransitionPipelineConfigurator Switch(IObservable observable, LightParameters trueLightParameters, + LightParameters falseLightParameters) + { + return Switch(observable, trueLightParameters.AsTransition(), falseLightParameters.AsTransition()); + } + + /// + public ILightTransitionPipelineConfigurator Switch(Func trueLightParametersFactory, + Func falseLightParametersFactory) where TObservable : IObservable + { + return Switch(c => falseLightParametersFactory(c).AsTransition(), c => trueLightParametersFactory(c).AsTransition()); + } + + /// + public ILightTransitionPipelineConfigurator Switch(IObservable observable, Func trueLightParametersFactory, + Func falseLightParametersFactory) + { + return Switch(observable, c => trueLightParametersFactory(c).AsTransition(), c => falseLightParametersFactory(c).AsTransition()); + } + + /// + public ILightTransitionPipelineConfigurator Switch(LightTransition trueLightTransition, + LightTransition falseLightTransition) where TObservable : IObservable + { + return Switch(trueLightTransition, falseLightTransition); + } + + /// + public ILightTransitionPipelineConfigurator Switch(IObservable observable, LightTransition trueLightTransition, + LightTransition falseLightTransition) + { + return Switch(observable, trueLightTransition, falseLightTransition); + } + + /// + public ILightTransitionPipelineConfigurator Switch(Func trueLightTransitionFactory, + Func falseLightTransitionFactory) where TObservable : IObservable + { + return Switch( + c => new StaticLightTransitionNode(trueLightTransitionFactory(c), c.ServiceProvider.GetRequiredService()), + c => new StaticLightTransitionNode(falseLightTransitionFactory(c), c.ServiceProvider.GetRequiredService())); + } + + /// + public ILightTransitionPipelineConfigurator Switch(IObservable observable, Func trueLightTransitionFactory, + Func falseLightTransitionFactory) + { + return Switch( + observable, + c => new StaticLightTransitionNode(trueLightTransitionFactory(c), c.ServiceProvider.GetRequiredService()), + c => new StaticLightTransitionNode(falseLightTransitionFactory(c), c.ServiceProvider.GetRequiredService())); + } + + /// + public ILightTransitionPipelineConfigurator Switch(Func> trueNodeFactory, Func> falseNodeFactory) where TObservable : IObservable + { + var observable = serviceProvider.CreateInstanceWithinContext(Light); + return Switch(observable, trueNodeFactory, falseNodeFactory); + } + + /// + public ILightTransitionPipelineConfigurator Switch(IObservable observable, Func> trueNodeFactory, + Func> falseNodeFactory) + { + return AddReactiveNode(c => c + .On(observable.Where(x => x), trueNodeFactory) + .On(observable.Where(x => !x), falseNodeFactory)); + } + + /// + public ILightTransitionPipelineConfigurator Switch() where TObservable : IObservable where TTrueNode : IPipelineNode where TFalseNode : IPipelineNode + { + var observable = serviceProvider.CreateInstanceWithinContext(Light); + return Switch(observable); + } + + /// + public ILightTransitionPipelineConfigurator Switch(IObservable observable) where TTrueNode : IPipelineNode where TFalseNode : IPipelineNode + { + return AddReactiveNode(c => c + .On(observable.Where(x => x)) + .On(observable.Where(x => !x))); + } + + /// + public ILightTransitionPipelineConfigurator AddReactiveNodeSwitch(Action trueConfigure, Action falseConfigure) where TObservable : IObservable + { + var observable = serviceProvider.CreateInstanceWithinContext(Light); + return AddReactiveNodeSwitch(observable, trueConfigure, falseConfigure); + } + + /// + public ILightTransitionPipelineConfigurator AddReactiveNodeSwitch(IObservable observable, Action trueConfigure, + Action falseConfigure) + { + return AddReactiveNode(c => c + .On(observable.Where(x => x), trueConfigure) + .On(observable.Where(x => !x), falseConfigure)); + } + + /// + public ILightTransitionPipelineConfigurator AddPipelineSwitch(Action trueConfigure, Action falseConfigure) where TObservable : IObservable + { + return Switch(c => lightPipelineFactory.CreateLightPipeline(c.Light, trueConfigure), c => lightPipelineFactory.CreateLightPipeline(c.Light, falseConfigure)); + } + + /// + public ILightTransitionPipelineConfigurator AddPipelineSwitch(IObservable observable, Action trueConfigure, + Action falseConfigure) + { + return Switch(observable, c => lightPipelineFactory.CreateLightPipeline(c.Light, trueConfigure), c => lightPipelineFactory.CreateLightPipeline(c.Light, falseConfigure)); + } + + /// + public ILightTransitionPipelineConfigurator TurnOnOff() where TObservable : IObservable + { + return Switch(LightTransition.On(), LightTransition.Off()); + } + + /// + public ILightTransitionPipelineConfigurator TurnOnOff(IObservable observable) + { + return Switch(observable, LightTransition.On(), LightTransition.Off()); + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.When.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.When.cs new file mode 100644 index 0000000..c2616f2 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.When.cs @@ -0,0 +1,155 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.Nodes; +using CodeCasa.AutomationPipelines.Lights.ReactiveNode; +using System.Reactive.Concurrency; +using System.Reactive.Linq; +using CodeCasa.Lights; +using Microsoft.Extensions.DependencyInjection; + +namespace CodeCasa.AutomationPipelines.Lights.Pipeline; + +internal partial class LightTransitionPipelineConfigurator +{ + /// + public ILightTransitionPipelineConfigurator When(LightParameters lightParameters) + where TObservable : IObservable + { + return When(lightParameters.AsTransition()); + } + + /// + public ILightTransitionPipelineConfigurator When(IObservable observable, + LightParameters lightParameters) + { + return When(observable, lightParameters.AsTransition()); + } + + /// + public ILightTransitionPipelineConfigurator When( + Func lightParametersFactory) where TObservable : IObservable + { + return When(c => lightParametersFactory(c).AsTransition()); + } + + /// + public ILightTransitionPipelineConfigurator When(IObservable observable, + Func lightParametersFactory) + { + return When(observable, c => lightParametersFactory(c).AsTransition()); + } + + /// + public ILightTransitionPipelineConfigurator When(LightTransition lightTransition) + where TObservable : IObservable + { + return When(_ => lightTransition); + } + + /// + public ILightTransitionPipelineConfigurator When(IObservable observable, + LightTransition lightTransition) + { + return When(observable, _ => lightTransition); + } + + /// + public ILightTransitionPipelineConfigurator When( + Func lightTransitionFactory) where TObservable : IObservable + { + return When(c => new StaticLightTransitionNode(lightTransitionFactory(c), c.ServiceProvider.GetRequiredService())); + } + + /// + public ILightTransitionPipelineConfigurator When(IObservable observable, + Func lightTransitionFactory) + { + return When(observable, c => new StaticLightTransitionNode(lightTransitionFactory(c), c.ServiceProvider.GetRequiredService())); + } + + /// + public ILightTransitionPipelineConfigurator When( + Func> nodeFactory) where TObservable : IObservable + { + var observable = serviceProvider.CreateInstanceWithinContext(Light); + return When(observable, nodeFactory); + } + + /// + public ILightTransitionPipelineConfigurator When(IObservable observable, + Func> nodeFactory) + { + return AddReactiveNode(c => c + .On(observable.Where(x => x), nodeFactory) + .PassThroughOn(observable.Where(x => !x))); + } + + /// + public ILightTransitionPipelineConfigurator When() + where TObservable : IObservable + where TNode : IPipelineNode + { + var observable = serviceProvider.CreateInstanceWithinContext(Light); + return When(observable); + } + + /// + public ILightTransitionPipelineConfigurator When(IObservable observable) + where TNode : IPipelineNode + { + return AddReactiveNode(c => c + .On(observable.Where(x => x)) + .PassThroughOn(observable.Where(x => !x))); + } + + /// + public ILightTransitionPipelineConfigurator AddReactiveNodeWhen(Action configure) where TObservable : IObservable + { + var observable = serviceProvider.CreateInstanceWithinContext(Light); + return AddReactiveNodeWhen(observable, configure); + } + + /// + public ILightTransitionPipelineConfigurator AddReactiveNodeWhen(IObservable observable, Action configure) + { + return AddReactiveNode(c => c + .On(observable.Where(x => x), configure) + .PassThroughOn(observable.Where(x => !x))); + } + + /// + public ILightTransitionPipelineConfigurator AddPipelineWhen(Action pipelineConfigurator) where TObservable : IObservable + { + return When(c => lightPipelineFactory.CreateLightPipeline(c.Light, pipelineConfigurator)); + } + + /// + public ILightTransitionPipelineConfigurator AddPipelineWhen(IObservable observable, Action pipelineConfigurator) + { + return When(observable, c => lightPipelineFactory.CreateLightPipeline(c.Light, pipelineConfigurator)); + } + + /// + public ILightTransitionPipelineConfigurator TurnOffWhen() where TObservable : IObservable + { + return When(LightTransition.Off()); + } + + /// + public ILightTransitionPipelineConfigurator TurnOffWhen(IObservable observable) + { + return When(observable, LightTransition.Off()); + } + + /// + public ILightTransitionPipelineConfigurator TurnOnWhen() where TObservable : IObservable + { + return When(LightTransition.On()); + } + + /// + public ILightTransitionPipelineConfigurator TurnOnWhen(IObservable observable) + { + return When(observable, LightTransition.On()); + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.cs b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.cs new file mode 100644 index 0000000..60153b1 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Pipeline/LightTransitionPipelineConfigurator.cs @@ -0,0 +1,116 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.ReactiveNode; +using System.Reactive.Concurrency; +using CodeCasa.Abstractions; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Pipeline +{ + /// + /// Configures a light transition pipeline for a single light entity. + /// This configurator allows adding pipeline nodes, reactive nodes, dimmers, and conditional logic to light automation. + /// + internal partial class LightTransitionPipelineConfigurator( + IServiceProvider serviceProvider, + LightPipelineFactory lightPipelineFactory, + ReactiveNodeFactory reactiveNodeFactory, + ILight light) + : ILightTransitionPipelineConfigurator + { + private readonly List> _nodes = new(); + + internal ILight Light { get; } = light; + internal string? Name { get; private set; } + + public IReadOnlyCollection> Nodes => _nodes.AsReadOnly(); + + public ILightTransitionPipelineConfigurator + AddConditional(IObservable observable, Action trueConfigure, Action falseConfigure) + { + throw new NotImplementedException(); + } + + /// + public ILightTransitionPipelineConfigurator SetName(string name) + { + Name = name; + return this; + } + + /// + public ILightTransitionPipelineConfigurator AddNode() where TNode : IPipelineNode + { + _nodes.Add(serviceProvider.CreateInstanceWithinContext(Light)); + return this; + } + + /// + /// Adds a pipeline node to the pipeline. + /// + /// The pipeline node to add. + /// The configurator instance for method chaining. + public ILightTransitionPipelineConfigurator AddNode(IPipelineNode node) + { + _nodes.Add(node); + return this; + } + + /// + public ILightTransitionPipelineConfigurator AddNode(Func> nodeFactory) + { + _nodes.Add(nodeFactory(new LightPipelineContext(serviceProvider, Light))); + return this; + } + + /// + public ILightTransitionPipelineConfigurator AddReactiveNode( + Action configure) + { + return AddNode(reactiveNodeFactory.CreateReactiveNode(Light, configure)); + } + + /// + public ILightTransitionPipelineConfigurator AddDimmer(IDimmer dimmer) + { + return AddDimmer(dimmer, _ => { }); + } + + /// + public ILightTransitionPipelineConfigurator AddDimmer(IDimmer dimmer, Action dimOptions) + { + return AddReactiveNode(c => + { + c.AddUncoupledDimmer(dimmer, dimOptions); + }); + } + + /// + public ILightTransitionPipelineConfigurator ForLight(string lightId, + Action compositeNodeBuilder) => + ForLights([lightId], compositeNodeBuilder); + + /// + public ILightTransitionPipelineConfigurator ForLight(ILight light, + Action compositeNodeBuilder) => ForLights([light], compositeNodeBuilder); + + /// + public ILightTransitionPipelineConfigurator ForLights(IEnumerable lightIds, + Action compositeNodeBuilder) + { + CompositeHelper.ValidateLightSupported(lightIds, Light.Id); + return this; + } + + /// + public ILightTransitionPipelineConfigurator ForLights(IEnumerable lightEntities, + Action compositeNodeBuilder) + { + CompositeHelper.ResolveGroupsAndValidateLightSupported(lightEntities, Light.Id); + return this; + } + + /// + public ILightTransitionPipelineConfigurator AddPipeline(Action pipelineNodeOptions) => AddNode(lightPipelineFactory.CreateLightPipeline(Light, pipelineNodeOptions)); + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/CompositeLightTransitionReactiveNodeConfigurator.Cycle.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/CompositeLightTransitionReactiveNodeConfigurator.Cycle.cs new file mode 100644 index 0000000..cf08992 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/CompositeLightTransitionReactiveNodeConfigurator.Cycle.cs @@ -0,0 +1,63 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Cycle; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.Nodes; +using CodeCasa.Lights; +using Microsoft.Extensions.DependencyInjection; + +namespace CodeCasa.AutomationPipelines.Lights.ReactiveNode; + +internal partial class CompositeLightTransitionReactiveNodeConfigurator +{ + /// + public ILightTransitionReactiveNodeConfigurator AddCycle(IObservable triggerObservable, IEnumerable lightParameters) + => AddCycle(triggerObservable, lightParameters.ToArray()); + + /// + public ILightTransitionReactiveNodeConfigurator AddCycle(IObservable triggerObservable, + params LightParameters[] lightParameters) + { + return AddCycle(triggerObservable, configure => + { + foreach (var lp in lightParameters) + { + configure.Add(lp); + } + }); + } + + /// + public ILightTransitionReactiveNodeConfigurator AddCycle(IObservable triggerObservable, IEnumerable lightTransitions) + => AddCycle(triggerObservable, lightTransitions.ToArray()); + + /// + public ILightTransitionReactiveNodeConfigurator AddCycle(IObservable triggerObservable, + params LightTransition[] lightTransitions) + { + return AddCycle(triggerObservable, configure => + { + foreach (var lt in lightTransitions) + { + configure.Add(lt); + } + }); + } + + /// + public ILightTransitionReactiveNodeConfigurator AddCycle(IObservable triggerObservable, Action configure) + { + var cycleConfigurators = configurators.ToDictionary(kvp => kvp.Key, + kvp => new LightTransitionCycleConfigurator(kvp.Value.Light, scheduler)); + var compositeCycleConfigurator = new CompositeLightTransitionCycleConfigurator(cycleConfigurators, []); + configure(compositeCycleConfigurator); + configurators.ForEach(kvp => kvp.Value.AddNodeSource(triggerObservable.ToCycleObservable(cycleConfigurators[kvp.Key].CycleNodeFactories.Select(tuple => + { + var serviceScope = serviceProvider.CreateScope(); + var context = new LightPipelineContext(serviceScope.ServiceProvider, kvp.Value.Light); + var factory = new Func>(() => new ScopedNode(serviceScope, tuple.nodeFactory(context))); + var valueIsActiveFunc = () => tuple.matchesNodeState(context); + return (factory, valueIsActiveFunc); + })))); + return this; + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/CompositeLightTransitionReactiveNodeConfigurator.On.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/CompositeLightTransitionReactiveNodeConfigurator.On.cs new file mode 100644 index 0000000..38299aa --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/CompositeLightTransitionReactiveNodeConfigurator.On.cs @@ -0,0 +1,82 @@ +using System.Reactive.Concurrency; +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.Nodes; +using CodeCasa.AutomationPipelines.Lights.Pipeline; +using CodeCasa.Lights; +using Microsoft.Extensions.DependencyInjection; + +namespace CodeCasa.AutomationPipelines.Lights.ReactiveNode; + +internal partial class CompositeLightTransitionReactiveNodeConfigurator +{ + /// + public ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, LightParameters lightParameters) + => On(triggerObservable, lightParameters.AsTransition()); + + /// + public ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, Func lightParametersFactory) + => On(triggerObservable, c => lightParametersFactory(c).AsTransition()); + + /// + public ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, LightTransition lightTransition) + => On(triggerObservable, c => new StaticLightTransitionNode(lightTransition, c.ServiceProvider.GetRequiredService())); + + /// + public ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, Func lightTransitionFactory) + => On(triggerObservable, c => new StaticLightTransitionNode(lightTransitionFactory(c), c.ServiceProvider.GetRequiredService())); + + /// + public ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable) where TNode : IPipelineNode + { + configurators.Values.ForEach(c => c.On(triggerObservable)); + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, Func> nodeFactory) + { + configurators.Values.ForEach(c => c.On(triggerObservable, nodeFactory)); + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, Action pipelineConfigurator) + { + // Note: we create the pipeline in composite context so all configuration is also applied in that context. + var pipelines = lightPipelineFactory.CreateLightPipelines(configurators.Values.Select(c => c.Light), + pipelineConfigurator); + configurators.Values.ForEach(c => c.On(triggerObservable, ctx => pipelines[ctx.Light.Id])); + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, Action configure) + { + // Note: we create the pipeline in composite context so all configuration is also applied in that context. + var nodes = reactiveNodeFactory.CreateReactiveNodes(configurators.Values.Select(c => c.Light), + configure); + configurators.Values.ForEach(c => c.On(triggerObservable, ctx => nodes[ctx.Light.Id])); + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator PassThroughOn(IObservable triggerObservable) + { + configurators.Values.ForEach(c => c.PassThroughOn(triggerObservable)); + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator TurnOffWhen(IObservable triggerObservable) + { + configurators.Values.ForEach(c => c.TurnOffWhen(triggerObservable)); + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator TurnOnWhen(IObservable triggerObservable) + { + return On(triggerObservable, LightTransition.On()); + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/CompositeLightTransitionReactiveNodeConfigurator.Toggle.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/CompositeLightTransitionReactiveNodeConfigurator.Toggle.cs new file mode 100644 index 0000000..1d4762b --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/CompositeLightTransitionReactiveNodeConfigurator.Toggle.cs @@ -0,0 +1,86 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.Nodes; +using CodeCasa.AutomationPipelines.Lights.Toggle; +using CodeCasa.Lights; +using CodeCasa.Lights.Extensions; +using Microsoft.Extensions.DependencyInjection; + +namespace CodeCasa.AutomationPipelines.Lights.ReactiveNode; + +internal partial class CompositeLightTransitionReactiveNodeConfigurator +{ + /// + public ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, IEnumerable lightParameters) + => AddToggle(triggerObservable, lightParameters.ToArray()); + + /// + public ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, + params LightParameters[] lightParameters) + { + return AddToggle(triggerObservable, configure => + { + foreach (var lightParameter in lightParameters) + { + configure.Add(lightParameter); + } + }); + } + + /// + public ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, IEnumerable lightTransitions) + => AddToggle(triggerObservable, lightTransitions.ToArray()); + + /// + public ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, + params LightTransition[] lightTransitions) + { + return AddToggle(triggerObservable, configure => + { + foreach (var lightTransition in lightTransitions) + { + configure.Add(lightTransition); + } + }); + } + + /// + public ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, IEnumerable>> nodeFactories) + => AddToggle(triggerObservable, nodeFactories.ToArray()); + + /// + public ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, params Func>[] nodeFactories) + { + return AddToggle(triggerObservable, configure => + { + foreach (var fact in nodeFactories) + { + configure.Add(fact); + } + }); + } + + /// + public ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, Action configure) + { + var toggleConfigurators = configurators.ToDictionary(kvp => kvp.Key, + kvp => new LightTransitionToggleConfigurator(kvp.Value.Light, scheduler)); + var compositeCycleConfigurator = new CompositeLightTransitionToggleConfigurator(toggleConfigurators, []); + configure(compositeCycleConfigurator); + configurators.ForEach(kvp => kvp.Value.AddNodeSource(triggerObservable.ToToggleObservable( + () => configurators.Values.Any(c => c.Light.IsOn()), + () => new TurnOffThenPassThroughNode(), + toggleConfigurators[kvp.Key].NodeFactories.Select(fact => + { + return new Func>(() => + { + var serviceScope = serviceProvider.CreateScope(); + var context = new LightPipelineContext(serviceScope.ServiceProvider, kvp.Value.Light); + return new ScopedNode(serviceScope, fact(context)); + }); + }), + toggleConfigurators[kvp.Key].ToggleTimeout ?? TimeSpan.FromMilliseconds(1000), + toggleConfigurators[kvp.Key].IncludeOffValue))); + return this; + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/CompositeLightTransitionReactiveNodeConfigurator.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/CompositeLightTransitionReactiveNodeConfigurator.cs new file mode 100644 index 0000000..20efd58 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/CompositeLightTransitionReactiveNodeConfigurator.cs @@ -0,0 +1,107 @@ +using System.Reactive.Concurrency; +using CodeCasa.Abstractions; +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.Pipeline; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.ReactiveNode; + +/// +/// Configures light transition reactive nodes for multiple light entities as a composite. +/// This configurator applies configurations across all included lights and allows for selective scoping to subsets of lights. +/// +internal partial class CompositeLightTransitionReactiveNodeConfigurator( + IServiceProvider serviceProvider, + LightPipelineFactory lightPipelineFactory, + ReactiveNodeFactory reactiveNodeFactory, + Dictionary configurators, + IScheduler scheduler) + : ILightTransitionReactiveNodeConfigurator +{ + /// + public ILightTransitionReactiveNodeConfigurator SetName(string name) + { + configurators.Values.ForEach(c => c.SetName(name)); + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator AddReactiveDimmer(IDimmer dimmer) + { + foreach (var configurator in configurators) + { + configurator.Value.AddReactiveDimmer(dimmer); + } + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator SetReactiveDimmerOptions(DimmerOptions dimmerOptions) + { + foreach (var configurator in configurators) + { + configurator.Value.SetReactiveDimmerOptions(dimmerOptions); + } + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator AddUncoupledDimmer(IDimmer dimmer) + { + return AddUncoupledDimmer(dimmer, _ => { }); + } + + /// + public ILightTransitionReactiveNodeConfigurator AddUncoupledDimmer(IDimmer dimmer, Action dimOptions) + { + // todo: support. + throw new NotSupportedException(); + } + + /// + public ILightTransitionReactiveNodeConfigurator AddNodeSource(IObservable?>> nodeFactorySource) + { + configurators.Values.ForEach(c => c.AddNodeSource(nodeFactorySource)); + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator ForLight(string lightId, Action configure) => ForLights([lightId], configure); + + /// + public ILightTransitionReactiveNodeConfigurator ForLight(ILight light, Action configure) => ForLights([light], configure); + + /// + public ILightTransitionReactiveNodeConfigurator ForLights(IEnumerable lightIds, Action configure) + { + var lightIdsArray = + CompositeHelper.ValidateLightsSupported(lightIds, configurators.Keys); + + if (lightIdsArray.Length == configurators.Count) + { + configure(this); + return this; + } + if (lightIdsArray.Length == 1) + { + configure(configurators[lightIdsArray.First()]); + return this; + } + + configure(new CompositeLightTransitionReactiveNodeConfigurator( + serviceProvider, + lightPipelineFactory, + reactiveNodeFactory, + configurators + .Where(kvp => lightIdsArray.Contains(kvp.Key)).ToDictionary(kvp => kvp.Key, kvp => kvp.Value), scheduler)); + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator ForLights(IEnumerable lightEntities, Action configure) + { + var lightIds = CompositeHelper.ResolveGroupsAndValidateLightsSupported(lightEntities, configurators.Keys); + return ForLights(lightIds, configure); + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ILightTransitionReactiveNodeConfigurator.Cycle.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ILightTransitionReactiveNodeConfigurator.Cycle.cs new file mode 100644 index 0000000..7b3a004 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ILightTransitionReactiveNodeConfigurator.Cycle.cs @@ -0,0 +1,67 @@ +using CodeCasa.AutomationPipelines.Lights.Cycle; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.ReactiveNode; + +public partial interface ILightTransitionReactiveNodeConfigurator +{ + /// + /// Adds a state-based cycle trigger that rotates through the specified light parameters when triggered by . + /// The cycle advances based on the current light state: if the light matches parameters in the cycle, it advances to the next set. + /// If the current state is not recognized, the cycle starts from the beginning. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers cycling to the next parameters. + /// The collection of light parameters to cycle through. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator AddCycle(IObservable triggerObservable, + IEnumerable lightParameters); + + /// + /// Adds a state-based cycle trigger that rotates through the specified light parameters when triggered by . + /// The cycle advances based on the current light state: if the light matches parameters in the cycle, it advances to the next set. + /// If the current state is not recognized, the cycle starts from the beginning. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers cycling to the next parameters. + /// The array of light parameters to cycle through. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator AddCycle(IObservable triggerObservable, + params LightParameters[] lightParameters); + + /// + /// Adds a state-based cycle trigger that rotates through the specified light transitions when triggered by . + /// The cycle advances based on the current light state: if the light matches a transition in the cycle, it advances to the next transition. + /// If the current state is not recognized, the cycle starts from the beginning. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers cycling to the next transition. + /// The collection of light transitions to cycle through. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator AddCycle(IObservable triggerObservable, + IEnumerable lightTransitions); + + /// + /// Adds a state-based cycle trigger that rotates through the specified light transitions when triggered by . + /// The cycle advances based on the current light state: if the light matches a transition in the cycle, it advances to the next transition. + /// If the current state is not recognized, the cycle starts from the beginning. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers cycling to the next transition. + /// The array of light transitions to cycle through. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator AddCycle(IObservable triggerObservable, + params LightTransition[] lightTransitions); + + /// + /// Adds a state-based cycle trigger configured by the specified action when triggered by . + /// The cycle advances based on the current light state: if the light matches a state in the cycle, it advances to the next state. + /// If the current state is not recognized, the cycle starts from the beginning. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers cycling to the next state. + /// An action to configure the cycle behavior. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator AddCycle(IObservable triggerObservable, + Action configure); +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ILightTransitionReactiveNodeConfigurator.On.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ILightTransitionReactiveNodeConfigurator.On.cs new file mode 100644 index 0000000..a3e5fa2 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ILightTransitionReactiveNodeConfigurator.On.cs @@ -0,0 +1,114 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Pipeline; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.ReactiveNode; + +public partial interface ILightTransitionReactiveNodeConfigurator +{ + /// + /// Registers a trigger that applies the given when the emits a value. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers the light parameter application. + /// The light parameters to apply when triggered. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, + LightParameters lightParameters); + + /// + /// Registers a trigger that applies light parameters created by when the emits a value. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers the light parameter application. + /// A factory function that creates light parameters based on the pipeline context. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, + Func lightParametersFactory); + + /// + /// Registers a trigger that applies the given when the emits a value. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers the light transition application. + /// The light transition to apply when triggered. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, + LightTransition lightTransition); + + /// + /// Registers a trigger that applies a light transition created by when the emits a value. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers the light transition application. + /// A factory function that creates a light transition based on the pipeline context. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, + Func lightTransitionFactory); + + /// + /// Registers a trigger that activates a pipeline node of type when the emits a value. + /// The node is resolved from the service provider. + /// + /// The type of values emitted by the trigger observable. + /// The type of the pipeline node to resolve and activate. + /// The observable that triggers the node activation. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable) + where TNode : IPipelineNode; + + /// + /// Registers a trigger that activates a pipeline node created by when the emits a value. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers the node activation. + /// A factory function that creates a pipeline node based on the pipeline context. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, + Func> nodeFactory); + + /// + /// Registers a trigger that activates a nested pipeline configured by when the emits a value. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers the pipeline activation. + /// An action to configure the nested pipeline. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, + Action pipelineConfigurator); + + /// + /// Registers a trigger that activates a nested reactive node configured by when the emits a value. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers the reactive node activation. + /// An action to configure the nested reactive node. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, + Action configure); + + /// + /// Registers a pass-through trigger that allows the current input to pass through unchanged when the emits a value. + /// This is useful for conditional logic where you want to maintain the current state under certain conditions. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers the pass-through behavior. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator PassThroughOn(IObservable triggerObservable); + + /// + /// Registers a trigger that turns off the light when the emits a value. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers turning off the light. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator TurnOffWhen(IObservable triggerObservable); + + /// + /// Registers a trigger that turns on the light when the emits a value. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers turning on the light. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator TurnOnWhen(IObservable triggerObservable); +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ILightTransitionReactiveNodeConfigurator.Toggle.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ILightTransitionReactiveNodeConfigurator.Toggle.cs new file mode 100644 index 0000000..7d8b7e9 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ILightTransitionReactiveNodeConfigurator.Toggle.cs @@ -0,0 +1,85 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Toggle; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.ReactiveNode; + +public partial interface ILightTransitionReactiveNodeConfigurator +{ + /// + /// Adds a time-based toggle trigger that switches between the specified light parameters when triggered by . + /// Quick consecutive triggers advance through all parameter sets sequentially. After a timeout period, the next trigger restarts from the beginning. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers toggling to the next parameters. + /// The collection of light parameters to toggle between. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, + IEnumerable lightParameters); + + /// + /// Adds a time-based toggle trigger that switches between the specified light parameters when triggered by . + /// Quick consecutive triggers advance through all parameter sets sequentially. After a timeout period, the next trigger restarts from the beginning. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers toggling to the next parameters. + /// The array of light parameters to toggle between. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, + params LightParameters[] lightParameters); + + /// + /// Adds a time-based toggle trigger that switches between the specified light transitions when triggered by . + /// Quick consecutive triggers advance through all transitions sequentially. After a timeout period, the next trigger restarts from the beginning. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers toggling to the next transition. + /// The collection of light transitions to toggle between. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, + IEnumerable lightTransitions); + + /// + /// Adds a time-based toggle trigger that switches between the specified light transitions when triggered by . + /// Quick consecutive triggers advance through all transitions sequentially. After a timeout period, the next trigger restarts from the beginning. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers toggling to the next transition. + /// The array of light transitions to toggle between. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, + params LightTransition[] lightTransitions); + + /// + /// Adds a time-based toggle trigger that switches between nodes created by the specified factory functions when triggered by . + /// Quick consecutive triggers advance through all node factories sequentially. After a timeout period, the next trigger restarts from the beginning. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers toggling to the next node. + /// The collection of factory functions that create pipeline nodes. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, + IEnumerable>> nodeFactories); + + /// + /// Adds a time-based toggle trigger that switches between nodes created by the specified factory functions when triggered by . + /// Quick consecutive triggers advance through all node factories sequentially. After a timeout period, the next trigger restarts from the beginning. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers toggling to the next node. + /// The array of factory functions that create pipeline nodes. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, + params Func>[] nodeFactories); + + /// + /// Adds a time-based toggle trigger configured by the specified action when triggered by . + /// Quick consecutive triggers advance through all configured states sequentially. After a timeout period, the next trigger restarts from the beginning. + /// + /// The type of values emitted by the trigger observable. + /// The observable that triggers toggling to the next state. + /// An action to configure the toggle behavior. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, + Action configure); +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ILightTransitionReactiveNodeConfigurator.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ILightTransitionReactiveNodeConfigurator.cs new file mode 100644 index 0000000..29742dd --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ILightTransitionReactiveNodeConfigurator.cs @@ -0,0 +1,100 @@ +using CodeCasa.Abstractions; +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.ReactiveNode; + +/// +/// Configures a light transition reactive node for controlling light behavior through reactive event handling. +/// Supports adding reactive dimmers, uncoupled dimmers, dynamic node sources, and scoped configurations. +/// +public partial interface ILightTransitionReactiveNodeConfigurator +{ + /// + /// Sets the name for the current reactive node configuration. + /// + /// The name to assign to the reactive node. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator SetName(string name); + + /// + /// Adds a reactive dimmer control that will be reset when the reactive node activates a new node. + /// Responds to dimmer events and adjusts light parameters accordingly. + /// Multiple reactive dimmers can be added and will behave as a group. + /// + /// The dimmer device to add to the reactive node. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator AddReactiveDimmer(IDimmer dimmer); + + /// + /// Sets the configuration options for reactive dimmer controls in this node. + /// + /// The dimmer options to configure dimmer behavior. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator SetReactiveDimmerOptions(DimmerOptions dimmerOptions); + + /// + /// Adds an uncoupled dimmer control that operates independently without being affected by the reactive node's behavior. + /// The dimmer will not be reset when the reactive node activates a new node. + /// + /// The dimmer device to add as an uncoupled control. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator AddUncoupledDimmer(IDimmer dimmer); + + /// + /// Adds an uncoupled dimmer control with custom configuration options. + /// The dimmer operates independently without being affected by the reactive node's behavior. + /// The dimmer will not be reset when the reactive node activates a new node. + /// + /// The dimmer device to add as an uncoupled control. + /// An action to configure the dimmer options. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator AddUncoupledDimmer(IDimmer dimmer, Action dimOptions); + + /// + /// Adds a dynamic node source that activates a new node in the reactive node each time the observable emits a factory. + /// The emitted factory is invoked to create and activate the new pipeline node. + /// + /// An observable that emits factory functions for creating pipeline nodes. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator + AddNodeSource( + IObservable?>> + nodeFactorySource); + + /// + /// Creates a scoped reactive node configuration for a specific light identified by its entity ID. + /// + /// The entity ID of the light to configure. + /// An action to configure the reactive node for this specific light. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator ForLight(string lightId, + Action configure); + + /// + /// Creates a scoped reactive node configuration for a specific light. + /// + /// The light to configure. + /// An action to configure the reactive node for this specific light. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator ForLight(ILight light, + Action configure); + + /// + /// Creates a scoped reactive node configuration for multiple light entities identified by their entity IDs. + /// + /// The entity IDs of the lights to configure. + /// An action to configure the reactive node for these lights. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator ForLights(IEnumerable lightIds, + Action configure); + + /// + /// Creates a scoped reactive node configuration for multiple light entities. + /// + /// The light entities to configure. + /// An action to configure the reactive node for these lights. + /// The configurator instance for method chaining. + ILightTransitionReactiveNodeConfigurator ForLights(IEnumerable lightEntities, + Action configure); +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/LightTransitionReactiveNodeConfigurator.Cycle.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/LightTransitionReactiveNodeConfigurator.Cycle.cs new file mode 100644 index 0000000..019de03 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/LightTransitionReactiveNodeConfigurator.Cycle.cs @@ -0,0 +1,62 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Cycle; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.Nodes; +using CodeCasa.Lights; +using Microsoft.Extensions.DependencyInjection; + +namespace CodeCasa.AutomationPipelines.Lights.ReactiveNode; + +internal partial class LightTransitionReactiveNodeConfigurator +{ + /// + public ILightTransitionReactiveNodeConfigurator AddCycle(IObservable triggerObservable, IEnumerable lightParameters) + => AddCycle(triggerObservable, lightParameters.ToArray()); + + /// + public ILightTransitionReactiveNodeConfigurator AddCycle(IObservable triggerObservable, + params LightParameters[] lightParameters) + { + return AddCycle(triggerObservable, configure => + { + foreach (var lp in lightParameters) + { + configure.Add(lp); + } + }); + } + + /// + public ILightTransitionReactiveNodeConfigurator AddCycle(IObservable triggerObservable, IEnumerable lightTransitions) + => AddCycle(triggerObservable, lightTransitions.ToArray()); + + /// + public ILightTransitionReactiveNodeConfigurator AddCycle(IObservable triggerObservable, + params LightTransition[] lightTransitions) + { + return AddCycle(triggerObservable, configure => + { + foreach (var lt in lightTransitions) + { + configure.Add(lt); + } + }); + } + + /// + public ILightTransitionReactiveNodeConfigurator AddCycle(IObservable triggerObservable, + Action configure) + { + var cycleConfigurator = new LightTransitionCycleConfigurator(Light, scheduler); + configure(cycleConfigurator); + AddNodeSource(triggerObservable.ToCycleObservable(cycleConfigurator.CycleNodeFactories.Select(tuple => + { + var serviceScope = serviceProvider.CreateScope(); + var context = new LightPipelineContext(serviceScope.ServiceProvider, Light); + var factory = new Func>(() => new ScopedNode(serviceScope, tuple.nodeFactory(context))); + var valueIsActiveFunc = () => tuple.matchesNodeState(context); + return (factory, valueIsActiveFunc); + }))); + return this; + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/LightTransitionReactiveNodeConfigurator.On.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/LightTransitionReactiveNodeConfigurator.On.cs new file mode 100644 index 0000000..3dc809c --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/LightTransitionReactiveNodeConfigurator.On.cs @@ -0,0 +1,70 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.Nodes; +using CodeCasa.AutomationPipelines.Lights.Pipeline; +using System.Reactive.Concurrency; +using System.Reactive.Linq; +using CodeCasa.Lights; +using Microsoft.Extensions.DependencyInjection; + +namespace CodeCasa.AutomationPipelines.Lights.ReactiveNode; + +internal partial class LightTransitionReactiveNodeConfigurator +{ + /// + public ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, + LightParameters lightParameters) => On(triggerObservable, lightParameters.AsTransition()); + + /// + public ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, + Func lightParametersFactory) + => On(triggerObservable, c => lightParametersFactory(c).AsTransition()); + + /// + public ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, + LightTransition lightTransition) => + On(triggerObservable, c => new StaticLightTransitionNode(lightTransition, c.ServiceProvider.GetRequiredService())); + + /// + public ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, + Func lightTransitionFactory) + => On(triggerObservable, c => new StaticLightTransitionNode(lightTransitionFactory(c), c.ServiceProvider.GetRequiredService())); + + /// + public ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable) + where TNode : IPipelineNode => + AddNodeSource(triggerObservable.Select(_ => + new Func?>(c => + c.ServiceProvider.CreateInstanceWithinContext(c)))); + + /// + public ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, + Func> nodeFactory) => + AddNodeSource(triggerObservable.Select(_ => nodeFactory)); + + /// + public ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, Action pipelineConfigurator) => On(triggerObservable, c => lightPipelineFactory.CreateLightPipeline(c.Light, pipelineConfigurator)); + + /// + public ILightTransitionReactiveNodeConfigurator On(IObservable triggerObservable, Action configure) => On(triggerObservable, c => reactiveNodeFactory.CreateReactiveNode(c.Light, configure)); + + /// + public ILightTransitionReactiveNodeConfigurator PassThroughOn(IObservable triggerObservable) + { + AddNodeSource(triggerObservable.Select(_ => new PassThroughNode())); + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator TurnOffWhen(IObservable triggerObservable) + { + AddNodeSource(triggerObservable.Select(_ => new TurnOffThenPassThroughNode())); + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator TurnOnWhen(IObservable triggerObservable) + { + return On(triggerObservable, LightTransition.On()); + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/LightTransitionReactiveNodeConfigurator.Toggle.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/LightTransitionReactiveNodeConfigurator.Toggle.cs new file mode 100644 index 0000000..d9b56ed --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/LightTransitionReactiveNodeConfigurator.Toggle.cs @@ -0,0 +1,84 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.Nodes; +using CodeCasa.AutomationPipelines.Lights.Toggle; +using CodeCasa.Lights; +using CodeCasa.Lights.Extensions; +using Microsoft.Extensions.DependencyInjection; + +namespace CodeCasa.AutomationPipelines.Lights.ReactiveNode; + +internal partial class LightTransitionReactiveNodeConfigurator +{ + /// + public ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, IEnumerable lightParameters) + => AddToggle(triggerObservable, lightParameters.ToArray()); + + /// + public ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, + params LightParameters[] lightParameters) + { + return AddToggle(triggerObservable, configure => + { + foreach (var lightParameter in lightParameters) + { + configure.Add(lightParameter); + } + }); + } + + /// + public ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, IEnumerable lightTransitions) + => AddToggle(triggerObservable, lightTransitions.ToArray()); + + /// + public ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, + params LightTransition[] lightTransitions) + { + return AddToggle(triggerObservable, configure => + { + foreach (var lightTransition in lightTransitions) + { + configure.Add(lightTransition); + } + }); + } + + /// + public ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, IEnumerable>> nodeFactories) + => AddToggle(triggerObservable, nodeFactories.ToArray()); + + /// + public ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, params Func>[] nodeFactories) + { + return AddToggle(triggerObservable, configure => + { + foreach (var fact in nodeFactories) + { + configure.Add(fact); + } + }); + } + + /// + public ILightTransitionReactiveNodeConfigurator AddToggle(IObservable triggerObservable, Action configure) + { + var toggleConfigurator = new LightTransitionToggleConfigurator(Light, scheduler); + configure(toggleConfigurator); + AddNodeSource(triggerObservable.ToToggleObservable( + () => Light.IsOn(), + () => new TurnOffThenPassThroughNode(), + toggleConfigurator.NodeFactories.Select(fact => + { + return new Func>(() => + { + var serviceScope = serviceProvider.CreateScope(); + var context = new LightPipelineContext(serviceScope.ServiceProvider, Light); + return new ScopedNode(serviceScope, fact(context)); + }); + }), + toggleConfigurator.ToggleTimeout ?? TimeSpan.FromMilliseconds(1000), + toggleConfigurator.IncludeOffValue)); + return this; + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/LightTransitionReactiveNodeConfigurator.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/LightTransitionReactiveNodeConfigurator.cs new file mode 100644 index 0000000..2393404 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/LightTransitionReactiveNodeConfigurator.cs @@ -0,0 +1,128 @@ +using System.Reactive; +using System.Reactive.Concurrency; +using System.Reactive.Linq; +using CodeCasa.Abstractions; +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.Nodes; +using CodeCasa.AutomationPipelines.Lights.Pipeline; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.ReactiveNode; + +/// +/// Configures a light transition reactive node for a single light. +/// This configurator allows adding reactive dimmer controls, node sources, and scoped configurations for light automation. +/// +internal partial class LightTransitionReactiveNodeConfigurator( + IServiceProvider serviceProvider, + LightPipelineFactory lightPipelineFactory, + ReactiveNodeFactory reactiveNodeFactory, + ILight light, + IScheduler scheduler) : ILightTransitionReactiveNodeConfigurator +{ + /// + /// Gets the light associated with this configurator. + /// + public ILight Light { get; } = light; + + internal string? Name { get; private set; } + internal List?>> NodeObservables { get; } = new(); + internal List Dimmers { get; } = new(); + internal DimmerOptions DimmerOptions { get; private set; } = new (); + + /// + public ILightTransitionReactiveNodeConfigurator SetName(string name) + { + Name = name; + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator AddReactiveDimmer(IDimmer dimmer) + { + Dimmers.Add(dimmer); + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator SetReactiveDimmerOptions(DimmerOptions dimmerOptions) + { + DimmerOptions = dimmerOptions; + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator AddUncoupledDimmer(IDimmer dimmer) + { + return AddUncoupledDimmer(dimmer, _ => { }); + } + + /// + public ILightTransitionReactiveNodeConfigurator AddUncoupledDimmer(IDimmer dimmer, Action dimOptions) + { + var options = new DimmerOptions(); + dimOptions(options); + options.ValidateSingleLight(Light.Id); + + var dimPulses = dimmer.Dimming.ToPulsesWhenTrue(options.TimeBetweenSteps, scheduler); + var brightenPulses = dimmer.Brightening.ToPulsesWhenTrue(options.TimeBetweenSteps, scheduler); + + AddDimPulses(options, [Light], dimPulses, brightenPulses); + return this; + } + + internal void AddDimPulses(DimmerOptions options, IEnumerable lightsInDimOrder, IObservable dimPulses, IObservable brightenPulses) + { + var dimHelper = new DimHelper(Light, lightsInDimOrder, options.MinBrightness, options.BrightnessStep); + AddNodeSource(dimPulses + .Select(_ => dimHelper.DimStep()) + .Where(t => t != null) + .Select(t => (IPipelineNode)(t == LightTransition.Off() ? new TurnOffThenPassThroughNode() : new StaticLightTransitionNode(t, scheduler)))); + AddNodeSource(brightenPulses + .Select(_ => dimHelper.BrightenStep()) + .Where(t => t != null) + .Select(t => (IPipelineNode)(t == LightTransition.Off() ? new TurnOffThenPassThroughNode() : new StaticLightTransitionNode(t, scheduler)))); + } + + /// + /// Adds a node source observable to the reactive node. + /// + /// An observable that emits pipeline nodes. + /// The configurator instance for method chaining. + public ILightTransitionReactiveNodeConfigurator AddNodeSource(IObservable?> nodeSource) + { + NodeObservables.Add(nodeSource); + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator AddNodeSource(IObservable?>> nodeFactorySource) + { + return AddNodeSource(nodeFactorySource.Select(f => f(new LightPipelineContext(serviceProvider, Light)))); + } + + /// + public ILightTransitionReactiveNodeConfigurator ForLight(string lightId, + Action configure) => ForLights([lightId], configure); + + /// + public ILightTransitionReactiveNodeConfigurator ForLight(ILight light, + Action configure) => ForLights([light], configure); + + /// + public ILightTransitionReactiveNodeConfigurator ForLights(IEnumerable lightIds, + Action configure) + { + CompositeHelper.ValidateLightSupported(lightIds, Light.Id); + return this; + } + + /// + public ILightTransitionReactiveNodeConfigurator ForLights(IEnumerable lightEntities, + Action configure) + { + CompositeHelper.ResolveGroupsAndValidateLightSupported(lightEntities, Light.Id); + return this; + } +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ReactiveDimmerNode.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ReactiveDimmerNode.cs new file mode 100644 index 0000000..8922732 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ReactiveDimmerNode.cs @@ -0,0 +1,226 @@ +using System.Reactive.Concurrency; +using CodeCasa.AutomationPipelines.Lights.Nodes; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.ReactiveNode +{ + /// + /// Represents the context for dimming operations, containing the ordered output parameters of all dimmer nodes. + /// + /// An array of tuples containing entity IDs and their current light parameters, ordered for dimming operations. + public class DimmingContext( + (string entityId, LightParameters? parametersAfterDim)[] dimmerNodeOutputParametersInOrder) + { + /// + /// Gets the ordered output parameters of all dimmer nodes, used to coordinate dimming behavior across multiple lights. + /// + public (string entityId, LightParameters? parametersAfterDim)[] DimmerNodeOutputParametersInOrder { get; } = dimmerNodeOutputParametersInOrder; + } + + /// + /// A light transition node that handles dimming and brightening operations in response to dimmer input. + /// + internal class ReactiveDimmerNode : LightTransitionNode + { + private readonly int _minBrightness; + private readonly int _brightnessStep; + private int _dimSteps; // negative is dimming, positive is brightening. + + /// + /// Initializes a new instance of the class. + /// + /// The reactive node to monitor for state changes. + /// The entity ID of the light this dimmer node controls. + /// The minimum brightness level before the light turns off. + /// The step size for each dimming/brightening increment. + /// The scheduler used for timing operations. + public ReactiveDimmerNode( + ReactiveNode reactiveNode, + string lightId, + int minBrightness, + int brightnessStep, + IScheduler scheduler) : base(scheduler) + { + reactiveNode.NodeChanged.Subscribe(_ => Reset()); + PassThrough = true; + + LightId = lightId; + _minBrightness = minBrightness; + _brightnessStep = brightnessStep; + } + + /// + /// Gets the entity ID of the light this dimmer node controls. + /// + public string LightId { get; } + + /// + /// Resets the dimming state back to pass-through mode. + /// + public void Reset() + { + PassThrough = true; + _dimSteps = 0; + } + + /// + protected override void InputReceived(LightTransition? input) + { + if (input == null) + { + Output = null; + return; + } + + var newBrightness = CalculateBrightness(input.LightParameters.Brightness ?? 0); + Output = input with { LightParameters = input.LightParameters with { Brightness = newBrightness } }; + } + + /// + /// Executes one step of dimming in response to dimmer input. + /// + /// The dimming context containing current light parameters. + public void DimStep(DimmingContext context) + { + if (!ShouldDim(context)) + { + return; + } + _dimSteps--; + if (_dimSteps == 0) + { + PassThrough = true; + return; + } + + ScheduleInterpolatedLightTransition(); + } + + /// + /// Executes one step of brightening in response to dimmer input. + /// + /// The dimming context containing current light parameters. + public void BrightenStep(DimmingContext context) + { + if (!ShouldBrighten(context)) + { + return; + } + _dimSteps++; + if (_dimSteps == 0) + { + PassThrough = true; + return; + } + + ScheduleInterpolatedLightTransition(); + } + + private bool ShouldDim(DimmingContext context) + { + var subjectParameters = context.DimmerNodeOutputParametersInOrder.Single(x => x.entityId == LightId).parametersAfterDim; + var subjectBrightness = subjectParameters?.Brightness ?? 0; + if (subjectBrightness > _minBrightness) + { + // If we are brighter than minimum brightness, we have to dim anyway. + return true; + } + if (subjectBrightness <= 0) + { + return false; + } + // At this point we are at min brightness and have to check if any other light is going to dim. If so, we don't have to. + string? lightToTurnOff = null; + foreach (var (entityId, parametersAfterDim) in context.DimmerNodeOutputParametersInOrder) + { + var brightness = parametersAfterDim?.Brightness ?? 0; + if (brightness == 0) + { + continue; + } + if (brightness > _minBrightness) + { + // If any light is brighter than MinBrightness, we let them dim first. + return false; + } + + lightToTurnOff ??= entityId; + } + + return lightToTurnOff == LightId; + } + + private bool ShouldBrighten(DimmingContext context) + { + var subjectParameters = context.DimmerNodeOutputParametersInOrder.Single(x => x.entityId == LightId).parametersAfterDim; + var subjectBrightness = subjectParameters?.Brightness ?? 0; + if (subjectBrightness > _minBrightness) + { + // If we are brighter than minimum brightness, we have to brighten anyway. + return subjectBrightness < byte.MaxValue; + } + // At this point we are either off or at min brightness and have to check if any other light is going to turn on. If so, we don't have to turn on or brighten. + string? lightToTurnOn = null; + foreach (var (entityId, parametersAfterDim) in context.DimmerNodeOutputParametersInOrder.Reverse()) + { + var brightness = parametersAfterDim?.Brightness ?? 0; + if (brightness >= _minBrightness) // On + { + if (lightToTurnOn != null || brightness > _minBrightness) + { + return false; + } + continue; + } + + lightToTurnOn ??= entityId; + } + + return lightToTurnOn == null || lightToTurnOn == LightId; + } + + private void ScheduleInterpolatedLightTransition() + { + if (Input == null) + { + Output = new LightParameters { Brightness = CalculateBrightness(0) }.AsTransition(); + } + else + { + ScheduleInterpolatedLightTransitionUsingInputTransitionTime( + InputLightSourceParameters == null + ? null + : InputLightSourceParameters with + { + Brightness = CalculateBrightness(InputLightSourceParameters.Brightness ?? 0) + }, + Input.LightParameters with + { + Brightness = CalculateBrightness(Input.LightParameters.Brightness ?? 0) + }); + } + } + + private double? CalculateBrightness(double inputBrightness) + { + var calculatedBrightness = inputBrightness + _brightnessStep * _dimSteps; + if (_dimSteps < 0) + { + // Make sure we always show minimum brightness before turning off. + if (calculatedBrightness <= _minBrightness && calculatedBrightness + _brightnessStep > _minBrightness) + { + return _minBrightness; + } + } + if (_dimSteps > 0) + { + // Make sure we always show minimum brightness after turning on. + if (calculatedBrightness > _minBrightness && calculatedBrightness - _brightnessStep <= _minBrightness) + { + return _minBrightness; + } + } + return Math.Min(byte.MaxValue, Math.Max(0, calculatedBrightness)); + } + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ReactiveNode.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ReactiveNode.cs new file mode 100644 index 0000000..ad3f53a --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ReactiveNode.cs @@ -0,0 +1,121 @@ +using System.Reactive; +using System.Reactive.Linq; +using System.Reactive.Subjects; +using CodeCasa.AutomationPipelines.Lights.Utils; +using CodeCasa.Lights; +using Microsoft.Extensions.Logging; + +namespace CodeCasa.AutomationPipelines.Lights.ReactiveNode; + +/// +/// A pipeline node that dynamically switches between different child nodes based on an observable source. +/// The active node can change at runtime, allowing for reactive behavior switching. +/// +public class ReactiveNode : PipelineNode +{ + private readonly Lock _lock = new(); + private readonly string? _name; + private readonly ILogger? _logger; + private readonly Subject _nodeChangedSubject = new(); + private IPipelineNode? _activeNode; + private IDisposable? _activeNodeSubscription; + + /// + /// Initializes a new instance of the class. + /// + /// Optional name for the reactive node, used for logging purposes. + /// An observable that emits the pipeline nodes to activate. Null values deactivate the current node. + /// Optional logger for diagnostic information. + public ReactiveNode(string? name, IObservable?> nodeObservable, ILogger logger) + { + _name = name; + _logger = logger; + PassThrough = true; + + nodeObservable + .Subscribe(n => + { + lock (_lock) + { + if (n == null) + { + DeactivateActiveNode(); + PassThrough = true; + _logger?.LogTrace($"{LogPrefix}No active node. Passing through data."); + _nodeChangedSubject.OnNext(Unit.Default); + return; + } + + ActivateNode(n); + _nodeChangedSubject.OnNext(Unit.Default); + } + }); + } + + private string LogPrefix => _name == null ? "" : $"{_name}: "; + + /// + /// Gets an observable that emits whenever the active node changes. + /// + public IObservable NodeChanged => _nodeChangedSubject.AsObservable(); + + /// + protected override void InputReceived(LightTransition? input) + { + if (_activeNode == null) + { + return; + } + lock (_lock) + { + if (_activeNode != null) + { + _activeNode.Input = input; + } + } + } + + private void DeactivateActiveNode() + { + _activeNodeSubscription?.Dispose(); + if (_activeNode != null) + { + _activeNode.Input = null; + _activeNode.DisposeOrDisposeAsync().GetAwaiter().GetResult(); + } + + _activeNode = null; + _activeNodeSubscription = null; + } + + private void ActivateNode(IPipelineNode node) + { + DeactivateActiveNode(); + _activeNode = node; + _logger?.LogTrace($"{LogPrefix}Activating {node}."); + // todo: move after input setting? + _activeNodeSubscription = _activeNode.OnNewOutput.Subscribe(output => + { + if (EqualityComparer.Default.Equals(Output, output)) + { + return; + } + lock (_lock) + { + if (!EqualityComparer.Default.Equals(Output, output)) + { + Output = output; + } + } + }); + _activeNode.Input = Input; + if (!EqualityComparer.Default.Equals(Output, _activeNode.Output)) + { + Output = _activeNode.Output; + } + PassThrough = false; + } + + /// + public override string ToString() => _name ?? base.ToString(); +} \ No newline at end of file diff --git a/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ReactiveNodeFactory.cs b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ReactiveNodeFactory.cs new file mode 100644 index 0000000..8135f09 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/ReactiveNode/ReactiveNodeFactory.cs @@ -0,0 +1,264 @@ +using System.Reactive; +using System.Reactive.Concurrency; +using System.Reactive.Disposables; +using System.Reactive.Linq; +using System.Reactive.Subjects; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.Nodes; +using CodeCasa.AutomationPipelines.Lights.Pipeline; +using CodeCasa.Lights; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; + +namespace CodeCasa.AutomationPipelines.Lights.ReactiveNode +{ + /// + /// Factory for creating reactive nodes that dynamically switch between child nodes based on observable inputs. + /// + public class ReactiveNodeFactory(IServiceProvider serviceProvider, IScheduler scheduler) + { + /// + /// Creates a reactive node for a single light. + /// + /// The light to create the reactive node for. + /// An action to configure the reactive node. + /// A configured reactive node for the specified light. + public IPipelineNode CreateReactiveNode(ILight light, Action configure) + { + return CreateReactiveNodes([light], configure)[light.Id]; + } + + /// + /// Creates reactive nodes for multiple light entities. + /// + /// The light entities to create reactive nodes for. + /// An action to configure the reactive nodes. + /// A dictionary mapping light IDs to their corresponding reactive nodes. + internal Dictionary> CreateReactiveNodes(IEnumerable lightEntities, Action configure) + { + // Note: we simply assume that these are not groups. + var lightArray = lightEntities.ToArray(); + if (!lightArray.Any()) + { + return new Dictionary>(); + } + + var lightPipelineFactory = serviceProvider.GetRequiredService(); + var reactiveConfigurators = lightArray.ToDictionary(l => l.Id, l => new LightTransitionReactiveNodeConfigurator(serviceProvider, lightPipelineFactory, + this, l, scheduler)); + ILightTransitionReactiveNodeConfigurator configurator = lightArray.Length == 1 + ? reactiveConfigurators[lightArray[0].Id] + : new CompositeLightTransitionReactiveNodeConfigurator( + serviceProvider, + lightPipelineFactory, + this, + reactiveConfigurators, + scheduler); + configure(configurator); + + /* + * Note: for now this implementation does not support assigning specific dimmers to specific children. + * The nicest way to achieve this would be to create a pulse observable that emits a IDimmer[] for every pulse given, reflecting the dimmers that are currently pushed and providing the pulse. + * This array should then be compared to a dictionary that contains which dimmer node (and entity) relate to which dimmers. + * Then simply build the context and dim/brighten only for those dimmers. + */ + var dimmers = reactiveConfigurators.Values + .SelectMany(rnc => rnc.Dimmers) + .Distinct() + .ToArray(); + + if (!dimmers.Any()) + { + return lightArray.ToDictionary(l => l.Id, l => + { + var reactiveNode = CreateReactiveNode(reactiveConfigurators[l.Id]); + return (IPipelineNode)reactiveNode; + }); + } + + var registrationManager = new RegistrationManager(); + var dimmerNodes = new Dictionary(); + var result = new Dictionary>(); + + foreach (var light in lightArray) + { + var reactiveNodeConfigurator = reactiveConfigurators[light.Id]; + var reactiveNode = CreateReactiveNode(reactiveNodeConfigurator); + var lightDimmerOptions = reactiveNodeConfigurator.DimmerOptions; + + var dimmerNode = new ReactiveDimmerNode( + reactiveNode, + light.Id, + lightDimmerOptions.MinBrightness, + lightDimmerOptions.BrightnessStep, + scheduler); + + dimmerNodes.Add(light.Id, dimmerNode); + var innerPipeline = new ReactiveDimmerPipeline(reactiveNode, dimmerNode, registrationManager); + + result.Add(light.Id, innerPipeline); + } + + /* + * Note: for now this implementation does not support assigning specific dimmers to specific children. + * The same is true for the options. We simply pick the first as all options will be set to the same value. + * If this ever changes, time between steps and entity order should be extracted to apply to every dimmer while the other properties can be applied to individual ones. + */ + var dimmerOptions = reactiveConfigurators.First().Value.DimmerOptions; + var dimmer = dimmers.Length > 1 ? new CompositeDimmer(dimmers) : dimmers[0]; + + var dimPulses = dimmer.Dimming.ToPulsesWhenTrue(dimmerOptions.TimeBetweenSteps, scheduler); + var brightenPulses = dimmer.Brightening.ToPulsesWhenTrue(dimmerOptions.TimeBetweenSteps, scheduler); + + var orderedDimNodes = dimmerOptions.ValidateAndOrderMultipleLightTypes(dimmerNodes); + + var dimSubscriptionDisposables = new CompositeDisposable(); + SubscribeToPulses(dimPulses, dimmerNodes, orderedDimNodes, dimSubscriptionDisposables, + (context, dn) => dn.DimStep(context)); + SubscribeToPulses(brightenPulses, dimmerNodes, orderedDimNodes, dimSubscriptionDisposables, + (context, dn) => dn.BrightenStep(context)); + + var lastUnregisteredSubscription = registrationManager.LastUnregistered.Subscribe(_ => + { + dimSubscriptionDisposables.Dispose(); + }); + + dimSubscriptionDisposables.Add(lastUnregisteredSubscription); + + return result; + } + + private ReactiveNode CreateReactiveNode(LightTransitionReactiveNodeConfigurator reactiveNodeConfigurator) + { + return new ReactiveNode( + reactiveNodeConfigurator.Name, + reactiveNodeConfigurator.NodeObservables.Merge(), + serviceProvider.GetRequiredService>()); + } + + private void SubscribeToPulses( + IObservable pulses, + Dictionary dimmerNodes, + OrderedDictionary orderedDimNodes, + CompositeDisposable compositeDisposable, + Action dimmerAction) + { + compositeDisposable.Add(pulses.Subscribe(_ => + { + var context = CreateDimmingContext(orderedDimNodes); + dimmerNodes.Values.ForEach(dn => dimmerAction(context, dn)); + })); + } + + private DimmingContext CreateDimmingContext(OrderedDictionary orderedDimNodes) + { + return new DimmingContext(orderedDimNodes + .Select(kvp => (kvp.Key, kvp.Value.Output?.LightParameters)).ToArray()); + } + } + + /// + /// A pipeline that combines a reactive node with a reactive dimmer node for managing light transitions. + /// + internal class ReactiveDimmerPipeline : Pipeline + { + private readonly IRegisterInterface _registerInterface; + + /// + /// Initializes a new instance of the class. + /// + public ReactiveDimmerPipeline( + ReactiveNode reactiveNode, + ReactiveDimmerNode reactiveDimmerNode, + IRegisterInterface registerInterface) + { + _registerInterface = registerInterface; + _registerInterface.Register(this); + RegisterNode(reactiveNode); + RegisterNode(reactiveDimmerNode); + } + + /// + public override ValueTask DisposeAsync() + { + _registerInterface.Unregister(this); + return base.DisposeAsync(); + } + } + + /// + /// Interface for managing registrations and tracking when the last item is unregistered. + /// + internal interface IRegisterInterface + { + /// + /// Registers an item. + /// + void Register(T reference); + + /// + /// Unregisters an item. + /// + void Unregister(T reference); + } + + /// + /// Manages registration of items and notifies when the last item is unregistered. + /// + internal sealed class RegistrationManager : IRegisterInterface, IDisposable + { + private readonly HashSet _items = new(); + private readonly Lock _lock = new(); + private readonly Subject _lastUnregistered = new (); + private bool _isDisposed; + + /// + /// Gets an observable that emits when the last registered item is unregistered. + /// + public IObservable LastUnregistered => _lastUnregistered; + + /// + public void Register(T reference) + { + lock (_lock) + { + ObjectDisposedException.ThrowIf(_isDisposed, typeof(RegistrationManager)); + _items.Add(reference); + } + } + + /// + public void Unregister(T reference) + { + bool becameEmpty = false; + + lock (_lock) + { + if (_isDisposed) + return; + + if (_items.Remove(reference) && _items.Count == 0) + becameEmpty = true; + } + + if (becameEmpty) + _lastUnregistered.OnNext(Unit.Default); + } + + /// + public void Dispose() + { + lock (_lock) + { + if (_isDisposed) + return; + + _isDisposed = true; + _items.Clear(); + } + + _lastUnregistered.OnCompleted(); + _lastUnregistered.Dispose(); + } + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Toggle/CompositeLightTransitionToggleConfigurator.cs b/src/CodeCasa.AutomationPipelines.Lights/Toggle/CompositeLightTransitionToggleConfigurator.cs new file mode 100644 index 0000000..17f3189 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Toggle/CompositeLightTransitionToggleConfigurator.cs @@ -0,0 +1,141 @@ +using System.Reactive.Concurrency; +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.Nodes; +using CodeCasa.Lights; +using Microsoft.Extensions.DependencyInjection; + +namespace CodeCasa.AutomationPipelines.Lights.Toggle +{ + internal class CompositeLightTransitionToggleConfigurator( + Dictionary activeConfigurators, + Dictionary inactiveConfigurators) : ILightTransitionToggleConfigurator + { + public ILightTransitionToggleConfigurator SetToggleTimeout(TimeSpan timeout) + { + activeConfigurators.Values.ForEach(c => c.SetToggleTimeout(timeout)); + inactiveConfigurators.Values.ForEach(c => c.SetToggleTimeout(timeout)); + return this; + } + + public ILightTransitionToggleConfigurator IncludeOffInToggleCycle() + { + activeConfigurators.Values.ForEach(c => c.IncludeOffInToggleCycle()); + inactiveConfigurators.Values.ForEach(c => c.IncludeOffInToggleCycle()); + return this; + } + + public ILightTransitionToggleConfigurator ExcludeOffFromToggleCycle() + { + activeConfigurators.Values.ForEach(c => c.ExcludeOffFromToggleCycle()); + inactiveConfigurators.Values.ForEach(c => c.ExcludeOffFromToggleCycle()); + return this; + } + + public ILightTransitionToggleConfigurator AddOff() + { + return Add(); + } + + public ILightTransitionToggleConfigurator AddOn() + { + return Add(LightTransition.On()); + } + + public ILightTransitionToggleConfigurator Add(LightParameters lightParameters) + { + return Add(lightParameters.AsTransition()); + } + + public ILightTransitionToggleConfigurator Add(Func lightParametersFactory) + { + return Add(c => lightParametersFactory(c)?.AsTransition()); + } + + public ILightTransitionToggleConfigurator Add(Func lightParametersFactory) + { + return Add((c, t) => lightParametersFactory(c, t)?.AsTransition()); + } + + public ILightTransitionToggleConfigurator Add(LightTransition lightTransition) + { + return Add(_ => lightTransition); + } + + public ILightTransitionToggleConfigurator Add(Func lightTransitionFactory) + { + return Add(c => new StaticLightTransitionNode(lightTransitionFactory(c), c.ServiceProvider.GetRequiredService())); + } + + public ILightTransitionToggleConfigurator Add(Func lightTransitionFactory) + { + return Add(c => new FactoryNode(t => lightTransitionFactory(c, t))); + } + + public ILightTransitionToggleConfigurator Add() where TNode : IPipelineNode + { + activeConfigurators.Values.ForEach(c => c.Add()); + inactiveConfigurators.Values.ForEach(c => c.AddPassThrough()); + return this; + } + + public ILightTransitionToggleConfigurator Add(Func> nodeFactory) + { + activeConfigurators.Values.ForEach(c => c.Add(nodeFactory)); + inactiveConfigurators.Values.ForEach(c => c.AddPassThrough()); + return this; + } + + public ILightTransitionToggleConfigurator AddPassThrough() + { + activeConfigurators.Values.ForEach(c => c.AddPassThrough()); + inactiveConfigurators.Values.ForEach(c => c.AddPassThrough()); + return this; + } + + public ILightTransitionToggleConfigurator ForLight(string lightId, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None) => ForLights([lightId], configure, excludedLightBehaviour); + + public ILightTransitionToggleConfigurator ForLight(ILight light, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None) => ForLights([light], configure, excludedLightBehaviour); + + public ILightTransitionToggleConfigurator ForLights(IEnumerable lightIds, + Action configure, + ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None) + { + var lightIdsArray = + CompositeHelper.ValidateLightsSupported(lightIds, activeConfigurators.Keys); + + if (lightIdsArray.Length == activeConfigurators.Count) + { + configure(this); + return this; + } + + if (excludedLightBehaviour == ExcludedLightBehaviours.None) + { + if (lightIdsArray.Length == 1) + { + configure(activeConfigurators[lightIdsArray.First()]); + return this; + } + + configure(new CompositeLightTransitionToggleConfigurator( + activeConfigurators.Where(kvp => lightIdsArray.Contains(kvp.Key)) + .ToDictionary(kvp => kvp.Key, kvp => kvp.Value), [])); + return this; + } + + configure(new CompositeLightTransitionToggleConfigurator( + activeConfigurators.Where(kvp => lightIdsArray.Contains(kvp.Key)) + .ToDictionary(kvp => kvp.Key, kvp => kvp.Value), + activeConfigurators.Where(kvp => !lightIdsArray.Contains(kvp.Key)) + .ToDictionary(kvp => kvp.Key, kvp => kvp.Value))); + return this; + } + + public ILightTransitionToggleConfigurator ForLights(IEnumerable lightEntities, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None) + { + var lightIds = CompositeHelper.ResolveGroupsAndValidateLightsSupported(lightEntities, activeConfigurators.Keys); + return ForLights(lightIds, configure, excludedLightBehaviour); + } + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Toggle/ILightTransitionToggleConfigurator.cs b/src/CodeCasa.AutomationPipelines.Lights/Toggle/ILightTransitionToggleConfigurator.cs new file mode 100644 index 0000000..137f56a --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Toggle/ILightTransitionToggleConfigurator.cs @@ -0,0 +1,145 @@ +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.Lights; + +namespace CodeCasa.AutomationPipelines.Lights.Toggle +{ + /// + /// Configurator for time-based toggle behavior. Quick consecutive triggers advance through all states sequentially. + /// After a timeout period, the next trigger restarts from the beginning. + /// + public interface ILightTransitionToggleConfigurator + { + /// + /// Sets the timeout duration after which the toggle cycle restarts from the beginning. + /// + /// The timeout duration between triggers that determines when to restart the cycle. + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator SetToggleTimeout(TimeSpan timeout); + + /// + /// Includes the "off" state in the toggle cycle. When the light is off and toggled, it will advance to the first state in the cycle. + /// + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator IncludeOffInToggleCycle(); + + /// + /// Excludes the "off" state from the toggle cycle. When the light is off and toggled, it will turn on to the first state but "off" won't be part of the sequential cycle. + /// + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator ExcludeOffFromToggleCycle(); + + /// + /// Adds an "off" state to the toggle sequence. + /// + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator AddOff(); + + /// + /// Adds an "on" state to the toggle sequence. + /// + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator AddOn(); + + /// + /// Adds light parameters to the toggle sequence. Quick consecutive triggers will advance through all added parameter sets. + /// + /// The light parameters to add to the toggle sequence. + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator Add(LightParameters lightParameters); + + /// + /// Adds light parameters created by a factory to the toggle sequence. + /// + /// A factory function that creates light parameters based on the pipeline context. + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator Add(Func lightParametersFactory); + + /// + /// Adds light parameters created by a factory to the toggle sequence. + /// The factory receives both the pipeline context and the current light transition. + /// + /// A factory function that creates light parameters based on the pipeline context and current transition. + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator Add(Func lightParametersFactory); + + /// + /// Adds a light transition to the toggle sequence. Quick consecutive triggers will advance through all added transitions. + /// + /// The light transition to add to the toggle sequence. + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator Add(LightTransition lightTransition); + + /// + /// Adds a light transition created by a factory to the toggle sequence. + /// + /// A factory function that creates a light transition based on the pipeline context. + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator Add(Func lightTransitionFactory); + + /// + /// Adds a light transition created by a factory to the toggle sequence. + /// The factory receives both the pipeline context and the current light transition. + /// + /// A factory function that creates a light transition based on the pipeline context and current transition. + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator Add(Func lightTransitionFactory); + + /// + /// Adds a pipeline node of type to the toggle sequence. + /// The node is resolved from the service provider. Quick consecutive triggers will advance through all added nodes. + /// + /// The type of the pipeline node to add to the toggle sequence. + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator Add() where TNode : IPipelineNode; + + /// + /// Adds a pipeline node created by a factory to the toggle sequence. + /// Quick consecutive triggers will advance through all added nodes. + /// + /// A factory function that creates a pipeline node based on the pipeline context. + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator Add(Func> nodeFactory); + + /// + /// Adds a pass-through state to the toggle sequence that maintains the current light state. + /// + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator AddPassThrough(); + + /// + /// Creates a scoped toggle configuration for a specific light identified by its entity ID. + /// + /// The entity ID of the light to configure. + /// An action to configure the toggle for this specific light. + /// Specifies the behavior for lights not included in this scoped configuration. Defaults to . + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator ForLight(string lightId, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None); + + /// + /// Creates a scoped toggle configuration for a specific light. + /// + /// The light to configure. + /// An action to configure the toggle for this specific light. + /// Specifies the behavior for lights not included in this scoped configuration. Defaults to . + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator ForLight(ILight light, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None); + + /// + /// Creates a scoped toggle configuration for multiple light entities identified by their entity IDs. + /// + /// The entity IDs of the lights to configure. + /// An action to configure the toggle for these lights. + /// Specifies the behavior for lights not included in this scoped configuration. Defaults to . + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator ForLights(IEnumerable lightIds, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None); + + /// + /// Creates a scoped toggle configuration for multiple light entities. + /// + /// The light entities to configure. + /// An action to configure the toggle for these lights. + /// Specifies the behavior for lights not included in this scoped configuration. Defaults to . + /// The configurator instance for method chaining. + ILightTransitionToggleConfigurator ForLights(IEnumerable lightEntities, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None); + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Toggle/LightTransitionToggleConfigurator.cs b/src/CodeCasa.AutomationPipelines.Lights/Toggle/LightTransitionToggleConfigurator.cs new file mode 100644 index 0000000..00e7738 --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Toggle/LightTransitionToggleConfigurator.cs @@ -0,0 +1,117 @@ +using System.Reactive.Concurrency; +using CodeCasa.AutomationPipelines.Lights.Context; +using CodeCasa.AutomationPipelines.Lights.Extensions; +using CodeCasa.AutomationPipelines.Lights.Nodes; +using CodeCasa.Lights; +using Microsoft.Extensions.DependencyInjection; + +namespace CodeCasa.AutomationPipelines.Lights.Toggle +{ + internal class LightTransitionToggleConfigurator(ILight light, IScheduler scheduler) : ILightTransitionToggleConfigurator + { + public ILight Light { get; } = light; + internal TimeSpan? ToggleTimeout { get; private set; } + internal bool? IncludeOffValue { get; private set; } + internal List>> NodeFactories + { + get; + } = []; + + public ILightTransitionToggleConfigurator SetToggleTimeout(TimeSpan timeout) + { + ToggleTimeout = timeout; + return this; + } + + public ILightTransitionToggleConfigurator IncludeOffInToggleCycle() + { + IncludeOffValue = true; + return this; + } + + public ILightTransitionToggleConfigurator ExcludeOffFromToggleCycle() + { + IncludeOffValue = false; + return this; + } + + public ILightTransitionToggleConfigurator AddOff() + { + return Add(); + } + + public ILightTransitionToggleConfigurator AddOn() + { + return Add(LightTransition.On()); + } + + + public ILightTransitionToggleConfigurator Add(LightParameters lightParameters) + { + return Add(lightParameters.AsTransition()); + } + + public ILightTransitionToggleConfigurator Add(Func lightParametersFactory) + { + return Add(c => lightParametersFactory(c)?.AsTransition()); + } + + public ILightTransitionToggleConfigurator Add(Func lightParametersFactory) + { + return Add((c, t) => lightParametersFactory(c, t)?.AsTransition()); + } + + public ILightTransitionToggleConfigurator Add(LightTransition lightTransition) + { + return Add(new StaticLightTransitionNode(lightTransition, scheduler)); + } + + public ILightTransitionToggleConfigurator Add(Func lightTransitionFactory) + { + return Add(c => new StaticLightTransitionNode(lightTransitionFactory(c), c.ServiceProvider.GetRequiredService())); + } + + public ILightTransitionToggleConfigurator Add(Func lightTransitionFactory) + { + return Add(c => new FactoryNode(t => lightTransitionFactory(c, t))); + } + + public ILightTransitionToggleConfigurator Add() where TNode : IPipelineNode + { + return Add(c => c.ServiceProvider.CreateInstanceWithinContext(c)); + } + + public ILightTransitionToggleConfigurator Add(IPipelineNode node) + { + return Add(_ => node); + } + + public ILightTransitionToggleConfigurator Add(Func> nodeFactory) + { + NodeFactories.Add(nodeFactory); + return this; + } + + public ILightTransitionToggleConfigurator AddPassThrough() + { + return Add(new PassThroughNode()); + } + + public ILightTransitionToggleConfigurator ForLight(string lightId, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None) => ForLights([lightId], configure, excludedLightBehaviour); + + public ILightTransitionToggleConfigurator ForLight(ILight light, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None) => ForLights([light], configure, excludedLightBehaviour); + + public ILightTransitionToggleConfigurator ForLights(IEnumerable lightIds, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None) + { + CompositeHelper.ValidateLightSupported(lightIds, Light.Id); + return this; + } + + public ILightTransitionToggleConfigurator ForLights(IEnumerable lightEntities, Action configure, ExcludedLightBehaviours excludedLightBehaviour = ExcludedLightBehaviours.None) + { + CompositeHelper.ResolveGroupsAndValidateLightSupported(lightEntities, Light.Id); + return this; + } + + } +} diff --git a/src/CodeCasa.AutomationPipelines.Lights/Utils/ObjectExtensions.cs b/src/CodeCasa.AutomationPipelines.Lights/Utils/ObjectExtensions.cs new file mode 100644 index 0000000..b3fbbfc --- /dev/null +++ b/src/CodeCasa.AutomationPipelines.Lights/Utils/ObjectExtensions.cs @@ -0,0 +1,19 @@ + +namespace CodeCasa.AutomationPipelines.Lights.Utils +{ + internal static class ObjectExtensions + { + public static async Task DisposeOrDisposeAsync(this object obj) + { + switch (obj) + { + case IAsyncDisposable asyncDisposable: + await asyncDisposable.DisposeAsync(); + break; + case IDisposable disposable: + disposable.Dispose(); + break; + } + } + } +} diff --git a/src/CodeCasa.Lights.NetDaemon/Extensions/LightEntityCodeExtensions.cs b/src/CodeCasa.Lights.NetDaemon/Extensions/LightEntityCoreExtensions.cs similarity index 95% rename from src/CodeCasa.Lights.NetDaemon/Extensions/LightEntityCodeExtensions.cs rename to src/CodeCasa.Lights.NetDaemon/Extensions/LightEntityCoreExtensions.cs index 5d5c058..d086775 100644 --- a/src/CodeCasa.Lights.NetDaemon/Extensions/LightEntityCodeExtensions.cs +++ b/src/CodeCasa.Lights.NetDaemon/Extensions/LightEntityCoreExtensions.cs @@ -11,8 +11,18 @@ namespace CodeCasa.Lights.NetDaemon.Extensions; /// including turning lights on/off, applying transitions, retrieving parameters, and checking state. /// All methods are extension methods on , allowing for a fluent API. /// -public static class LightEntityCodeExtensions +public static class LightEntityCoreExtensions { + /// + /// Converts an to a wrapper. + /// + /// The light entity to convert. + /// A wrapper around the provided light entity. + public static NetDaemonLight AsLight(this ILightEntityCore lightEntity) + { + return new NetDaemonLight(lightEntity); + } + /// /// Turns on a light entity with the specified light parameters. ///