tui/widget/pipelineCreate.go

package widget

import (
	"fmt"
	"io"

	"github.com/Khan/genqlient/graphql"
	"github.com/charmbracelet/bubbles/list"
	"github.com/charmbracelet/bubbles/textinput"
	tea "github.com/charmbracelet/bubbletea"
)

type pipelineCreateForm struct {
	list list.Model
}

func (m pipelineCreateForm) Init() tea.Cmd {
	return nil
}

func (m pipelineCreateForm) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	switch msg := msg.(type) {
	case tea.KeyMsg:
		switch msg.String() {
		case "enter":
			// TODO: enable submitting
		}
	}

	var cmd tea.Cmd
	m.list, cmd = m.list.Update(msg)

	items := m.list.Items()

	for i := 0; i < len(items); i++ {
		if e, ok := items[i].(createPipelineItem); ok {
			if i == m.list.Index() {
				e.field.Focus()
				e.field, _ = e.field.Update(msg)
			} else {
				e.field.Blur()
			}
			m.list.SetItem(i, e)
		}
	}

	return m, cmd
}

func (m pipelineCreateForm) View() string {
	return m.list.View()
}

type pipelineCreateListItem string

func (i pipelineListItem) FilterValue() string       { return "" }
func (i pipelineCreateListItem) FilterValue() string { return "" }

type pipelineListItemDelegate struct{}

func (d pipelineListItemDelegate) Height() int                               { return 1 }
func (d pipelineListItemDelegate) Spacing() int                              { return 0 }
func (d pipelineListItemDelegate) Update(msg tea.Msg, m *list.Model) tea.Cmd { return nil }
func (d pipelineListItemDelegate) Render(w io.Writer, m list.Model, index int, listItem list.Item) {
	switch i := listItem.(type) {
	case pipelineListItem:
		fn := itemStyle.Render
		faintFn := faintItemStyle.Render
		if index == m.Index() {
			fn = func(s string) string {
				return selectedItemStyle.Render("> " + s)
			}
			faintFn = faintSelectedItemStyle.Render
		}

		str := fn(i.name) + faintFn(" ("+i.id+")")
		fmt.Fprint(w, str)
	case pipelineCreateListItem:
		fn := itemStyle.Render
		if index == m.Index() {
			fn = func(s string) string {
				return selectedItemStyle.Render("> " + s)
			}
		}

		str := string(i)
		fmt.Fprint(w, fn(str))
	}
}

type createPipelineItem struct {
	field textinput.Model
}

type createPipelineSubmitItem string

func (i createPipelineItem) FilterValue() string       { return "" }
func (i createPipelineSubmitItem) FilterValue() string { return "" }

type createPipelineDelegate struct{}

func (d createPipelineDelegate) Height() int                               { return 1 }
func (d createPipelineDelegate) Spacing() int                              { return 0 }
func (d createPipelineDelegate) Update(msg tea.Msg, m *list.Model) tea.Cmd { return nil }
func (d createPipelineDelegate) Render(w io.Writer, m list.Model, index int, listItem list.Item) {
	var str string
	switch i := listItem.(type) {
	case createPipelineItem:
		str = i.field.View()
	case createPipelineSubmitItem:
		str = string(i)
	}

	fn := itemStyle.Render
	if index == m.Index() {
		fn = func(s string) string {
			return selectedItemStyle.Render("> " + s)
		}
	}

	fmt.Fprint(w, fn(str))
}

func createPipelineCreateForm(client graphql.Client, width int, height int) (tea.Model, error) {
	nameField := textinput.New()
	nameField.Focus()
	nameField.Width = 20
	nameField.Prompt = "Name: "
	nameField.Placeholder = "pipeline0"
	urlField := textinput.New()
	urlField.Prompt = "Url: "
	urlField.Placeholder = "https://git.cursorius.ohea/group/repo"
	pollIntervalField := textinput.New()
	pollIntervalField.Width = 20
	pollIntervalField.Prompt = "Poll Interval: "
	pollIntervalField.Placeholder = "0 (disable polling)"
	items := []list.Item{
		createPipelineItem{field: nameField},
		createPipelineItem{field: urlField},
		createPipelineItem{field: pollIntervalField},
		createPipelineSubmitItem("> Submit <"),
	}
	l := list.New(items, createPipelineDelegate{}, width, height-10)
	l.Title = "Create a new pipeline."
	l.SetShowStatusBar(false)
	l.KeyMap.GoToStart.SetEnabled(false)
	l.KeyMap.GoToEnd.SetEnabled(false)
	l.KeyMap.Filter.SetEnabled(false)
	l.KeyMap.Quit.SetEnabled(false)
	return pipelineCreateForm{
		list: l,
	}, nil
}