editor.go

package wig

import (
	"os"
	"path"
	"path/filepath"
	"strings"

	"github.com/gdamore/tcell/v2"
)

type EditorConfig struct {
	Theme                string
	ShowLineNumbers      bool
	RelativeLineNumbers  bool
	CurrentLineAbsolute  bool // If true, shows absolute line number on current line when relative is on
	FormatOnSave         bool
	GitStatusView        string // "full" or "split"
	GitBlameView         string // "full" or "split"
	IndentGuides         bool
	FloatingWindowWidth  float64
	FloatingWindowHeight float64
}

type View interface {
	SetContent(x, y int, str string, st tcell.Style)
	Size() (width, height int)
	Resize(x, y, width, height int)
}

type RenderPlane int

const (
	PlaneWin    RenderPlane = 0
	PlaneEditor RenderPlane = 1
)

type UiComponent interface {
	Mode() Mode
	Keymap() *KeyHandler
	Render(view View)
	Plane() RenderPlane
}

type Context struct {
	Editor *Editor
	Buf    *Buffer
	Win    *Window
	Count  uint32
	Char   string
}

type AutocompleteFn func(Context) bool

// MarksPopupFactory allows the `ui` package to register a popup for marks
// without causing a circular import.
var MarksPopupFactory func(ctx Context, marks map[rune]Mark)

var EditorInst *Editor

type Layout int

const (
	LayoutHorizontal Layout = 0
	LayoutVertical   Layout = 1
)

type Workspace struct {
	Num          int
	Windows      []*Window
	ActiveWindow *Window
}

type Editor struct {
	View                View
	Keys                *KeyHandler
	Buffers             []*Buffer
	UiComponents        []UiComponent
	ExitCh              chan int
	RedrawCh            chan int
	ScreenSyncCh        chan int
	Layout              Layout
	Yanks               List[yank]
	Projects            ProjectManager
	Message             string // display in echo area
	Lsp                 *LspManager
	Events              *EventsManager
	AutocompleteTrigger AutocompleteFn
	Snippets            *SnippetsManager
	Config              EditorConfig
	Workspaces          []Workspace
	ActiveWorkspace     int
}

func NewEditor(
	view View,
	keys *KeyHandler,
) *Editor {
	windows := []*Window{CreateWindow(nil)}
	workspaces := make([]Workspace, 10)
	workspaces[1].Windows = windows

	EditorInst = &Editor{
		View:            view,
		Keys:            keys,
		Buffers:         make([]*Buffer, 0, 32),
		Yanks:           List[yank]{},
		Layout:          LayoutVertical,
		Projects:        NewProjectManager(),
		ExitCh:          make(chan int),
		RedrawCh:        make(chan int, 10),
		ScreenSyncCh:    make(chan int),
		Events:          NewEventsManager(),
		Snippets:        NewSnippetsManager(),
		Workspaces:      workspaces,
		ActiveWorkspace: 1,
	}

	EditorInst.Lsp = NewLspManager(EditorInst)
	TreeSitterHighlighterGo(EditorInst)
	EditorInst.SetWindows(windows)
	EditorInst.SetActiveWindow(windows[0])

	return EditorInst
}

func (e *Editor) Windows() []*Window {
	return e.Workspaces[e.ActiveWorkspace].Windows
}

func (e *Editor) SetWindows(w []*Window) {
	e.Workspaces[e.ActiveWorkspace].Windows = w
}

func (e *Editor) ReadConfigFile() {
	e.Config = EditorConfig{
		Theme:                "naysayer",
		ShowLineNumbers:      true,
		RelativeLineNumbers:  true,
		CurrentLineAbsolute:  true,
		FormatOnSave:         false,
		GitStatusView:        "full",
		GitBlameView:         "split",
		IndentGuides:         true,
		FloatingWindowWidth:  0.8,
		FloatingWindowHeight: 0.8,
	}
}

func (e *Editor) OpenFile(path string) (*Buffer, error) {
	absPath, err := filepath.Abs(path)
	if err == nil {
		path = absPath
	}
	if fbuf := e.BufferFindByFilePath(path, false); fbuf != nil {
		return fbuf, nil
	}

	buf, err := BufferReadFile(path)
	if err != nil {
		e.LogError(err)
		return nil, err
	}

	e.Buffers = append(e.Buffers, buf)
	e.Lsp.DidOpen(buf)

	hl := TreeSitterHighlighterInitBuffer(e, buf)
	if hl != nil {
		buf.Highlighter = hl
	}

	// Broadcast event so GitGutterManager calculates signs for newly opened file
	e.Events.Broadcast(EventBufferReloaded{Buf: buf})

	return buf, nil
}

func (e *Editor) NewContext() Context {
	return Context{
		Editor: e,
		Buf:    e.ActiveBuffer(),
		Win:    e.ActiveWindow(),
		Count:  0,
	}
}

// Find or create new buffer by its full file path
func (e *Editor) BufferFindByFilePath(fp string, create bool) *Buffer {
	for _, b := range e.Buffers {
		if b.FilePath == fp {
			return b
		}
	}

	if !create {
		return nil
	}

	b := NewBuffer()
	b.FilePath = fp
	e.Buffers = append(e.Buffers, b)

	return b
}

// Returns active window buffer.
// May return nil when the active workspace has no active window/buffer,
// e.g. transiently after ":q" closed the last window.
func (e *Editor) ActiveBuffer() *Buffer {
	win := e.ActiveWindow()
	if win == nil {
		return nil
	}
	return win.Buffer()
}

func (e *Editor) GetActiveWorkspace() *Workspace {
	return &e.Workspaces[e.ActiveWorkspace]
}

func (e *Editor) GetWorkspace(num int) *Workspace {
	return &e.Workspaces[num]
}

func (e *Editor) ActiveWindow() *Window {
	return e.GetActiveWorkspace().ActiveWindow
}

func (e *Editor) SetActiveWindow(w *Window) {
	e.Workspaces[e.ActiveWorkspace].ActiveWindow = w
}

func (e *Editor) PushUi(c UiComponent) {
	e.UiComponents = append(e.UiComponents, c)
}

func (e *Editor) PopUi() {
	if len(e.UiComponents) > 0 {
		e.UiComponents = e.UiComponents[:len(e.UiComponents)-1]
	}
}

// PopUiComponent removes a specific UI component from the stack.
// This is required for WhichKey because commands executed from WhichKey
// can push their own UI components (Picker, CommandLine, etc.) before
// WhichKey.Close is called. Using PopUi in that case removes the newly
// pushed component instead of WhichKey, leaving WhichKey stuck on screen.
func (e *Editor) PopUiComponent(c UiComponent) {
	for i := len(e.UiComponents) - 1; i >= 0; i-- {
		if e.UiComponents[i] == c {
			e.UiComponents = append(e.UiComponents[:i], e.UiComponents[i+1:]...)
			break
		}
	}
}

func (e *Editor) EnsureBufferIsVisible(b *Buffer) {
	for _, win := range e.Windows() {
		if win.Buffer() == b {
			return
		}
	}
	if len(e.Windows()) > 1 {
		e.Windows()[len(e.Windows())-1].ShowBuffer(b)
		return
	}
	win := CreateWindow(nil)
	win.buf = b
	windows := e.Windows()
	windows = append(windows, win)
}

func (e *Editor) HandleInput(ev *tcell.EventKey) {
	var k *KeyHandler

	win := e.ActiveWindow()
	if win == nil {
		// Workspace teardown in progress (e.g. right after ":q"): drop event.
		return
	}
	buf := win.Buffer()
	if buf == nil {
		// No active buffer yet: drop event instead of nil-deref in buf.Mode().
		return
	}
	mode := buf.Mode()
	e.Message = ""

	if buf.KeyHandler != nil {
		k = buf.KeyHandler
	} else {
		k = e.Keys
	}

	if len(e.UiComponents) > 0 {
		comp := e.UiComponents[len(e.UiComponents)-1]
		k = comp.Keymap()
		mode = comp.Mode()
	}

	k.HandleKey(e, ev, mode)
}

func (e *Editor) LogError(err error, echo ...bool) {
	buf := e.BufferFindByFilePath("[Messages]", true)
	buf.Append("error: " + err.Error())
	if len(echo) > 0 && echo[0] == true {
		e.EchoMessage(err.Error())
	}
}

func (e *Editor) LogMessage(msg ...string) {
	for _, m := range msg {
		buf := e.BufferFindByFilePath("[Messages]", true)
		buf.Append(m)
	}
}

func (e *Editor) RuntimeDir(elems ...string) string {
	p := []string{os.Getenv("HOME"), ".config", "wig"}
	elems = append(p, elems...)
	return path.Join(elems...)
}

func (e *Editor) EchoMessage(msg string) {
	msg = strings.ReplaceAll(msg, "\n", " ")
	buf := e.BufferFindByFilePath("[Messages]", true)
	buf.Append(msg)
	e.Message = msg
}

func (e *Editor) Redraw() {
	e.RedrawCh <- 1
}

func (e *Editor) ScreenSync() {
	e.ScreenSyncCh <- 1
}

// CmdToggleIndentGuides flips the IndentGuides config flag at runtime so
// you can show/hide virtual indent guides without restarting. The initial
// value comes from the "indent_guides" key in config.toml (default: true).
func CmdToggleIndentGuides(ctx Context) {
	ctx.Editor.Config.IndentGuides = !ctx.Editor.Config.IndentGuides
	ctx.Editor.Redraw()
}