cli

func (confirmModel) Update(msg tea.Msg) (tea.Model, tea.Cmd)
{
	switch msg := msg.(type) {
	case tea.KeyMsg:
		switch msg.String() {
		case "ctrl+c":
			m.err = fmt.Errorf("interrupted")
			return m, tea.Quit
		case "y", "Y":
			m.choice = true
		case "n", "N":
			m.choice = false
		case "left", "right", "h", "l", "tab":
			m.choice = !m.choice
		case "enter":
			m.submitted = true
			return m, tea.Quit
		}
	}
	return m, nil
}

func (confirmModel) View() string
{
	var s strings.Builder
	s.WriteString("\n" + lipgloss.NewStyle().Bold(true).Render(m.prompt) + "\n\n")

	yStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("241")).MarginRight(2)
	nStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("241")).MarginRight(2)

	if m.choice {
		yStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("205")).Bold(true).MarginRight(2)
	} else {
		nStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("205")).Bold(true).MarginRight(2)
	}

	s.WriteString(yStyle.Render(m.yesText))
	s.WriteString(nStyle.Render(m.noText))
	s.WriteString("\n")

	return s.String()
}

func (Command) StartProgressBar(message string, total int) *ProgressBarModel
{
	p := progress.New(
		progress.WithGradient("#277eff", "#e0388d"),
		progress.WithoutPercentage(),
	)
	m := progressComponent{
		progress: p,
		total:    total,
		message:  message,
	}

	prog := tea.NewProgram(m)

	go func() {
		if _, err := prog.Run(); err != nil {
			fmt.Println("Error running progress bar:", err)
		}
	}()

	return &ProgressBarModel{
		program: prog,
		total:   total,
		current: 0,
	}
}

func (Command) StartSpinner(message string) *SpinnerModel
{
	p := tea.NewProgram(initialSpinnerComponent(message))
	quit := make(chan struct{})

	go func() {
		if _, err := p.Run(); err != nil {
			fmt.Println("Error running spinner:", err)
		}
		close(quit)
	}()

	return &SpinnerModel{
		program: p,
	}
}

func (*Command) ConfirmAction(prompt, yesText, noText string, defaultChoice bool) (bool, error)
{
	// If custom text provided, use it, assuming 'y' maps to yesText and 'n' to noText visual
	p := tea.NewProgram(initialConfirmModel(prompt, yesText, noText, defaultChoice))
	m, err := p.Run()
	if err != nil {
		return false, err
	}

	if m, ok := m.(confirmModel); ok {
		if m.err != nil {
			return false, m.err
		}
		if !m.submitted {
			return defaultChoice, nil
		}
		return m.choice, nil
	}

	return false, fmt.Errorf("could not retrieve confirmation")
}

func (*Command) SelectOption(prompt string, options []string) (string, error)
{
	if strings.Contains(prompt, "%d") {
		prompt = fmt.Sprintf(prompt, len(options))
	}
	p := tea.NewProgram(initialListModel(prompt, options))
	m, err := p.Run()
	if err != nil {
		return "", err
	}

	if m, ok := m.(listModel); ok {
		if m.err != nil {
			return "", m.err
		}
		return m.selected, nil
	}

	return "", fmt.Errorf("could not retrieve selection")
}

func (*Command) Table(headers []string, data [][]string) error
{
	headerStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("205")).Bold(true).Padding(0, 1)
	styledHeaders := make([]string, len(headers))
	for i, h := range headers {
		styledHeaders[i] = headerStyle.Render(h)
	}

	t := table.New().
		Border(lipgloss.NormalBorder()).
		BorderStyle(lipgloss.NewStyle().Foreground(lipgloss.Color("238"))).
		Headers(styledHeaders...).
		Rows(data...).
		StyleFunc(func(row, col int) lipgloss.Style {
			switch {
			default:
				if row%2 == 0 {
					return lipgloss.NewStyle().
						Foreground(lipgloss.Color("252")).
						Padding(0, 1)
				}
				return lipgloss.NewStyle().
					Foreground(lipgloss.Color("246")).
					Padding(0, 1)
			}
		})

	fmt.Println(t)
	return nil
}

func (*Command) PromptText(prompt, placeholder string) (string, error)
{
	p := tea.NewProgram(initialTextInputModel(prompt, placeholder))
	m, err := p.Run()
	if err != nil {
		return "", err
	}

	if m, ok := m.(textInputModel); ok {
		if m.err != nil {
			return "", m.err
		}
		if m.textInput.Value() == "" {
			return placeholder, nil
		}
		return m.textInput.Value(), nil
	}

	return "", fmt.Errorf("could not retrieve manual input")
}

func (progressComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd)
{
	switch msg := msg.(type) {
	case tea.KeyMsg:
		if msg.Type == tea.KeyCtrlC {
			return m, tea.Quit
		}
	case progressMsg:
		var cmd tea.Cmd
		if m.current < m.total {
			pct := float64(m.current) / float64(m.total)
			cmd = m.progress.SetPercent(pct)
			return m, cmd
		}
	case titleMsg:
		m.message = string(msg)
	case stopMsg:
		return m, tea.Quit
	case progress.FrameMsg:
		progressModel, cmd := m.progress.Update(msg)
		m.progress = progressModel.(progress.Model)
		return m, cmd
	}
	return m, nil
}

func (*ProgressBarModel) Increment(inc int)
{
	m.current += inc
	if m.current >= m.total {
		m.current = m.total
		m.Stop()
		return
	}

	// Bubbles progress takes a 0-1 float.
	pct := float64(m.current) / float64(m.total)
	m.program.Send(progressMsg(pct))
}

func (itemDelegate) Render(w io.Writer, m list.Model, index int, listItem list.Item)
{
	i, ok := listItem.(item)
	if !ok {
		return
	}

	str := fmt.Sprintf("%d. %s", index+1, i)

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

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

func (listModel) Update(msg tea.Msg) (tea.Model, tea.Cmd)
{
	switch msg := msg.(type) {
	case tea.KeyMsg:
		key := msg.String()
		switch key {
		case "ctrl+c":
			m.err = fmt.Errorf("interrupted")
			return m, tea.Quit
		case "enter":
			if i, ok := m.list.SelectedItem().(item); ok {
				m.selected = string(i)
			}
			return m, tea.Quit
		case "1", "2", "3", "4", "5", "6", "7", "8", "9":
			idx := int(key[0] - '1')
			items := m.list.Items()
			if idx >= 0 && idx < len(items) {
				if i, ok := items[idx].(item); ok {
					m.selected = string(i)
					return m, tea.Quit
				}
			}
		}
	case tea.WindowSizeMsg:
		m.list.SetWidth(msg.Width)
		return m, nil
	}

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

func (spinnerComponent) Update(msg tea.Msg) (tea.Model, tea.Cmd)
{
	switch msg := msg.(type) {
	case quitMsg:
		m.quitting = true
		return m, tea.Quit
	case updateMsg:
		m.message = string(msg)
		return m, nil
	}

	var cmd tea.Cmd
	m.spinner, cmd = m.spinner.Update(msg)
	return m, cmd
}

func (textInputModel) Update(msg tea.Msg) (tea.Model, tea.Cmd)
{
	var cmd tea.Cmd

	switch msg := msg.(type) {
	case tea.KeyMsg:
		switch msg.Type {
		case tea.KeyCtrlC, tea.KeyEsc:
			m.err = fmt.Errorf("interrupted")
			return m, tea.Quit
		case tea.KeyEnter:
			return m, tea.Quit
		}

	case tea.WindowSizeMsg:
		m.textInput.Width = msg.Width
	}

	m.textInput, cmd = m.textInput.Update(msg)
	return m, cmd
}