tk

type Bindings interface {
	Handle(Widget, term.Event) bool
}

type CodeArea interface {
	Widget
	// CopyState returns a copy of the state.
	CopyState() CodeAreaState
	// MutateState calls the given the function while locking StateMutex.
	MutateState(f func(*CodeAreaState))
	// Submit triggers the OnSubmit callback.
	Submit()
}

type CodeAreaSpec struct {
	// Key bindings.
	Bindings Bindings
	// A function that highlights the given code and returns any tips it has
	// found, such as errors and autofixes. If this function is not given, the
	// Widget does not highlight the code nor show any tips.
	Highlighter func(code string) (ui.Text, []ui.Text)
	// Prompt callback.
	Prompt func() ui.Text
	// Right-prompt callback.
	RPrompt func() ui.Text
	// A function that calls the callback with string pairs for abbreviations
	// and their expansions. If no function is provided the Widget does not
	// expand any abbreviations of the specified type.
	SimpleAbbreviations    func(f func(abbr, full string))
	CommandAbbreviations   func(f func(abbr, full string))
	SmallWordAbbreviations func(f func(abbr, full string))
	// A function that returns whether pasted texts (from bracketed pastes)
	// should be quoted. If this function is not given, the Widget defaults to
	// not quoting pasted texts.
	QuotePaste func() bool
	// A function that is called on the submit event.
	OnSubmit func()

	// State. When used in New, this field specifies the initial state.
	State CodeAreaState
}

type CodeAreaState struct {
	Buffer      CodeBuffer
	Pending     PendingCode
	HideRPrompt bool
	HideTips    bool
}

type CodeBuffer struct {
	// Content of the buffer.
	Content string
	// Position of the dot (more commonly known as the cursor), as a byte index
	// into Content.
	Dot int
}

type ColView interface {
	Widget
	// MutateState mutates the state.
	MutateState(f func(*ColViewState))
	// CopyState returns a copy of the state.
	CopyState() ColViewState
	// Left triggers the OnLeft callback.
	Left()
	// Right triggers the OnRight callback.
	Right()
}

type ColViewSpec struct {
	// Key bindings.
	Bindings Bindings
	// A function that takes the number of columns and return weights for the
	// widths of the columns. The returned slice must have a size of n. If this
	// function is nil, all the columns will have the same weight.
	Weights func(n int) []int
	// A function called when the Left method of Widget is called, or when Left
	// is pressed and unhandled.
	OnLeft func(w ColView)
	// A function called when the Right method of Widget is called, or when
	// Right is pressed and unhandled.
	OnRight func(w ColView)

	// State. Specifies the initial state when used in New.
	State ColViewState
}

type ColViewState struct {
	Columns     []Widget
	FocusColumn int
}

type ComboBox interface {
	Widget
	// Returns the embedded codearea widget.
	CodeArea() CodeArea
	// Returns the embedded listbox widget.
	ListBox() ListBox
	// Forces the filtering to rerun.
	Refilter()
}

type ComboBoxSpec struct {
	CodeArea CodeAreaSpec
	ListBox  ListBoxSpec
	OnFilter func(ComboBox, string)
}

type DummyBindings struct{}

type Empty struct{}

type FuncBindings func(Widget, term.Event) bool

type HScrollbar struct {
	Total int
	Low   int
	High  int
}

type Handler interface {
	// Try to handle a terminal event and returns whether the event has been
	// handled.
	Handle(event term.Event) bool
}

type Items interface {
	// Show renders the item at the given zero-based index.
	Show(i int) ui.Text
	// Len returns the number of items.
	Len() int
}

type Label struct {
	Content ui.Text
}

type ListBox interface {
	Widget
	// CopyState returns a copy of the state.
	CopyState() ListBoxState
	// Reset resets the state of the widget with the given items and index of
	// the selected item. It triggers the OnSelect callback if the index is
	// valid.
	Reset(it Items, selected int)
	// Select changes the selection by calling f with the current state, and
	// using the return value as the new selection index. It triggers the
	// OnSelect callback if the selected index has changed and is valid.
	Select(f func(ListBoxState) int)
	// Accept accepts the currently selected item.
	Accept()
}

type ListBoxSpec struct {
	// Key bindings.
	Bindings Bindings
	// A placeholder to show when there are no items.
	Placeholder ui.Text
	// A function to call when the selected item has changed.
	OnSelect func(it Items, i int)
	// A function called on the accept event.
	OnAccept func(it Items, i int)
	// Whether the listbox should be rendered in a horizontal layout. Note that
	// in the horizontal layout, items must have only one line.
	Horizontal bool
	// The minimal amount of space to reserve for left and right sides of each
	// entry.
	Padding int
	// If true, the left padding of each item will be styled the same as the
	// first segment of the item, and the right spacing and padding will be
	// styled the same as the last segment of the item.
	ExtendStyle bool

	// State. When used in [NewListBox], this field specifies the initial state.
	State ListBoxState
}

type ListBoxState struct {
	Items    Items
	Selected int
	// The first element to show. Used when rendering and adjusted accordingly
	// when the terminal size changes or the user has scrolled.
	First int
	// Height of the listbox, excluding horizontal scrollbar when using the
	// horizontal layout. Stored in the state for commands to move the cursor by
	// page (for vertical layout) or column (for horizontal layout).
	ContentHeight int
}

type MapBindings map[term.Event]func(Widget)

type MaxHeighter interface {
	// MaxHeight returns the maximum height needed when rendering onto a region
	// of bound width and height. The returned value may be larger than the
	// height argument.
	MaxHeight(width, height int) int
}

type PendingCode struct {
	// Beginning index of the text area that the pending code replaces, as a
	// byte index into RawState.Code.
	From int
	// End index of the text area that the pending code replaces, as a byte
	// index into RawState.Code.
	To int
	// The content of the pending code.
	Content string
}

type Renderer interface {
	// Render renders onto a region of bound width and height.
	Render(width, height int) *term.Buffer
}

type TestItems struct {
	Prefix string
	Style  ui.Styling
	NItems int
}

type TextView interface {
	Widget
	// ScrollBy scrolls the widget by the given delta. Positive values scroll
	// down, and negative values scroll up.
	ScrollBy(delta int)
	// MutateState mutates the state.
	MutateState(f func(*TextViewState))
	// CopyState returns a copy of the State.
	CopyState() TextViewState
}

type TextViewSpec struct {
	// Key bindings.
	Bindings Bindings
	// If true, a vertical scrollbar will be shown when there are more lines
	// that can be displayed, and the widget responds to Up and Down keys.
	Scrollable bool
	// State. Specifies the initial state if used in New.
	State TextViewState
}

type TextViewState struct {
	Lines []string
	First int
}

type VScrollbar struct {
	Total int
	Low   int
	High  int
}

type VScrollbarContainer struct {
	Content   Renderer
	Scrollbar VScrollbar
}

type Widget interface {
	Renderer
	MaxHeighter
	Handler
}