program_tui.go

//go:build !js

package wui

import (
	"fmt"
	"net/http"
	"strings"

	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
	zone "github.com/lrstanley/bubblezone"

	"github.com/suprbdev/wui/webserver"
)

type platformState struct {
	teaProgram *tea.Program
	adapter    *teaAdapter
}

func newProgram(m Model, cfg config) *Program {
	zones := zone.New()
	adapter := &teaAdapter{
		model:    m,
		renderer: newTUIRenderer(80, 24, zones),
		focus:    newTUIFocusManager(),
		zones:    zones,
	}
	p := &Program{
		model: m,
		cfg:   cfg,
		platformState: platformState{
			adapter: adapter,
		},
	}
	// The adapter needs the Program to resolve the status line, which
	// depends on the live model and on config.
	adapter.program = p

	opts := []tea.ProgramOption{}
	if !cfg.noAltScreen {
		opts = append(opts, tea.WithAltScreen())
	}
	if !cfg.noMouse {
		opts = append(opts, tea.WithMouseCellMotion())
	}
	p.teaProgram = tea.NewProgram(adapter, opts...)
	return p
}

func (p *Program) run() error {
	if p.cfg.serveEnabled {
		ln, err := webserver.Listen(p.cfg.serveAddr)
		if err != nil {
			return fmt.Errorf("wui: web server: %w", err)
		}
		defer ln.Close()
		go http.Serve(ln, http.FileServer(http.Dir(p.cfg.webDir)))
		p.adapter.serveURL = webserver.URL(ln.Addr())
	}
	final, err := p.teaProgram.Run()
	if a, ok := final.(*teaAdapter); ok {
		p.model = a.model
	}
	return err
}

// webStatusURL returns the URL of the served web build, including the
// model's current path, or "" when WithWebServer is not active.
func (p *Program) webStatusURL() string {
	if p.adapter == nil || p.adapter.serveURL == "" {
		return ""
	}
	return p.adapter.serveURL + p.pathSuffix()
}

// teaAdapter bridges a wui.Model into a tea.Model.
type teaAdapter struct {
	model    Model
	renderer *tuiRenderer
	focus    *tuiFocusManager
	zones    *zone.Manager
	serveURL string // non-empty when WithWebServer is active
	program  *Program
}

func (a *teaAdapter) Init() tea.Cmd {
	cmds := []tea.Cmd{wuiCmdToTea(a.model.Init())}
	if a.program != nil && a.program.cfg.title != "" {
		cmds = append(cmds, tea.SetWindowTitle(a.program.cfg.title))
	}
	return tea.Batch(cmds...)
}

func (a *teaAdapter) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch m := msg.(type) {
	case tea.WindowSizeMsg:
		a.renderer.Width = m.Width
		a.renderer.Height = m.Height
		return a, a.apply(ResizeMsg{Width: m.Width, Height: m.Height})

	case tea.KeyMsg:
		return a.handleKey(m)

	case tea.MouseMsg:
		return a.handleMouse(m)

	case QuitMsg:
		return a, tea.Quit

	case BatchMsg:
		// Deliver each batched Msg through Update in order, collecting
		// the Cmds they return.
		var cmds []tea.Cmd
		for _, sub := range unpackBatch(m) {
			if _, isQuit := sub.(QuitMsg); isQuit {
				return a, tea.Quit
			}
			cmds = append(cmds, a.apply(sub))
		}
		return a, tea.Batch(cmds...)

	default:
		// Anything else (including app-defined Msg values returned
		// from a Cmd and sent back via tea) goes straight to the
		// user's Update.
		return a, a.apply(m)
	}
}

// apply runs one Msg through the user's Update, stores the new model,
// and converts the returned Cmd. It is the single funnel every message
// path goes through, so model replacement never gets skipped.
func (a *teaAdapter) apply(msg Msg) tea.Cmd {
	newModel, cmd := a.model.Update(msg)
	a.model = newModel
	a.syncProgramModel()
	return wuiCmdToTea(cmd)
}

// syncProgramModel keeps Program.model pointing at the live model, so
// StatusFunc and Pather see current state.
func (a *teaAdapter) syncProgramModel() {
	if a.program != nil {
		a.program.model = a.model
	}
}

func (a *teaAdapter) handleKey(m tea.KeyMsg) (tea.Model, tea.Cmd) {
	key := m.String()

	if key == "ctrl+c" {
		return a, tea.Quit
	}

	focusables := collectFocusables(a.model.View(), a.renderer.Width)

	if key == "tab" {
		a.focus.SetIDs(focusableIDs(focusables))
		a.focus.Next()
		a.renderer.FocusedID = a.focus.FocusedID()
		return a, nil
	}
	if key == "shift+tab" {
		a.focus.SetIDs(focusableIDs(focusables))
		a.focus.Prev()
		a.renderer.FocusedID = a.focus.FocusedID()
		return a, nil
	}

	focusedID := a.focus.FocusedID()

	// Esc always escapes the focused element: blur it, then let the app
	// see the key too. Without this an input (which consumes every
	// printable key as text) would trap the keyboard with no way back to
	// app-level shortcuts.
	if key == "esc" && focusedID != "" {
		a.focus.Blur()
		a.renderer.FocusedID = ""
		return a, a.apply(KeyMsg{Key: key, Rune: firstRune(key)})
	}

	if focusedID != "" {
		if newModel, cmd, handled := a.routeKeyToFocused(focusedID, focusables, m); handled {
			a.model = newModel
			a.syncProgramModel()
			return a, cmd
		}
	}

	return a, a.apply(KeyMsg{Key: key, Rune: firstRune(key)})
}

// handleMouse activates the clickable element (button, link, input)
// under the mouse cursor on left-button release. Clicking any
// focusable also moves keyboard focus to it, so a click followed by
// typing behaves like the browser. Zones are recorded during View by
// the bubblezone Scan pass, so hit-testing uses the previous frame's
// layout — correct, since that is the frame the user clicked on.
func (a *teaAdapter) handleMouse(m tea.MouseMsg) (tea.Model, tea.Cmd) {
	if m.Action != tea.MouseActionRelease || m.Button != tea.MouseButtonLeft {
		return a, nil
	}

	focusables := collectFocusables(a.model.View(), a.renderer.Width)
	for _, f := range focusables {
		z := a.zones.Get(f.ID)
		if z == nil || z.IsZero() || !z.InBounds(m) {
			continue
		}

		a.focus.SetIDs(focusableIDs(focusables))
		a.focus.Focus(f.ID)
		a.renderer.FocusedID = f.ID

		if f.IsInput {
			return a, nil
		}
		if f.Activate != nil {
			return a, a.apply(f.Activate())
		}
		if msg := a.submitForm(f.Form); msg != nil {
			return a, a.apply(msg)
		}
		return a, nil
	}
	return a, nil
}

// routeKeyToFocused dispatches a key event to whichever element holds
// focus: text inputs get the key forwarded to their bubbles model;
// buttons and links activate on Enter via their Activate closure;
// elements inside a Form fall back to submitting the form on Enter,
// matching native browser behaviour in the HTML renderer.
func (a *teaAdapter) routeKeyToFocused(focusedID string, focusables []focusable, m tea.KeyMsg) (Model, tea.Cmd, bool) {
	var target *focusable
	for i := range focusables {
		if focusables[i].ID == focusedID {
			target = &focusables[i]
			break
		}
	}
	if target == nil {
		return a.model, nil, false
	}

	if target.Cycle != nil {
		// A Select: left/right (and up/down) step through the options,
		// Enter and Space advance — the terminal analogue of opening a
		// dropdown and picking the next entry. Keys a Select has no use
		// for fall through to the app's Update.
		delta := 0
		switch m.String() {
		case "left", "up":
			delta = -1
		case "right", "down", "enter", " ", "space":
			delta = 1
		}
		if delta == 0 {
			return a.model, nil, false
		}
		newModel, cmd := a.model.Update(target.Cycle(delta))
		return newModel, wuiCmdToTea(cmd), true
	}

	if !target.IsInput {
		// Enter or Space activates, matching native browser buttons
		// and checkboxes. Every other key falls through to the app's
		// Update — a focused button must not trap the keyboard.
		if key := m.String(); key == "enter" || key == " " || key == "space" {
			if target.Activate != nil {
				newModel, cmd := a.model.Update(target.Activate())
				return newModel, wuiCmdToTea(cmd), true
			}
			if msg := a.submitForm(target.Form); msg != nil {
				newModel, cmd := a.model.Update(msg)
				return newModel, wuiCmdToTea(cmd), true
			}
			return a.model, nil, true
		}
		return a.model, nil, false
	}

	if area := findAreaByID(a.model.View(), focusedID); area != nil {
		return a.routeKeyToArea(*area, m)
	}

	el := findInputByID(a.model.View(), focusedID)
	if el == nil {
		return a.model, nil, false
	}

	in := a.renderer.ensureInput(*el)
	prevValue := in.Value()
	updated, _ := in.Update(m)
	a.renderer.setInput(focusedID, updated)

	if m.String() == "enter" {
		if el.OnSubmit != nil {
			newModel, cmd := a.model.Update(el.OnSubmit(updated.Value()))
			return newModel, wuiCmdToTea(cmd), true
		}
		if msg := a.submitForm(target.Form); msg != nil {
			newModel, cmd := a.model.Update(msg)
			return newModel, wuiCmdToTea(cmd), true
		}
		return a.model, nil, true
	}

	if updated.Value() != prevValue {
		if el.OnChange != nil {
			newModel, cmd := a.model.Update(el.OnChange(updated.Value()))
			return newModel, wuiCmdToTea(cmd), true
		}
		// No callback — emit generic InputMsg so app can still react.
		newModel, cmd := a.model.Update(InputMsg{ID: focusedID, Value: updated.Value()})
		return newModel, wuiCmdToTea(cmd), true
	}

	return a.model, nil, true
}

// routeKeyToArea edits a focused TextArea's buffer. Unlike a single
// line input, Enter inserts a newline rather than submitting — matching
// <textarea> in the browser — so a form containing one is submitted
// from its submit button.
func (a *teaAdapter) routeKeyToArea(el TextAreaEl, m tea.KeyMsg) (Model, tea.Cmd, bool) {
	value := a.renderer.ensureArea(el)
	next := value

	switch m.String() {
	case "enter":
		next = value + "\n"
	case "backspace":
		if r := []rune(value); len(r) > 0 {
			next = string(r[:len(r)-1])
		}
	case "ctrl+u":
		next = ""
	case " ", "space":
		next = value + " "
	case "tab", "shift+tab", "up", "down", "left", "right", "home", "end":
		// Navigation keys are not text; leave the buffer untouched.
		// (Esc never reaches here — handleKey blurs on esc first.)
		return a.model, nil, true
	default:
		if r := []rune(m.String()); len(r) == 1 {
			next = value + string(r)
		} else {
			return a.model, nil, true
		}
	}

	if next == value {
		return a.model, nil, true
	}
	a.renderer.setArea(el.ID, next)

	if el.OnChange != nil {
		newModel, cmd := a.model.Update(el.OnChange(next))
		return newModel, wuiCmdToTea(cmd), true
	}
	// No callback — emit a generic InputMsg so the app can still react.
	newModel, cmd := a.model.Update(InputMsg{ID: el.ID, Value: next})
	return newModel, wuiCmdToTea(cmd), true
}

// submitForm collects the form's current input values and produces the
// form's OnSubmit Msg, or nil when there is no form or no handler.
func (a *teaAdapter) submitForm(form *FormEl) Msg {
	if form == nil || form.OnSubmit == nil {
		return nil
	}
	return form.OnSubmit(a.renderer.formValues(*form))
}

func (a *teaAdapter) View() string {
	a.focus.SetIDs(focusableIDs(collectFocusables(a.model.View(), a.renderer.Width)))
	a.renderer.FocusedID = a.focus.FocusedID()
	// The bar is built before the body so Fill-height layouts know how
	// many rows remain for them.
	bar := a.statusBar()
	a.renderer.Reserved = 0
	if bar != "" {
		a.renderer.Reserved = 1
	}
	view := a.renderer.Render(a.model.View())
	if bar != "" {
		view = a.withStatusBar(view, bar)
	}
	// Scan strips the zero-width zone markers and records each zone's
	// on-screen rectangle for mouse hit-testing. It must run on the
	// final composed frame so coordinates match what the user sees.
	return a.zones.Scan(view)
}

// statusBar renders the one-line status strip, or "" when there is
// nothing to show. Content comes from the app's StatusFunc when set,
// else wui's default (web link plus key map help).
func (a *teaAdapter) statusBar() string {
	if a.program == nil || a.program.cfg.noStatusBar {
		return ""
	}
	a.syncProgramModel()
	s := a.program.buildStatus()
	if s.Hidden || s.Empty() {
		return ""
	}
	line := plainStatusLine(s, a.renderer.Width)
	style := styleToLipgloss(s.Style).Width(a.renderer.Width)
	if s.Style == (Style{}) {
		style = lipgloss.NewStyle().Reverse(true).Width(a.renderer.Width)
	}
	return style.Render(line)
}

// withStatusBar pins the bar to the bottom row of the screen, clipping
// and padding the body so the bar always sits on the last line.
func (a *teaAdapter) withStatusBar(view, bar string) string {
	body := lipgloss.NewStyle().MaxHeight(a.renderer.Height - 1).Render(view)
	if pad := a.renderer.Height - 1 - lipgloss.Height(body); pad > 0 {
		body += strings.Repeat("\n", pad)
	}
	return body + "\n" + bar
}

func wuiCmdToTea(cmd Cmd) tea.Cmd {
	if cmd == nil {
		return nil
	}
	return func() tea.Msg {
		return cmd()
	}
}