c{0: 0 (((1 string-address)) <- ((new)) hello, _!) -- nil
c{0: 1 (((2 string-address)) <- ((new)) abc) -- nil
c{0: 2 (((3 string-address)) <- ((interpolate)) ((1 string-address)) ((2 string-address))) -- nil
c{1: 0 ✓ (((1 string-address)) <- ((new)) hello, _!)
c{1: 1 ✓ (((2 string-address)) <- ((new)) abc)
c{1: 2 ✓ (((3 string-address)) <- ((interpolate)) ((1 string-address)) ((2 string-address)))
cn0: convert-names in main
cn0: (((1 string-address)) <- ((new)) hello, _!) nil nil
cn0: checking arg hello, _!
cn0: checking oarg ((1 string-address))
maybe-add: ((1 string-address))
cn0: (((2 string-address)) <- ((new)) abc) nil nil
cn0: checking arg abc
cn0: checking oarg ((2 string-address))
maybe-add: ((2 string-address))
cn0: (((3 string-address)) <- ((interpolate)) ((1 string-address)) ((2 string-address))) nil nil
cn0: checking arg ((1 string-address))
maybe-add: ((1 string-address))
cn0: checking arg ((2 string-address))
maybe-add: ((2 string-address))
cn0: checking oarg ((3 string-address))
maybe-add: ((3 string-address))
cn1: (((1 string-address)) <- ((new)) hello, _!)
cn1: (((2 string-address)) <- ((new)) abc)
cn1: (((3 string-address)) <- ((interpolate)) ((1 string-address)) ((2 string-address)))
schedule: main
run: main 0: (((1 string-address)) <- ((new)) hello, _!)
run: main 0: 1000 => ((1 string-address))
mem: ((1 string-address)): 1 <= 1000
run: main 1: (((2 string-address)) <- ((new)) abc)
run: main 1: 1010 => ((2 string-address))
mem: ((2 string-address)): 2 <= 1010
run: main 2: (((3 string-address)) <- ((interpolate)) ((1 string-address)) ((2 string-address)))
mem: ((1 string-address)) => 1000
mem: ((2 string-address)) => 1010
run: interpolate/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((60 literal)))
run: interpolate/main 0: 1014 => ((default-space space-address))
run: interpolate/main 1: (((1 string-address)) <- ((next-input)))
arg: nil 0 (1000 1010)
run: interpolate/main 1: 1000 => ((1 string-address))
mem: ((1 string-address)): 1016 <= 1000
run: interpolate/main 2: (((2 integer)) <- ((length)) ((1 string-address) (deref)))
array-len: ((1 string-address) (deref))
mem: ((1000 integer) (raw)) => 9
run: interpolate/main 2: 9 => ((2 integer))
mem: ((2 integer)): 1017 <= 9
run: interpolate/main 3: (((3 integer)) <- ((copy)) ((2 integer)))
mem: ((2 integer)) => 9
run: interpolate/main 3: 9 => ((3 integer))
mem: ((3 integer)): 1018 <= 9
run: interpolate/main 4: (((4 string-address)) ((5 boolean)) <- ((next-input)))
arg: nil 1 (1000 1010)
run: interpolate/main 4: 1010 => ((4 string-address))
mem: ((4 string-address)): 1019 <= 1010
run: interpolate/main 4: t => ((5 boolean))
mem: ((5 boolean)): 1020 <= t
run: interpolate/main 5: (((jump-unless)) ((5 boolean)) ((4 offset)))
mem: ((5 boolean)) => t
run: interpolate/main 6: (((6 integer)) <- ((length)) ((4 string-address) (deref)))
array-len: ((4 string-address) (deref))
mem: ((1010 integer) (raw)) => 3
run: interpolate/main 6: 3 => ((6 integer))
mem: ((6 integer)): 1021 <= 3
run: interpolate/main 7: (((3 integer)) <- ((add)) ((3 integer)) ((6 integer)))
mem: ((3 integer)) => 9
mem: ((6 integer)) => 3
run: interpolate/main 7: 12 => ((3 integer))
mem: ((3 integer)): 1018 <= 12
run: interpolate/main 8: (((3 integer)) <- ((subtract)) ((3 integer)) ((1 literal)))
mem: ((3 integer)) => 12
run: interpolate/main 8: 11 => ((3 integer))
mem: ((3 integer)): 1018 <= 11
run: interpolate/main 9: (((jump)) ((-6 offset)))
run: interpolate/main 4: (((4 string-address)) ((5 boolean)) <- ((next-input)))
arg: nil 2 (1000 1010)
run: interpolate/main 4: nil => ((4 string-address))
mem: ((4 string-address)): 1019 <= nil
run: interpolate/main 4: nil => ((5 boolean))
mem: ((5 boolean)): 1020 <= nil
run: interpolate/main 5: (((jump-unless)) ((5 boolean)) ((4 offset)))
mem: ((5 boolean)) => nil
run: interpolate/main 10: (_ <- ((input)) ((0 literal)))
arg: (((0 literal))) 0 (1000 1010)
run: interpolate/main 11: (((7 string-address)) <- ((new)) ((string literal)) ((3 integer)))
mem: ((3 integer)) => 11
run: interpolate/main 11: 1075 => ((7 string-address))
mem: ((7 string-address)): 1022 <= 1075
run: int
package main

import (
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"os"
	"time"

	"github.com/mattn/go-isatty"

	"git.sr.ht/~sircmpwn/aerc/commands"
	"git.sr.ht/~sircmpwn/aerc/commands/account"
	"git.sr.ht/~sircmpwn/aerc/commands/compose"
	"git.sr.ht/~sircmpwn/aerc/commands/msgview"
	"git.sr.ht/~sircmpwn/aerc/commands/terminal"
	"git.sr.ht/~sircmpwn/aerc/config"
	libui "git.sr.ht/~sircmpwn/aerc/lib/ui"
	"git.sr.ht/~sircmpwn/aerc/widgets"
)

func getCommands(selected libui.Drawable) []*commands.Commands {
	switch selected.(type) {
	case *widgets.AccountView:
		return []*commands.Commands{
			account.AccountCommands,
			commands.GlobalCommands,
		}
	case *widgets.Composer:
		return []*commands.Commands{
			compose.ComposeCommands,
			commands.GlobalCommands,
		}
	case *widgets.MessageViewer:
		return []*commands.Commands{
			msgview.MessageViewCommands,
			commands.GlobalCommands,
		}
	case *widgets.Terminal:
		return []*commands.Commands{
			terminal.TerminalCommands,
			commands.GlobalCommands,
		}
	default:
		return []*commands.Commands{commands.GlobalCommands}
	}
}

func main() {
	var (
		logOut io.Writer
		logger *log.Logger
	)
	if !isatty.IsTerminal(os.Stdout.Fd()) {
		logOut = os.Stdout
	} else {
		logOut = ioutil.Discard
	}
	logger = log.New(logOut, "", log.LstdFlags)
	logger.Println("Starting up aerc")

	conf, err := config.LoadConfig(nil)
	if err != nil {
		fmt.Printf("Failed to load config: %v\n", err)
		os.Exit(1)
	}

	var (
		aerc *widgets.Aerc
		ui   *libui.UI
	)
	aerc = widgets.NewAerc(conf, logger, func(cmd string) error {
		cmds := getCommands(aerc.SelectedTab())
		for i, set := range cmds {
			err := set.ExecuteCommand(aerc, cmd)
			if _, ok := err.(commands.NoSuchCommand); ok {
				if i == len(cmds)-1 {
					return err
				} else {
					continue
				}
			} else if _, ok := err.(commands.ErrorExit); ok {
				ui.Exit()
				return nil
			} else if err != nil {
				return err
			} else {
				break
			}
		}
		return nil
	})

	ui, err = libui.Initialize(conf, aerc)
	if err != nil {
		panic(err)
	}
	defer ui.Close()

	for !ui.ShouldExit() {
		if !ui.Tick() {
			// ~60 FPS
			time.Sleep(16 * time.Millisecond)
		}
	}
}