tail.go

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

package main

import (
	"fmt"
	"github.com/awesome-gocui/gocui"
	"github.com/pkg/errors"
	"time"

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

const includeDebugView = false

var _ gocui.Manager = (*TailLayoutManager)(nil)

type TailLayoutManager struct {
	engine *tailEngine.Engine
	events EventHandlers
}

func NewTailLayoutManager(engine *tailEngine.Engine) *TailLayoutManager {
	return &TailLayoutManager{
		engine: engine,
		events: NewEventHandlers(),
	}
}

func (layout *TailLayoutManager) SetEventHandler(event string, handler EventHandler) {
	layout.events.SetEventHandler(event, handler)
}

func (layout *TailLayoutManager) SetLayoutKeybindings(gui *gocui.Gui) error {
	if err := layout.events.BindKeysToEvents(gui, gocui.ModNone, map[interface{}]string{
		'q': "quit",
		'Q': "quit",
		'/': "search",
	}); err != nil {
		return errors.WithStack(err)
	}
	return nil
}

func (layout *TailLayoutManager) Layout(gui *gocui.Gui) error {

	gui.Cursor = false

	// filter views
	totalFilters := layout.engine.TotalFilters()
	for index, ftr := range layout.engine.Filters() {
		if err := layout.setFilterView(gui, totalFilters, index, ftr); err != nil {
			return errors.WithStack(err)
		}
	}

	// debug view
	if includeDebugView {
		if err := layout.setDebugView(gui); err != nil {
			return errors.WithStack(err)
		}
	}

	return nil
}

func (layout *TailLayoutManager) setDebugView(gui *gocui.Gui) error {

	maxX, maxY := gui.Size()
	name := "debug"
	width := 20
	height := 8
	margin := 1
	view, err := gui.SetView(name, maxX-width-margin, margin, maxX-margin, height+margin, 0)
	if err != nil && !errors.Is(err, gocui.ErrUnknownView) {
		return errors.WithStack(err)
	}

	view.Editable = false
	view.Wrap = false
	view.Autoscroll = false

	view.Title = "debug"
	view.Clear()
	_, _ = fmt.Fprintf(view, "now=%d\n", time.Now().UTC().Unix())
	_, _ = fmt.Fprintf(view, "size=%d\n", layout.engine.InputBufferSize())
	_, _ = fmt.Fprintf(view, "length=%d\n", layout.engine.InputBufferLength())
	_, _ = fmt.Fprintf(view, "filters=%d\n", layout.engine.TotalFilters())
	_, _ = fmt.Fprintf(view, "maxX=%d\n", maxX)
	_, _ = fmt.Fprintf(view, "maxY=%d\n", maxY)

	if _, err := gui.SetCurrentView(name); err != nil {
		return errors.WithStack(err)
	}

	return nil
}

func (layout *TailLayoutManager) setFilterView(gui *gocui.Gui, total, index int, ftr *tailEngine.Filter) error {

	name := fmt.Sprintf("filter-%d", index)

	maxX, maxY := gui.Size()
	startY, endY := layout.sizeForTailView(maxX, maxY, total, index)
	view, err := gui.SetView(name, -1, startY, maxX, endY, 0)
	if err != nil && !errors.Is(err, gocui.ErrUnknownView) {
		return errors.WithStack(err)
	}

	view.Editable = false
	view.Wrap = false
	view.Autoscroll = true

	view.Title = ftr.Text()

	height := endY - startY

	view.Clear()
	err = ftr.VisitLast(height+5, func(idx int, line []byte) (err error) {
		if _, err = view.Write(line); err != nil {
			return err
		}
		if _, err = view.Write([]byte("\n")); err != nil {
			return err
		}
		return nil
	})

	if ftr.Size() < height {
		for i := 0; i < height-ftr.Size()-2; i++ {
			if _, err = view.Write([]byte("\n")); err != nil {
				return err
			}
		}
		if _, err = view.Write([]byte(fmt.Sprintf(
			"WARNING: buffer of %d lines is too small for this view of %d lines\n",
			ftr.Size(), height,
		))); err != nil {
			return err
		}
	}

	return err
}

func (layout *TailLayoutManager) sizeForTailView(maxX, maxY, total, index int) (startY int, endY int) {
	if total <= 0 {
		return -1, maxX
	}
	viewsHeight := maxY / total
	startY = viewsHeight * index
	if index == 0 {
		startY = -1
	}
	endY = viewsHeight * (index + 1)
	if index >= total-1 {
		endY = maxY
	}
	return startY, endY
}