tui/widget/pipelineCreate.go

package widget

import (
	"context"
	"fmt"
	"io"
	"strconv"

	"git.ohea.xyz/cursorius/tui/queries"
	"github.com/Khan/genqlient/graphql"
	"github.com/charmbracelet/bubbles/list"
	"github.com/charmbracelet/bubbles/textinput"
	tea "github.com/charmbracelet/bubbletea"
)

type pipelineCreateForm struct {
	formList list.Model
	client   graphql.Client
}

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 "esc":
			return m, func() tea.Msg {
				view, err := createPipelineWidgetList(m.client)
				if err != nil {
					return err
				}
				return pipelineWidgetScreenSwitch(view)
			}
		case "enter":
			if m.formList.Index() == len(m.formList.Items())-1 {
				return m, func() tea.Msg {
					name := ""
					url := ""
					pollIntervalStr := ""
					if e, ok := m.formList.Items()[0].(createPipelineItem); ok {
						name = e.field.Value()
					}
					if e, ok := m.formList.Items()[1].(createPipelineItem); ok {
						url = e.field.Value()
					}
					if e, ok := m.formList.Items()[2].(createPipelineItem); ok {
						pollIntervalStr = e.field.Value()
					}
					pollInterval, err := strconv.Atoi(pollIntervalStr)
					if err != nil {
						pollInterval = 0
					}

					_, err = queries.CreatePipeline(context.Background(), m.client, name, url, &pollInterval, nil)
					if err != nil {
						return err
					}

					view, err := createPipelineWidgetList(m.client)
					if err != nil {
						return err
					}

					return pipelineWidgetScreenSwitch(view)
				}
			}
		}
	}

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

	items := m.formList.Items()

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

	return m, cmd
}

func Atoi(pollIntervalStr string) {
	panic("unimplemented")
}

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

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{
		formList: l,
		client:   client,
	}, nil
}