go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/experiments/huectl/pkg/command/helpers.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 command

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"os"
	"reflect"
	"strings"
	"text/template"

	"github.com/urfave/cli/v2"
	"go.charczuk.com/sdk/ansi"

	"go.charczuk.com/experiments/huectl/pkg/hue"
)

const (
	flagAddr       = "addr"
	flagConfig     = "config"
	flagDeviceType = "device-type"
	flagGroupID    = "group-id"
	flagGroupName  = "group-name"
	flagLightID    = "light-id"
	flagLightName  = "light-name"
	flagOutput     = "output"
	flagQuiet      = "quiet"
	flagTemplate   = "template"
	flagUsername   = "username"
	flagVerbose    = "verbose"
)

// DefaultFlags are the default (or persistent) flags.
var DefaultFlags = []cli.Flag{
	&cli.StringFlag{
		Name:    flagConfig,
		Usage:   "The json config file path",
		Value:   os.ExpandEnv("${HOME}/.config/huectl/config.json"),
		EnvVars: []string{"HUE_CONFIG"},
	},
	&cli.StringFlag{
		Name:    flagUsername,
		Usage:   "The hue username to authenticate with",
		EnvVars: []string{"HUE_USERNAME"},
	},
	&cli.StringFlag{
		Name:    flagAddr,
		Usage:   "The hue bridge local address",
		EnvVars: []string{"HUE_ADDR"},
	},
	&cli.BoolFlag{
		Name:    flagQuiet,
		Aliases: []string{"q"},
		Usage:   "If command output should be suppressed",
	},
	&cli.BoolFlag{
		Name:    flagVerbose,
		Aliases: []string{"v"},
		Usage:   "If verbose command should be shown",
	},
}

// OutputFlags are common output related flags.
var OutputFlags = []cli.Flag{
	&cli.StringFlag{
		Name:    flagOutput,
		Aliases: []string{"o"},
		Usage:   "The output format (json|table|template)",
		EnvVars: []string{"HUE_OUTPUT"},
	},
	&cli.StringFlag{
		Name:    flagTemplate,
		Aliases: []string{"t"},
		Usage:   "The output template",
		EnvVars: []string{"HUE_OUTPUT_TEMPLATE"},
	},
}

// GroupFlags are group related flags.
var GroupFlags = []cli.Flag{
	&cli.IntFlag{
		Name:    flagGroupID,
		Aliases: []string{"id"},
		Usage:   "The group `ID` field of the group in question, exclusive with --group-name",
	},
	&cli.StringFlag{
		Name:    flagGroupName,
		Aliases: []string{"n", "name"},
		Usage:   "The group `Name` field of the group in question, exclusive with --group-id",
	},
}

// LightFlags are light related flags.
var LightFlags = []cli.Flag{
	&cli.IntFlag{
		Name:    flagLightID,
		Aliases: []string{"id"},
		Usage:   "The `ID` field of the light in question",
	},
	&cli.StringFlag{
		Name:    flagLightName,
		Aliases: []string{"name", "n"},
		Usage:   "The `Name` field of the light in question",
	},
}

func groupHelper(c *cli.Context) (*hue.Group, *hue.Bridge, error) {
	bridge, err := initHelper(c)
	if err != nil {
		return nil, nil, err
	}

	if c.Int(flagGroupID) > 0 && c.String(flagGroupName) != "" {
		return nil, nil, fmt.Errorf("please specify one of --group-id or --group-name")
	}
	var group *hue.Group
	if c.Int(flagGroupID) > 0 || c.String(flagGroupName) != "" {
		group, err = getGroup(c, &bridge, getGroupArgs{
			ID:   c.Int(flagGroupID),
			Name: c.String(flagGroupName),
		})
		if err != nil {
			return nil, nil, err
		}
	}
	return group, &bridge, nil
}

func lightHelper(c *cli.Context) (*hue.Light, *hue.Bridge, error) {
	bridge, err := initHelper(c)
	if err != nil {
		return nil, nil, err
	}

	if c.Int(flagLightID) > 0 && c.String(flagLightName) != "" {
		return nil, nil, fmt.Errorf("please specify one of --light-id or --light-name")
	}
	var light *hue.Light
	if c.Int(flagLightID) > 0 || c.String(flagLightName) != "" {
		light, err = getLight(c, &bridge, getLightArgs{
			ID:   c.Int(flagLightID),
			Name: c.String(flagLightName),
		})
		if err != nil {
			return nil, nil, err
		}
	}
	return light, &bridge, nil
}

func initHelper(c *cli.Context) (hue.Bridge, error) {
	c.Context = hue.WithVerbose(c.Context, c.Bool(flagVerbose))
	return getBridge(c)
}

type configKey struct{}

func withConfig(ctx context.Context, cfg config) context.Context {
	return context.WithValue(ctx, configKey{}, cfg)
}

func getConfigContext(ctx context.Context) (cfg config, ok bool) {
	if value := ctx.Value(configKey{}); value != nil {
		cfg, ok = value.(config)
		return
	}
	return
}

type bridgeKey struct{}

func withBridge(ctx context.Context, b hue.Bridge) context.Context {
	return context.WithValue(ctx, bridgeKey{}, b)
}

func getBridgeContext(ctx context.Context) (b hue.Bridge, ok bool) {
	if value := ctx.Value(bridgeKey{}); value != nil {
		b, ok = value.(hue.Bridge)
		return
	}
	return
}

type config struct {
	Username string `json:"username"`
	Addr     string `json:"addr"`
}

func readJSON(obj interface{}, path string) error {
	f, err := os.Open(path)
	if err != nil {
		return err
	}
	defer f.Close()
	return json.NewDecoder(f).Decode(obj)
}

func readConfig(c *config, path string) error {
	return readJSON(c, path)
}

func getConfig(c *cli.Context) (cfg config, ok bool, err error) {
	if cfg, ok = getConfigContext(c.Context); ok {
		return
	}

	if configPath := c.String(flagConfig); configPath != "" {
		if _, statErr := os.Stat(configPath); statErr == nil {
			if err = readConfig(&cfg, configPath); err != nil {
				return
			}
			ok = true
		}
	}
	return
}

func getBridge(c *cli.Context) (b hue.Bridge, err error) {
	var ok bool
	if b, ok = getBridgeContext(c.Context); ok {
		return
	}

	var cfg config
	cfg, ok, err = getConfig(c)
	if err != nil {
		return
	}
	if ok {
		b.Username = cfg.Username
		b.Addr = cfg.Addr
	}

	if b.Username == "" {
		username := c.String(flagUsername)
		if username == "" {
			err = fmt.Errorf("--user or $HUE_USERNAME is required to be set")
			return
		}
		b.Username = username
	}

	if b.Addr == "" {
		hueAddr := c.String(flagAddr)
		if hueAddr == "" {
			found, ok, discoverErr := hue.DiscoverFirst(c.Context)
			if discoverErr != nil {
				err = discoverErr
				return
			}
			if !ok {
				err = fmt.Errorf("--addr unset and no bridges discovered")
				return
			}
			b.Addr = found.Addr
		} else {
			b.Addr = hueAddr
		}
	}
	c.Context = withBridge(c.Context, b)
	return
}

func output(c *cli.Context, wr io.Writer, obj interface{}) error {
	switch c.String(flagOutput) {
	case "json":
		return json.NewEncoder(wr).Encode(obj)
	case "table":
		return ansi.TableForSlice(wr, obj)
	case "template":
		tmpl, err := template.New("huectl").Parse(c.String(flagTemplate) + "\n")
		if err != nil {
			return err
		}
		return iterate(obj, func(v interface{}) error {
			return tmpl.Execute(wr, v)
		})
	default:
		return ansi.TableForSlice(wr, obj)
	}
}

func iterate(collection interface{}, fn func(interface{}) error) error {
	cv := reflect.ValueOf(collection)
	for cv.Kind() == reflect.Ptr {
		cv = cv.Elem()
	}
	if cv.Kind() != reflect.Slice {
		return fmt.Errorf("cannot iterate over non-slice collection")
	}

	var err error
	for row := 0; row < cv.Len(); row++ {
		if err = fn(cv.Index(row)); err != nil {
			return err
		}
	}
	return nil
}

type getGroupArgs struct {
	ID   int
	Name string
}

func getGroup(c *cli.Context, bridge *hue.Bridge, args getGroupArgs) (*hue.Group, error) {
	if args.Name != "" {
		groups, err := bridge.GetGroups(c.Context)
		if err != nil {
			return nil, err
		}
		for _, group := range groups {
			if strings.EqualFold(group.Name, args.Name) {
				return &group, nil
			}
		}
		return nil, fmt.Errorf("group with name %q not found", args.Name)
	}

	group, err := bridge.GetGroup(c.Context, args.ID)
	if err != nil {
		return nil, err
	}
	if group == nil {
		return nil, fmt.Errorf("group with id %d not found", args.ID)
	}
	return group, nil
}

type getSceneArgs struct {
	ID   string
	Name string
}

func getScene(c *cli.Context, bridge *hue.Bridge, args getSceneArgs) (*hue.Scene, error) {
	if args.Name != "" {
		scenes, err := bridge.GetScenes(c.Context)
		if err != nil {
			return nil, err
		}
		for _, scene := range scenes {
			if strings.EqualFold(scene.Name, args.Name) {
				return &scene, nil
			}
		}
		return nil, fmt.Errorf("scene with name %q not found", args.Name)
	}

	scene, err := bridge.GetScene(c.Context, args.ID)
	if err != nil {
		return nil, err
	}
	if scene == nil {
		return nil, fmt.Errorf("scene with id %v not found", args.ID)
	}
	return scene, nil
}

type getLightArgs struct {
	ID   int
	Name string
}

func getLight(c *cli.Context, bridge *hue.Bridge, args getLightArgs) (*hue.Light, error) {
	if args.Name != "" {
		lights, err := bridge.GetLights(c.Context)
		if err != nil {
			return nil, err
		}
		for _, light := range lights {
			if strings.EqualFold(light.Name, args.Name) {
				return &light, nil
			}
		}
		return nil, fmt.Errorf("light with name %q not found", args.Name)
	}

	light, err := bridge.GetLight(c.Context, args.ID)
	if err != nil {
		return nil, err
	}
	if light == nil {
		return nil, fmt.Errorf("light with id %d not found", args.ID)
	}
	return light, nil
}

func printf(c *cli.Context, format string, args ...any) {
	if !c.Bool(flagQuiet) {
		fmt.Printf(format, args...)
	}
}