main.go

// main.go
// Copyright (C) 2024 Ricardo Melo
//
// Distributed under terms of the MIT license.
package main

import (
	"flag"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"strings"
	"time"

	"github.com/andreykaipov/goobs"
	"github.com/andreykaipov/goobs/api/requests/scenes"
)

// Config holds the application configuration
type Config struct {
	host             string
	port             string
	password         string
	passwordFile     string
	passwordProvided bool // true if password was explicitly provided via -password flag
	scene1           string
	scene2           string
	timeout          time.Duration
	verbose          bool
}

var osExit = os.Exit
var (
	version = "dev"
	commit  = "none"
	date    = "unknown"
)

func main() {
	// Initialize logging
	log.SetFlags(log.LstdFlags | log.Lshortfile)

	// Parse configuration
	config := parseFlags()

	if config.verbose {
		log.Printf("Connecting to OBS at %s:%s\n", config.host, config.port)
		log.Printf("Switching between scenes: %s and %s\n", config.scene1, config.scene2)
	}

	// Create and configure client
	client, err := createClient(config)
	if err != nil {
		// If connection failed and no password was explicitly provided,
		// try reading from password file as a fallback
		if !config.passwordProvided && config.password == "" && config.passwordFile != "" {
			if config.verbose {
				log.Printf("Initial connection failed, attempting with password from file...")
			}
			filePassword, readErr := readPasswordFromFile(config.passwordFile)
			if readErr == nil && filePassword != "" {
				config.password = filePassword
				if config.verbose {
					log.Printf("Retrying connection with password from: %s", config.passwordFile)
				}
				client, err = createClient(config)
			}
		}

		if err != nil {
			log.Fatalf("Failed to connect to OBS: %v", err)
		}
	}
	defer client.Disconnect()

	if err := switchScene(client, config); err != nil {
		log.Fatalf("Failed to switch scene: %v", err)
	}
}

// readPasswordFromFile reads and returns the password from a file
func readPasswordFromFile(filePath string) (string, error) {
	// Expand home directory if path starts with ~/
	if strings.HasPrefix(filePath, "~/") {
		home, err := os.UserHomeDir()
		if err != nil {
			return "", fmt.Errorf("failed to get home directory: %w", err)
		}
		filePath = filepath.Join(home, filePath[2:])
	}

	// Check if file exists
	if _, err := os.Stat(filePath); os.IsNotExist(err) {
		return "", nil // File doesn't exist, return empty password
	}

	// Read the file
	content, err := os.ReadFile(filePath)
	if err != nil {
		return "", fmt.Errorf("failed to read password file: %w", err)
	}

	// Trim whitespace and newlines
	password := strings.TrimSpace(string(content))
	return password, nil
}

// parseFlags handles command-line argument parsing and validation
func parseFlags() Config {
	config := Config{}

	var password string

	// Add version flag
	showVersion := flag.Bool("version", false, "Show version information")

	flag.StringVar(&config.host, "host", "localhost", "OBS WebSocket host")
	flag.StringVar(&config.port, "port", "4455", "OBS WebSocket port")
	flag.StringVar(&password, "password", "", "OBS WebSocket password")
	flag.StringVar(&config.passwordFile, "password-file", "~/.obspwd", "Path to file containing OBS WebSocket password")
	flag.DurationVar(&config.timeout, "timeout", 5*time.Second, "Connection timeout")
	flag.BoolVar(&config.verbose, "verbose", false, "Enable verbose logging")

	// Custom usage message
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "Usage: %s [options] <scene1> <scene2>\n\nOptions:\n", os.Args[0])
		flag.PrintDefaults()
	}

	flag.Parse()

	// Check if version flag was set
	if *showVersion {
		fmt.Printf("obs_switchscene %s (commit: %s, built at: %s)\n", version, commit, date)
		osExit(0)
	}
	// Validate positional arguments
	args := flag.Args()
	if len(args) != 2 {
		flag.Usage()
		osExit(1)
	}

	config.scene1 = args[0]
	config.scene2 = args[1]

	// Track if password was explicitly provided
	config.passwordProvided = password != ""
	config.password = password

	// Handle password: command-line takes precedence over file
	if config.password == "" && config.passwordFile != "" {
		filePassword, err := readPasswordFromFile(config.passwordFile)
		if err != nil {
			log.Printf("Warning: %v", err)
		} else if filePassword != "" {
			config.password = filePassword
			if config.verbose {
				log.Printf("Using password from file: %s", config.passwordFile)
			}
		}
	}

	return config
}

// createClient creates and configures an OBS WebSocket client with timeout
func createClient(config Config) (*goobs.Client, error) {
	connectionChan := make(chan struct {
		client *goobs.Client
		err    error
	}, 1)

	go func() {
		client, err := goobs.New(
			config.host+":"+config.port,
			goobs.WithPassword(config.password),
		)
		connectionChan <- struct {
			client *goobs.Client
			err    error
		}{client, err}
	}()

	select {
	case <-time.After(config.timeout):
		return nil, fmt.Errorf("connection timeout after %v", config.timeout)
	case result := <-connectionChan:
		return result.client, result.err
	}
}

// switchScene handles the scene switching logic
func switchScene(client *goobs.Client, config Config) error {
	// Get current scene
	currentSceneResp, err := client.Scenes.GetCurrentProgramScene()
	if err != nil {
		return fmt.Errorf("failed to get current scene: %w", err)
	}
	currentScene := currentSceneResp.CurrentProgramSceneName

	// Get scene list to validate both scenes exist
	sceneListResp, err := client.Scenes.GetSceneList()
	if err != nil {
		return fmt.Errorf("failed to get scene list: %w", err)
	}

	// Validate that both scenes exist
	sceneMap := make(map[string]bool)
	for _, scene := range sceneListResp.Scenes {
		sceneMap[scene.SceneName] = true
	}

	if !sceneMap[config.scene1] || !sceneMap[config.scene2] {
		return fmt.Errorf("one or both scenes do not exist: %s, %s", config.scene1, config.scene2)
	}

	// Determine which scene to switch to
	targetScene := config.scene1
	if currentScene == config.scene1 {
		targetScene = config.scene2
	}

	// Switch scene
	if config.verbose {
		log.Printf("Switching from scene '%s' to scene: '%s'\n", currentScene, targetScene)
	}

	params := scenes.NewSetCurrentProgramSceneParams().WithSceneName(targetScene)
	_, err = client.Scenes.SetCurrentProgramScene(params)
	if err != nil {
		return fmt.Errorf("failed to switch scene: %w", err)
	}

	return nil
}