go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/experiments/huectl/pkg/hue/light.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"
	"fmt"
)

// Light represents a bridge light https://developers.meethue.com/documentation/lights-api
type Light struct {
	bridge Bridge

	ID               int               `json:"id,omitempty"`
	Config           LightConfig       `json:"config,omitempty"`
	Capabilities     LightCapabilities `json:"capabilities,omitempty"`
	ManufacturerName string            `json:"manufacturername,omitempty"`
	ModelID          string            `json:"modelid,omitempty"`
	Name             string            `json:"name,omitempty"`
	ProductName      string            `json:"productname,omitempty"`
	State            LightState        `json:"state,omitempty"`
	SwConfigID       string            `json:"swconfigid,omitempty"`
	SwVersion        string            `json:"swversion,omitempty"`
	Type             string            `json:"type,omitempty"`
	UniqueID         string            `json:"uniqueid,omitempty"`
}

// String returns a new string form of the light.
func (l Light) String() string {
	return fmt.Sprintf("%d %s", l.ID, l.Name)
}

// LightConfig holds light config options.
type LightConfig struct {
	Archetype string `json:"archetype,omitempty"`
	Function  string `json:"function,omitempty"`
	Direction string `json:"direction,omitempty"`
}

// LightCapabilities holds light capabilities.
type LightCapabilities struct {
	Certified bool                       `json:"certified,omitempty"`
	Control   LightCapabilitiesControl   `json:"control,omitempty"`
	Streaming LightCapabilitiesStreaming `json:"streaming,omitempty"`
}

// LightCapabilitiesControl holds light capabilities for control.
type LightCapabilitiesControl struct {
	MinDimLevel      int         `json:"mindimlevel,omitempty"`
	MaxLumen         int         `json:"maxlumen,omitempty"`
	ColorGamutType   string      `json:"colorgamuttype,omitempty"`
	ColorGamut       [][]float64 `json:"colorgamut,omitempty"`
	ColorTemperature MinMaxInt   `json:"ct,omitempty"`
}

// MinMaxInt represents a minimum and a maximum integer.
type MinMaxInt struct {
	Min int `json:"min,omitempty"`
	Max int `json:"max,omitempty"`
}

// LightCapabilitiesStreaming holds the light streaming capabilities.
type LightCapabilitiesStreaming struct {
	Renderer bool `json:"renderer,omitempty"`
	Proxy    bool `json:"proxy,omitempty"`
}

// LightState defines the attributes and properties of a light
type LightState struct {
	Alert          string    `json:"alert,omitempty"`
	Bri            uint8     `json:"bri,omitempty"`
	BriInc         int       `json:"bri_inc,omitempty"`
	ColorMode      string    `json:"colormode,omitempty"`
	Ct             uint16    `json:"ct,omitempty"`
	CtInc          int       `json:"ct_inc,omitempty"`
	Effect         string    `json:"effect,omitempty"`
	Hue            uint16    `json:"hue,omitempty"`
	HueInc         int       `json:"hue_inc,omitempty"`
	On             bool      `json:"on"`
	Reachable      bool      `json:"reachable,omitempty"`
	Sat            uint8     `json:"sat,omitempty"`
	SatInc         int       `json:"sat_inc,omitempty"`
	Scene          string    `json:"scene,omitempty"`
	TransitionTime uint16    `json:"transitiontime,omitempty"`
	Xy             []float32 `json:"xy,omitempty"`
	XyInc          int       `json:"xy_inc,omitempty"`
}

// Lights defines a list of lights discovered the last time the bridge performed a light discovery.
// Also stores the timestamp the last time a discovery was performed.
type Lights struct {
	Lights   []string
	LastScan string `json:"lastscan"`
}

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

// Off sets the On state of one light to false, turning it off
func (l *Light) Off(ctx context.Context) error {
	state := LightState{}
	_, err := l.bridge.SetLightState(ctx, l.ID, state)
	if err != nil {
		return err
	}
	l.State.On = false
	return nil
}

// On sets the On state of one light to true, turning it on
func (l *Light) On(ctx context.Context) error {
	state := LightState{On: true}
	_, err := l.bridge.SetLightState(ctx, l.ID, state)
	if err != nil {
		return err
	}
	l.State.On = true
	return nil
}

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

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

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

// Hue sets the light hue state property (0-65535).
//
// Use the color helpers to create a more user-friendly input.
func (l *Light) Hue(ctx context.Context, new uint16) error {
	update := LightState{On: true, Hue: new}
	_, err := l.bridge.SetLightState(ctx, l.ID, update)
	if err != nil {
		return err
	}
	l.State.Hue = new
	l.State.On = true
	return nil
}

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

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

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

// Color sets the light color as RGB (will be converted to xy)
func (l *Light) Color(ctx context.Context, new Color) error {
	xy := new.XY(GetGamutForModelID(l.ModelID))
	update := LightState{On: true, Xy: xy, Bri: l.State.Bri}
	_, err := l.bridge.SetLightState(ctx, l.ID, update)
	if err != nil {
		return err
	}
	l.State.Xy = xy
	l.State.On = true
	return nil
}

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

// Effect the dynamic effect of the light, currently “none” and “colorloop” are supported
func (l *Light) Effect(ctx context.Context, new string) error {
	update := LightState{On: true, Effect: new}
	_, err := l.bridge.SetLightState(ctx, l.ID, update)
	if err != nil {
		return err
	}
	l.State.Effect = new
	l.State.On = true
	return nil
}

// Alert makes the light 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 (l *Light) Alert(ctx context.Context, new string) error {
	update := LightState{On: true, Alert: new}
	_, err := l.bridge.SetLightState(ctx, l.ID, update)
	if err != nil {
		return err
	}
	l.State.Effect = new
	l.State.On = true
	return nil
}