main.go

package main

import (
	"context"
	"errors"
	"log"
	"os"
	"os/signal"
	"syscall"
	"time"
)

func main() {
	log.SetFlags(log.LstdFlags | log.Lmicroseconds)

	cfg, err := loadConfig()
	if err != nil {
		log.Fatalf("Configuration error: %v", err)
	}

	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer cancel()

	hue := newHueClient(cfg)
	area, states, err := hue.loadAreaState(ctx, cfg)
	if err != nil {
		log.Fatalf("Hue setup failed: %v", err)
	}

	openrgb, err := dialOpenRGB(ctx, cfg)
	if err != nil {
		log.Fatalf("OpenRGB setup failed: %v", err)
	}
	defer openrgb.Close()

	target, err := openrgb.selectTarget(cfg, len(area.LightIDs))
	if err != nil {
		log.Fatalf("OpenRGB target selection failed: %v", err)
	}

	log.Printf("Using Hue area %q (%s) with %d lights", area.Name, area.ID, len(area.LightIDs))
	log.Printf("Using OpenRGB %s with capacity %d LEDs", target.label, target.ledCapacity)
	logAreaMapping(area, states)

	if err := syncTarget(target, area, states); err != nil {
		log.Fatalf("Initial sync failed: %v", err)
	}

	for {
		err = hue.stream(ctx, func(resources []map[string]any) error {
			needsReselect := false
			dirty := false
			for _, resource := range resources {
				resourceType := stringValue(resource["type"])
				switch resourceType {
				case "light":
					id := stringValue(resource["id"])
					state, ok := states[id]
					if !ok {
						continue
					}
					if state.merge(resource) {
						dirty = true
					}
				case "entertainment_configuration":
					if stringValue(resource["id"]) == area.ID {
						needsReselect = true
					}
				}
			}

			if needsReselect {
				refreshedArea, refreshedStates, err := hue.loadAreaState(ctx, cfg)
				if err != nil {
					return err
				}
				area = refreshedArea
				states = refreshedStates
				target, err = openrgb.selectTarget(cfg, len(area.LightIDs))
				if err != nil {
					return err
				}
				log.Printf("Hue area membership changed; refreshed target selection")
				logAreaMapping(area, states)
				dirty = true
			}

			if !dirty {
				return nil
			}

			return syncTarget(target, area, states)
		})

		if ctx.Err() != nil {
			log.Printf("Shutting down")
			return
		}

		if err != nil && !errors.Is(err, context.Canceled) {
			log.Printf("Hue event stream ended: %v", err)
		}

		select {
		case <-ctx.Done():
			log.Printf("Shutting down")
			return
		case <-time.After(cfg.ReconnectDelay):
		}
	}
}

func syncTarget(target *openRGBTarget, area hueArea, states map[string]*hueLightState) error {
	return target.syncArea(area, states)
}

func logAreaMapping(area hueArea, states map[string]*hueLightState) {
	for index, lightID := range area.LightIDs {
		state := states[lightID]
		name := lightID
		if state != nil && state.Name != "" {
			name = state.Name
		}
		log.Printf("Hue light %d -> %s (%s)", index, name, lightID)
	}
	if len(area.LightIDs) == 0 {
		log.Printf("Hue area %q resolved to zero lights", area.Name)
	}
	if brightness := averageBrightness(areaColors(area, states)); brightness > 0 {
		log.Printf("Initial average mapped brightness %.0f%%", brightness*100)
	}
}

func areaColors(area hueArea, states map[string]*hueLightState) []rgbColor {
	colors := make([]rgbColor, 0, len(area.LightIDs))
	for _, lightID := range area.LightIDs {
		if state, ok := states[lightID]; ok {
			colors = append(colors, state.rgb())
		}
	}
	return colors
}