main.go

//  @author: Brian Wojtczak
//  @copyright: 2024 by Brian Wojtczak
//  @license: BSD-style license found in the LICENSE file

package main

import (
	"flag"
	"fmt"
	"github.com/awesome-gocui/gocui"
	"github.com/pkg/errors"
	"log"
	"os"
	"path"
	"strings"
	"sync/atomic"
	"time"

	tailEngine "github.com/k42-software/tailwatch/engine"
)

type layoutModeType int

const (
	layoutModeTail layoutModeType = iota
	layoutModeDialog
)

var (
	currentLayoutMode = &atomic.Value{}
)

func main() {

	// Parse Command Line Arguments
	size, filename, filters := parseArguments()

	// Start Tail Engine
	engine, err := startTailEngine(size, filename, filters)
	if engine != nil {
		defer func() {
			if err := engine.Close(); err != nil {
				log.Printf("ERROR: %+v", err)
			}

		}()
	}
	if err != nil {
		log.Fatalf("ERROR: %+v", err)
	}

	// Start GUI
	if err = startGui(engine); err != nil {
		log.Panicf("%+v", err)
	}
}

func parseArguments() (
	size int,
	filename string,
	filters []string,
) {

	flag.Usage = func() {
		app := path.Base(os.Args[0])
		w := flag.CommandLine.Output()
		_, _ = fmt.Fprintf(w, "Usage: %s [options] filename\n\n", app)
		flag.PrintDefaults()
		_, _ = fmt.Fprintf(w, "\n")
	}

	flag.BoolFunc(
		"version",
		"Show the version of the program",
		func(_ string) error {
			fmt.Printf("TailWatch\n")
			fmt.Printf("Version: 0.0.1\n")
			fmt.Printf("Author: Brian Wojtczak <brian@k42.io>\n")
			os.Exit(0)
			return nil
		})

	flag.IntVar(
		&size,
		"size",
		128,
		"The number of lines to buffer",
	)
	flag.Func(
		"filter",
		"Keyword(s) for filtering (can specify multiple times or as CSV)",
		func(text string) error {
			text = strings.TrimSpace(text)
			filters = append(filters, strings.Split(text, ",")...)
			return nil
		})

	flag.Parse()

	if size <= 1 {
		fmt.Println("ERROR: size must be greater than 1")
		flag.Usage()
		os.Exit(1)
	}

	if flag.NArg() < 1 {
		fmt.Println("ERROR: filename is required")
		flag.Usage()
		os.Exit(1)

	} else if flag.NArg() == 1 {
		filename = flag.Arg(0)

	} else {
		fmt.Println("ERROR: too many positional arguments")
		flag.Usage()
		os.Exit(1)
	}

	return size, filename, filters
}

func startTailEngine(
	size int,
	filename string,
	filters []string,
) (engine *tailEngine.Engine, err error) {

	// Initialize Tail Engine
	engine = tailEngine.NewTailEngine(size)

	// Initialize the empty filter which gives us our "everything" view.
	if _, err := engine.Filter(""); err != nil {
		return engine, errors.WithStack(err)
	}

	// Initialize Filters from the command line arguments
	if len(filters) > 0 {
		for _, text := range filters {
			if _, err := engine.Filter(text); err != nil {
				return engine, errors.Wrapf(
					err, "engine.Filter(%s)", text,
				)
			}
		}
	}

	// Start Tail
	err = engine.TailFile(filename)
	if err != nil {
		return engine, errors.WithStack(err)
	}

	return engine, nil
}

func startGui(engine *tailEngine.Engine) error {

	// Initialize GUI
	gui, err := gocui.NewGui(gocui.OutputNormal, false)
	if err != nil {
		return errors.WithStack(err)
	}
	defer gui.Close()

	// Initialize the layout mode
	if err = switchLayoutMode(gui, engine, layoutModeTail); err != nil {
		return errors.WithStack(err)
	}

	// Updates
	go func() {
		ticker := time.NewTicker(time.Second / 15)
		for range ticker.C {
			if currentLayoutMode.Load() == layoutModeTail && engine.IsDirty() {
				gui.Update(func(gui *gocui.Gui) error {
					engine.SetDirty(false)
					return nil
				})
			}
		}
	}()

	// Main Loop
	if err = gui.MainLoop(); err != nil && !errors.Is(err, gocui.ErrQuit) {
		return errors.WithStack(err)
	}

	return nil
}

func switchLayoutMode(
	gui *gocui.Gui,
	engine *tailEngine.Engine,
	targetLayout layoutModeType,
) error {

	switch targetLayout {
	case layoutModeTail:
		if err := startLayoutModeTail(gui, engine); err != nil {
			return errors.WithStack(err)
		}

	case layoutModeDialog:
		if err := startLayoutModeDialog(gui, engine); err != nil {
			return errors.WithStack(err)
		}

	default:
		return errors.Errorf("unknown layout mode: %d", targetLayout)
	}

	if err := setGlobalKeybindings(gui); err != nil {
		return errors.WithStack(err)
	}

	return nil
}

func startLayoutModeTail(gui *gocui.Gui, engine *tailEngine.Engine) error {
	currentLayoutMode.Store(layoutModeTail)

	layout := NewTailLayoutManager(engine)
	gui.SetManager(layout)

	layout.SetEventHandler("quit", func() error {
		return quit(gui, nil)
	})
	layout.SetEventHandler("search", func() error {
		return switchLayoutMode(gui, engine, layoutModeDialog)
	})
	if err := layout.SetLayoutKeybindings(gui); err != nil {
		return errors.WithStack(err)
	}

	return nil
}

func startLayoutModeDialog(gui *gocui.Gui, engine *tailEngine.Engine) error {
	currentLayoutMode.Store(layoutModeDialog)

	layout := NewDialogLayoutManager(gui, engine)
	gui.SetManager(layout)

	layout.SetEventHandler("quit", func() error {
		return quit(gui, nil)
	})
	layout.SetEventHandler("close", func() error {
		return switchLayoutMode(gui, engine, layoutModeTail)
	})
	if err := layout.SetLayoutKeybindings(gui); err != nil {
		return errors.WithStack(err)
	}

	return nil
}

func setGlobalKeybindings(gui *gocui.Gui) error {
	if err := gui.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
		return errors.WithStack(err)
	}
	return nil
}

func quit(_ *gocui.Gui, _ *gocui.View) error {
	return gocui.ErrQuit
}