breakfast/main.go

package main

import (
	"fmt"
	"io/fs"
	"log"
	"os"
	"os/exec"
	"strings"

	tea "github.com/charmbracelet/bubbletea"
)

// Enum for the different launch types (browsers and CLI's)
const (
	BrowserSessions int = iota
	Commands
)

type commandChoice struct {
	displayString string
	command       *exec.Cmd
}

type Choices []commandChoice

type model struct {
	cursor   int
	choices  Choices
	selected map[int]struct{}
	status   string
}

type statusMsg string

var selection map[int]struct{}

func getBrowserSessions() []commandChoice {
	// 1. List files in $XDG_DATA_HOME/qutebrowser/sessions/ (N.B.:
	//    UserConfigDir() in os)
	userConfigDir, err := os.UserConfigDir()
	if err != nil {
		log.Printf("Error finding user configuration directory: %v", err)
		return []commandChoice{}
	}
	log.Printf("INFO userConfigDir: %+v", userConfigDir)
	fileSystem := os.DirFS(userConfigDir)
	log.Printf("INFO fileSystem: %+v", fileSystem)
	fileList, err := fs.ReadDir(fileSystem, "local/share/qutebrowser/sessions")
	if err != nil {
		log.Printf("Error reading browser sessions directory: %v", err)
		return []commandChoice{}
	}
	// 2. Exclude non-YAML files
	// 3. Wrangle them into this struct array
	result := make([]commandChoice, 0)
	for _, entry := range fileList {
		if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".yml") {
			log.Printf("INFO %s", entry.Name())
			result = append(result, commandChoice{
				displayString: fmt.Sprintf("Qutebrowser session: %s", strings.TrimSuffix(entry.Name(), ".yml")),
				command:       exec.Command("xterm", "-e", "qutebrowser", "--target", "window", "--restore", strings.TrimSuffix(entry.Name(), ".yml")),
			})
		}
	}
	// log.Printf("result: %v", result)
	return result
}

func initialModel() model {
	return model{
		cursor: 0,
		choices: append(
			getBrowserSessions(),
			commandChoice{
				displayString: "bottom",
				command:       exec.Command("xterm", "-maximized", "-e", "btm", "--group", "--battery", "--color", "gruvbox-light"),
			},
			commandChoice{
				displayString: "broot",
				command:       exec.Command("xterm", "-maximized", "-e", "broot"),
			},
			commandChoice{
				displayString: "joplin",
				command:       exec.Command("xterm", "-maximized", "-e", "joplin"),
			},
			commandChoice{
				displayString: "neomutt",
				command:       exec.Command("xterm", "-maximized", "-e", "neomutt"),
			},
			commandChoice{
				displayString: "newsboat",
				command:       exec.Command("xterm", "-maximized", "-e", "newsboat"),
			},
		),
		selected: make(map[int]struct{}),
	}
}

func launch(m model) tea.Cmd {
	return func() tea.Msg {
		var result statusMsg
		for q, item := range m.choices {
			if _, ok := m.selected[q]; ok {
				log.Printf("INFO launching: %v\n", item.displayString)
				result += statusMsg(fmt.Sprintf("Launching command: %v\n", item.displayString))
				err := item.command.Start()
				if err != nil {
					result += statusMsg(fmt.Sprintf("%v\n", err))
					log.Fatalf("Error launching: %v\n", err)
				}
			}
		}

		for r, item := range m.choices {
			if _, ok := m.selected[r]; ok {
				err := item.command.Wait()
				if err != nil {
					result += statusMsg(fmt.Sprintf("%v\n", err))
					log.Fatalf("Error during Wait(): %v\n", err)
				}
			}
		}

		return result
	}
}

func (m model) Init() tea.Cmd {
	return nil
}

func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case statusMsg:
		m.status = string(msg)
		return m, tea.Quit
	case tea.KeyMsg:
		switch msg.String() {
		case "ctrl+c", "q":
			return m, tea.Quit
		case "up", "k":
			if m.cursor > 0 {
				m.cursor--
			}
		case "down", "j":
			if m.cursor < len(m.choices)-1 {
				m.cursor++
			}
		case " ":
			_, ok := m.selected[m.cursor]
			if ok {
				delete(m.selected, m.cursor)
			} else {
				m.selected[m.cursor] = struct{}{}
			}
		case "enter":
			return m, launch(m)
		}
	}

	return m, nil
}

func (m model) View() string {
	s := "\nLet's get started!\n\n"

	for i, choice := range m.choices {
		cursor := " "
		if m.cursor == i {
			cursor = ">"
		}

		checked := " "
		if _, ok := m.selected[i]; ok {
			checked = "x"
		}

		s += fmt.Sprintf("%s [%s] %s\n", cursor, checked, choice.displayString)
	}
	s += "\n\n"

	// s += fmt.Sprintf("\n%+v", m.selected) // debug
	s += fmt.Sprintf("%s\n", m.status)
	s += "Press enter to launch.\n"
	s += "Press q to quit.\n"

	return s
}

func main() {
	// Logging example from the Bubbletea "simple" example. For some
	// reason there's no file variable, and hence no file to `.Close()`.
	logfilePath := os.Getenv("BUBBLETEA_LOG")
	if logfilePath != "" {
		if _, err := tea.LogToFile(logfilePath, "DEBUG"); err != nil {
			log.Fatal(err)
		}
	}

	p := tea.NewProgram(initialModel())
	if err := p.Start(); err != nil {
		fmt.Printf("Alas, there's been an error: %v", err)
		os.Exit(1)
	}
}