x/term: support pluggable history

// This program demonstrates the idea of a pluggable history for a terminal.
// It defines the History interface and a simple Terminal that uses it.
// The real golang.org/x/term package does not expose this API yet,
// so this is a stand‑in that compiles and runs with Go 1.27.1.

package main

import (
	"fmt"
)

// History is the interface that a terminal history must satisfy.
type History interface {
	Add(entry string)   // add a new line
	Len() int           // number of stored lines
	At(index int) string // retrieve a line; 0 is most recent
}

// ringHistory is a fixed‑size ring buffer that implements History.
type ringHistory struct {
	buf  []string
	size int
	pos  int // next write position
}

func newRingHistory(capacity int) *ringHistory {
	return &ringHistory{
		buf:  make([]string, capacity),
		size: capacity,
	}
}

func (h *ringHistory) Add(entry string) {
	h.buf[h.pos] = entry
	h.pos = (h.pos + 1) % h.size
}

func (h *ringHistory) Len() int {
	// For simplicity, we count all slots as used.
	return h.size
}

func (h *ringHistory) At(index int) string {
	if index < 0 || index >= h.size {
		panic("index out of range")
	}
	// Translate from most‑recent to buffer index.
	i := (h.pos - 1 - index + h.size) % h.size
	return h.buf[i]
}

// Terminal holds a History implementation.
type Terminal struct {
	History History
}

// ReadLine simulates reading a line and adding it to history.
func (t *Terminal) ReadLine(line string) string {
	t.History.Add(line)
	return line
}

func main() {
	// Create a terminal with a 5‑slot ring history.
	t := &Terminal{History: newRingHistory(5)}

	// Simulate reading five lines.
	for i := 1; i <= 5; i++ {
		t.ReadLine(fmt.Sprintf("command %d", i))
	}

	// Print the history from most recent to oldest.
	fmt.Println("History:")
	for i := 0; i < t.History.Len(); i++ {
		fmt.Printf("%d: %s\n", i, t.History.At(i))
	}
}