go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/experiments/huectl/pkg/hue/group.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package hue

import (
	"context"
	"errors"
	"time"
)

// Group represents a bridge group https://developers.meethue.com/documentation/groups-api
type Group struct {
	bridge Bridge

	ID int `json:"id,omitempty"`

	Class      string               `json:"class,omitempty"`
	GroupState GroupState           `json:"state,omitempty"`
	Lights     []string             `json:"lights,omitempty"`
	Locations  map[string][]float64 `json:"locations,omitempty"`
	Name       string               `json:"name,omitempty"`
	Recycle    bool                 `json:"recycle,omitempty"`
	State      LightState           `json:"action,omitempty"`
	Stream     Stream               `json:"stream,omitempty"`
	Type       string               `json:"type,omitempty"`
}

// GroupState defines the state on a group.
// Can be used to control the state of all lights in a group rather than controlling them individually
type GroupState struct {
	AllOn bool `json:"all_on,omitempty"`
	AnyOn bool `json:"any_on,omitempty"`
}

// Stream define the stream status of a group
type Stream struct {
	ProxyMode string  `json:"proxymode,omitempty"`
	ProxyNode string  `json:"proxynode,omitempty"`
	ActiveRaw *bool   `json:"active,omitempty"`
	OwnerRaw  *string `json:"owner,omitempty"`
}

// Active returns the stream active state, and will return false if ActiveRaw is nil
func (s *Stream) Active() bool {
	if s.ActiveRaw == nil {
		return false
	}

	return *s.ActiveRaw
}

// Owner returns the stream Owner, and will return an empty string if OwnerRaw is nil
func (s *Stream) Owner() string {
	if s.OwnerRaw == nil {
		return ""
	}

	return *s.OwnerRaw
}

// SetState sets the state of the group to s.
func (g *Group) SetState(ctx context.Context, s LightState) error {
	_, err := g.bridge.SetGroupState(ctx, g.ID, s)
	if err != nil {
		return err
	}
	g.State = s
	return nil
}

// Rename sets the name property of the group
func (g *Group) Rename(ctx context.Context, new string) error {
	update := Group{Name: new}
	_, err := g.bridge.UpdateGroup(ctx, g.ID, update)
	if err != nil {
		return err
	}
	g.Name = new
	return nil
}

// Off sets the On state of one group to false, turning all lights in the group off
func (g *Group) Off(ctx context.Context) error {
	state := LightState{On: false}
	_, err := g.bridge.SetGroupState(ctx, g.ID, state)
	if err != nil {
		return err
	}
	g.State.On = false
	return nil
}

// On sets the On state of one group to true, turning all lights in the group on
func (g *Group) On(ctx context.Context) error {
	state := LightState{On: true}
	_, err := g.bridge.SetGroupState(ctx, g.ID, state)
	if err != nil {
		return err
	}
	g.State.On = true
	return nil
}

// IsOn returns true if light state On property is true
func (g *Group) IsOn() bool {
	return g.State.On
}

// Brightness sets the light brightness state property
func (g *Group) Brightness(ctx context.Context, new uint8) error {
	update := LightState{On: true, Bri: new}
	_, err := g.bridge.SetGroupState(ctx, g.ID, update)
	if err != nil {
		return err
	}
	g.State.Bri = new
	g.State.On = true
	return nil
}

// Hue sets the light hue state property (0-65535)
func (g *Group) Hue(ctx context.Context, new uint16) error {
	update := LightState{On: true, Hue: new}
	_, err := g.bridge.SetGroupState(ctx, g.ID, update)
	if err != nil {
		return err
	}
	g.State.Hue = new
	g.State.On = true
	return nil
}

// Saturation sets the light saturation state property (0-254)
func (g *Group) Saturation(ctx context.Context, new uint8) error {
	update := LightState{On: true, Sat: new}
	_, err := g.bridge.SetGroupState(ctx, g.ID, update)
	if err != nil {
		return err
	}
	g.State.Sat = new
	g.State.On = true
	return nil
}

// Xy sets the x and y coordinates of a color in CIE color space. (0-1 per value)
func (g *Group) Xy(ctx context.Context, new []float32) error {
	update := LightState{On: true, Xy: new}
	_, err := g.bridge.SetGroupState(ctx, g.ID, update)
	if err != nil {
		return err
	}
	g.State.Xy = new
	g.State.On = true
	return nil
}

// ColorTemperature sets the light color temperature state property
func (g *Group) ColorTemperature(ctx context.Context, new uint16) error {
	update := LightState{On: true, Ct: new}
	_, err := g.bridge.SetGroupState(ctx, g.ID, update)
	if err != nil {
		return err
	}
	g.State.Ct = new
	g.State.On = true
	return nil
}

// Color sets the light color as RGB (will be converted to xy)
func (g *Group) Color(ctx context.Context, c Color) error {
	xy := c.XY(GamutC)

	update := LightState{
		On:  true,
		Bri: g.State.Bri,
		Xy:  xy,
	}
	_, err := g.bridge.SetGroupState(ctx, g.ID, update)
	if err != nil {
		return err
	}
	g.State.Xy = xy
	g.State.On = true
	return nil
}

// ColorTransition sets the light color as RGB (will be converted to xy) with a given transition time.
func (g *Group) ColorTransition(ctx context.Context, c Color, transition time.Duration) error {
	xy := c.XY(GamutC)

	update := LightState{
		On:             true,
		Bri:            g.State.Bri,
		Xy:             xy,
		TransitionTime: uint16(transition / (100 * time.Millisecond)),
	}
	_, err := g.bridge.SetGroupState(ctx, g.ID, update)
	if err != nil {
		return err
	}
	g.State.Xy = xy
	g.State.On = true
	return nil
}

// Scene sets the scene by it's identifier of the scene you wish to recall
func (g *Group) Scene(ctx context.Context, scene string) error {
	update := LightState{On: true, Scene: scene}
	_, err := g.bridge.SetGroupState(ctx, g.ID, update)
	if err != nil {
		return err
	}
	g.State.Scene = scene
	g.State.On = true
	return nil
}

// TransitionTimeContext sets the duration of the transition from the light’s current state to the new state
func (g *Group) TransitionTimeContext(ctx context.Context, new uint16) error {
	update := LightState{On: g.State.On, TransitionTime: new}
	_, err := g.bridge.SetGroupState(ctx, g.ID, update)
	if err != nil {
		return err
	}
	g.State.TransitionTime = new
	return nil
}

// EffectContext the dynamic effect of the lights in the group, currently “none” and “colorloop” are supported
func (g *Group) EffectContext(ctx context.Context, new string) error {
	update := LightState{On: true, Effect: new}
	_, err := g.bridge.SetGroupState(ctx, g.ID, update)
	if err != nil {
		return err
	}
	g.State.Effect = new
	g.State.On = true
	return nil
}

// AlertContext makes the lights in the group blink in its current color. Supported values are:
// “none” – The light is not performing an alert effect.
// “select” – The light is performing one breathe cycle.
// “lselect” – The light is performing breathe cycles for 15 seconds or until alert is set to "none".
func (g *Group) AlertContext(ctx context.Context, new string) error {
	update := LightState{On: true, Alert: new}
	_, err := g.bridge.SetGroupState(ctx, g.ID, update)
	if err != nil {
		return err
	}
	g.State.Effect = new
	g.State.On = true
	return nil
}

// EnableStreamingContext enables streaming for the group by setting the Stream Active property to true
func (g *Group) EnableStreamingContext(ctx context.Context) error {
	if g.Type != "Entertainment" {
		return errors.New("must be an entertainment group to enable streaming")
	}

	active := true
	update := Group{
		Stream: Stream{
			ActiveRaw: &active,
		},
	}
	_, err := g.bridge.UpdateGroup(ctx, g.ID, update)
	if err != nil {
		return err
	}

	g.Stream.ActiveRaw = &active
	g.Stream.OwnerRaw = &g.bridge.Username
	return nil
}

// DisableStreamingContext disabled streaming for the group by setting the Stream Active property to false
func (g *Group) DisableStreamingContext(ctx context.Context) error {
	if g.Type != "Entertainment" {
		return errors.New("must be an entertainment group to disable streaming")
	}

	active := false
	update := Group{
		Stream: Stream{
			ActiveRaw: &active,
		},
	}
	_, err := g.bridge.UpdateGroup(ctx, g.ID, update)
	if err != nil {
		return err
	}

	g.Stream.ActiveRaw = &active
	g.Stream.OwnerRaw = nil

	return nil
}