main.go

package main

import (
	"errors"
	"flag"
	"fmt"
	"io"
	"log"
	"log/syslog"
	"os"
	"os/exec"
	"path/filepath"
	"sort"
	"strconv"
	"strings"
)

const (
	appName       = "lightswitch"
	initialPrio   = 20
	prioIncrement = 5
)

type mode string

const (
	modeDark   mode = "dark"
	modeLight  mode = "light"
	modeToggle mode = "toggle"
)

type command struct {
	mode       mode
	activate   string
	deactivate string
	prio       *int
	renumber   bool
	debug      bool
}

type app struct {
	configDir string
	logger    logger
	stdout    io.Writer
	stderr    io.Writer
}

type logger interface {
	Printf(format string, v ...any)
	Close() error
}

type stdLogger struct {
	primary *log.Logger
	closer  io.Closer
	debug   *log.Logger
}

func (l *stdLogger) Printf(format string, v ...any) {
	if l.primary != nil {
		l.primary.Printf(format, v...)
	}
	if l.debug != nil {
		l.debug.Printf(format, v...)
	}
}

func (l *stdLogger) Close() error {
	if l.closer == nil {
		return nil
	}
	return l.closer.Close()
}

func main() {
	if err := run(os.Args[1:], os.Stdout, os.Stderr); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}

func run(args []string, stdout, stderr io.Writer) error {
	cmd, err := parseArgs(args)
	if err != nil {
		return err
	}

	configDir, err := defaultConfigDir()
	if err != nil {
		return err
	}

	logger := newLogger(cmd.debug, stderr)
	defer logger.Close()

	return (&app{
		configDir: configDir,
		logger:    logger,
		stdout:    stdout,
		stderr:    stderr,
	}).run(cmd)
}

func parseArgs(args []string) (command, error) {
	var cmd command
	fs := flag.NewFlagSet(appName, flag.ContinueOnError)
	fs.SetOutput(io.Discard)

	dark := fs.Bool("dark", false, "switch to dark mode")
	light := fs.Bool("light", false, "switch to light mode")
	toggle := fs.Bool("toggle", false, "toggle light/dark mode")
	debug := fs.Bool("debug", false, "echo log output to stderr")
	activate := fs.String("activate", "", "activate a script from scripts/")
	deactivate := fs.String("deactivate", "", "deactivate a script")
	renumber := fs.Bool("renumber", false, "renumber active scripts")
	prio := fs.Int("prio", -1, "priority for activation")

	if err := fs.Parse(args); err != nil {
		return cmd, err
	}
	if fs.NArg() != 0 {
		return cmd, fmt.Errorf("unexpected arguments: %s", strings.Join(fs.Args(), " "))
	}

	cmd.debug = *debug
	cmd.activate = strings.TrimSpace(*activate)
	cmd.deactivate = strings.TrimSpace(*deactivate)
	cmd.renumber = *renumber
	if *prio >= 0 {
		cmd.prio = prio
	}

	var actions int
	if *dark {
		cmd.mode = modeDark
		actions++
	}
	if *light {
		cmd.mode = modeLight
		actions++
	}
	if *toggle {
		cmd.mode = modeToggle
		actions++
	}
	if cmd.activate != "" {
		actions++
	}
	if cmd.deactivate != "" {
		actions++
	}
	if cmd.renumber {
		actions++
	}
	if actions != 1 {
		return cmd, errors.New("specify exactly one of --dark, --light, --toggle, --activate, --deactivate, or --renumber")
	}
	if cmd.prio != nil && cmd.activate == "" {
		return cmd, errors.New("--prio can only be used with --activate")
	}
	return cmd, nil
}

func (a *app) run(cmd command) error {
	switch {
	case cmd.activate != "":
		return a.activate(cmd.activate, cmd.prio)
	case cmd.deactivate != "":
		return a.deactivate(cmd.deactivate)
	case cmd.renumber:
		return a.renumber()
	default:
		resolvedMode, err := a.resolveMode(cmd.mode)
		if err != nil {
			return err
		}
		return a.executeScripts(resolvedMode)
	}
}

func defaultConfigDir() (string, error) {
	dir, err := os.UserConfigDir()
	if err != nil {
		return "", fmt.Errorf("find config dir: %w", err)
	}
	return filepath.Join(dir, appName), nil
}

func newLogger(debug bool, debugOut io.Writer) logger {
	writer, err := syslog.New(syslog.LOG_INFO|syslog.LOG_USER, appName)
	if err == nil {
		l := &stdLogger{
			primary: log.New(writer, "", 0),
			closer:  writer,
		}
		if debug {
			l.debug = log.New(debugOut, "", 0)
		}
		return l
	}

	l := &stdLogger{primary: log.New(io.Discard, "", 0)}
	if debug {
		l.debug = log.New(debugOut, "", 0)
	}
	return l
}

func (a *app) scriptsDir() string {
	return filepath.Join(a.configDir, "scripts")
}

func (a *app) activeDir() string {
	return filepath.Join(a.configDir, "lightswitch.d")
}

func (a *app) statePath() string {
	return filepath.Join(a.configDir, "state")
}

func (a *app) ensureDirs() error {
	for _, dir := range []string{a.scriptsDir(), a.activeDir()} {
		if err := os.MkdirAll(dir, 0o755); err != nil {
			return fmt.Errorf("create %s: %w", dir, err)
		}
	}
	return nil
}

func (a *app) resolveMode(requested mode) (mode, error) {
	if requested != modeToggle {
		return requested, a.writeState(requested)
	}

	current, err := a.readState()
	if err != nil {
		return "", err
	}
	if current == modeDark {
		return modeLight, a.writeState(modeLight)
	}
	return modeDark, a.writeState(modeDark)
}

func (a *app) readState() (mode, error) {
	data, err := os.ReadFile(a.statePath())
	if errors.Is(err, os.ErrNotExist) {
		return modeLight, nil
	}
	if err != nil {
		return "", fmt.Errorf("read state: %w", err)
	}
	state := mode(strings.TrimSpace(string(data)))
	if state != modeDark && state != modeLight {
		return "", fmt.Errorf("invalid state %q in %s", state, a.statePath())
	}
	return state, nil
}

func (a *app) writeState(next mode) error {
	if err := os.MkdirAll(a.configDir, 0o755); err != nil {
		return fmt.Errorf("create config dir: %w", err)
	}
	if err := os.WriteFile(a.statePath(), []byte(next+"\n"), 0o644); err != nil {
		return fmt.Errorf("write state: %w", err)
	}
	return nil
}

func (a *app) activate(name string, prio *int) error {
	if err := validateScriptName(name); err != nil {
		return err
	}
	if err := a.ensureDirs(); err != nil {
		return err
	}
	scriptPath := filepath.Join(a.scriptsDir(), name)
	info, err := os.Stat(scriptPath)
	if err != nil {
		return fmt.Errorf("find script %s: %w", name, err)
	}
	if info.IsDir() {
		return fmt.Errorf("script %s is a directory", name)
	}
	if info.Mode().Perm()&0o111 == 0 {
		return fmt.Errorf("script %s is not executable", name)
	}

	entries, err := readActiveEntries(a.activeDir())
	if err != nil {
		return err
	}
	existing := activeByName(entries, name)
	if existing != nil {
		if prio == nil {
			fmt.Fprintf(a.stdout, "%s is already active\n", name)
			return nil
		}
		if err := os.Remove(filepath.Join(a.activeDir(), existing.fileName)); err != nil {
			return fmt.Errorf("update active script %s: %w", name, err)
		}
	}

	targetPrio := initialPrio
	if prio != nil {
		targetPrio = *prio
	} else if len(entries) > 0 {
		targetPrio = maxPriority(entries) + prioIncrement
	}

	linkName := fmt.Sprintf("%d-%s", targetPrio, name)
	if err := os.Symlink(scriptPath, filepath.Join(a.activeDir(), linkName)); err != nil {
		return fmt.Errorf("activate %s: %w", name, err)
	}
	fmt.Fprintf(a.stdout, "activated %s as %s\n", name, linkName)
	return nil
}

func (a *app) deactivate(name string) error {
	if err := validateScriptName(name); err != nil {
		return err
	}
	entries, err := readActiveEntries(a.activeDir())
	if errors.Is(err, os.ErrNotExist) {
		return nil
	}
	if err != nil {
		return err
	}
	for _, entry := range entries {
		if entry.scriptName == name {
			if err := os.Remove(filepath.Join(a.activeDir(), entry.fileName)); err != nil {
				return fmt.Errorf("deactivate %s: %w", name, err)
			}
			fmt.Fprintf(a.stdout, "deactivated %s\n", name)
			return nil
		}
	}
	return nil
}

func (a *app) renumber() error {
	entries, err := readActiveEntries(a.activeDir())
	if errors.Is(err, os.ErrNotExist) {
		return nil
	}
	if err != nil {
		return err
	}
	sortActive(entries)

	for i, entry := range entries {
		nextPrio := initialPrio + (i * prioIncrement)
		nextName := fmt.Sprintf("%d-%s", nextPrio, entry.scriptName)
		if entry.fileName == nextName {
			continue
		}
		if err := os.Rename(filepath.Join(a.activeDir(), entry.fileName), filepath.Join(a.activeDir(), nextName)); err != nil {
			return fmt.Errorf("renumber %s: %w", entry.fileName, err)
		}
	}
	fmt.Fprintln(a.stdout, "renumbered active scripts")
	return nil
}

func (a *app) executeScripts(next mode) error {
	entries, err := readActiveEntries(a.activeDir())
	if errors.Is(err, os.ErrNotExist) {
		a.logger.Printf("no active scripts")
		return nil
	}
	if err != nil {
		return err
	}
	sortActive(entries)
	for _, entry := range entries {
		path := filepath.Join(a.activeDir(), entry.fileName)
		a.logger.Printf("running %s %s", entry.fileName, next)
		cmd := exec.Command(path, string(next))
		out, err := cmd.CombinedOutput()
		if len(out) > 0 {
			for _, line := range strings.Split(strings.TrimRight(string(out), "\n"), "\n") {
				if line != "" {
					a.logger.Printf("%s: %s", entry.fileName, line)
				}
			}
		}
		if err != nil {
			return fmt.Errorf("run %s: %w", entry.fileName, err)
		}
	}
	return nil
}

type activeEntry struct {
	fileName   string
	scriptName string
	prio       *int
}

func readActiveEntries(dir string) ([]activeEntry, error) {
	files, err := os.ReadDir(dir)
	if err != nil {
		return nil, err
	}

	var entries []activeEntry
	for _, file := range files {
		if file.IsDir() {
			continue
		}
		entry := parseActiveName(file.Name())
		entries = append(entries, entry)
	}
	return entries, nil
}

func parseActiveName(name string) activeEntry {
	prefix, rest, ok := strings.Cut(name, "-")
	if !ok {
		return activeEntry{fileName: name, scriptName: name}
	}
	prio, err := strconv.Atoi(prefix)
	if err != nil {
		return activeEntry{fileName: name, scriptName: name}
	}
	return activeEntry{fileName: name, scriptName: rest, prio: &prio}
}

func sortActive(entries []activeEntry) {
	sort.SliceStable(entries, func(i, j int) bool {
		left, right := entries[i], entries[j]
		if left.prio == nil && right.prio != nil {
			return false
		}
		if left.prio != nil && right.prio == nil {
			return true
		}
		if left.prio != nil && right.prio != nil && *left.prio != *right.prio {
			return *left.prio < *right.prio
		}
		return left.fileName < right.fileName
	})
}

func activeByName(entries []activeEntry, name string) *activeEntry {
	for i := range entries {
		if entries[i].scriptName == name {
			return &entries[i]
		}
	}
	return nil
}

func maxPriority(entries []activeEntry) int {
	max := initialPrio - prioIncrement
	for _, entry := range entries {
		if entry.prio != nil && *entry.prio > max {
			max = *entry.prio
		}
	}
	return max
}

func validateScriptName(name string) error {
	if name == "" {
		return errors.New("script name cannot be empty")
	}
	if strings.Contains(name, "/") || strings.Contains(name, string(filepath.Separator)) || name == "." || name == ".." {
		return fmt.Errorf("invalid script name %q", name)
	}
	return nil
}