view.go

package render

import (
	"fmt"
	"strings"
	"time"
	"unicode/utf8"

	api "github.com/bootdotdev/bootdev/client"
	"github.com/charmbracelet/bubbles/spinner"
	"github.com/charmbracelet/lipgloss"
)

const safeStepIcon = "🛡︎"

func renderTestHeader(header string, spinner spinner.Model, isFinished bool, isSubmit bool, passed *bool, noPenaltyOnFail bool) string {
	if noPenaltyOnFail {
		header = fmt.Sprintf("%s %s", header, white.Render(safeStepIcon))
	}
	cmdStr := renderTest(header, spinner.View(), isFinished, &isSubmit, passed)
	box := borderBox.Render(fmt.Sprintf(" %s ", cmdStr))
	sliced := strings.Split(box, "\n")
	sliced[2] = strings.Replace(sliced[2], "─", "┬", 1)
	return strings.Join(sliced, "\n") + "\n"
}

func renderTests(tests []testModel, spinner string) string {
	var str strings.Builder
	var edges strings.Builder

	for _, test := range tests {
		testStr := renderTest(test.text, spinner, test.finished, nil, test.passed)
		testStr = fmt.Sprintf("  %s", testStr)
		height := lipgloss.Height(testStr)

		edges.Reset()
		edges.WriteString(" ├─")
		for i := 1; i < height; i++ {
			edges.WriteString("\n │ ")
		}

		str.WriteString(lipgloss.JoinHorizontal(lipgloss.Top, edges.String(), testStr))
		str.WriteByte('\n')
	}

	return str.String()
}

func renderTest(text string, spinner string, isFinished bool, isSubmit *bool, passed *bool) string {
	testStr := ""
	if !isFinished {
		testStr += fmt.Sprintf("%s %s", spinner, text)
	} else if isSubmit != nil && !*isSubmit {
		testStr += text
	} else if passed == nil {
		testStr += gray.Render(fmt.Sprintf("?  %s", text))
	} else if *passed {
		testStr += green.Render(fmt.Sprintf("✓  %s", text))
	} else {
		testStr += red.Render(fmt.Sprintf("X  %s", text))
	}
	return testStr
}

func renderJqOutputs(outputs []api.CLICommandJqOutput) string {
	if len(outputs) == 0 {
		return ""
	}

	var str strings.Builder
	str.WriteString("\n > jq output:\n\n")
	for _, output := range outputs {
		str.WriteString(gray.Render(fmt.Sprintf("Query: %s", output.Query)))
		str.WriteByte('\n')
		if output.Error != "" {
			str.WriteString(gray.Render(fmt.Sprintf("Error: %s", output.Error)))
			str.WriteByte('\n')
			str.WriteByte('\n')
			continue
		}
		if len(output.Results) == 0 {
			str.WriteString(gray.Render("Results: [none]"))
			str.WriteByte('\n')
			str.WriteByte('\n')
			continue
		}
		str.WriteString(gray.Render("Results:"))
		str.WriteByte('\n')
		for _, line := range output.Results {
			str.WriteString(gray.Render("  - " + line))
			str.WriteByte('\n')
		}
		str.WriteByte('\n')
	}
	return str.String()
}

func (m rootModel) View() string {
	if m.clear {
		return ""
	}
	s := m.spinner.View()
	var str strings.Builder
	for _, step := range m.steps {
		str.WriteString(renderTestHeader(step.step, m.spinner, step.finished, m.isSubmit, step.passed, step.noPenaltyOnFail))
		str.WriteString(renderTests(step.tests, s))

		if step.sleepAfter != "" && step.finished {
			sleepBox := borderBox.Render(fmt.Sprintf(" %s ", step.sleepAfter))
			str.WriteString(sleepBox)
			str.WriteByte('\n')
		}

		if step.result == nil || !m.finalized {
			continue
		}

		if step.result.CLICommandResult != nil {
			for _, test := range step.tests {
				if strings.Contains(test.text, "exit code") {
					fmt.Fprintf(&str, "\n > Command exit code: %d\n", step.result.CLICommandResult.ExitCode)
					break
				}
			}
			str.WriteString(" > Command stdout:\n\n")
			sliced := strings.SplitSeq(step.result.CLICommandResult.Stdout, "\n")
			i := 0
			runeCount := 0
			const maxLines, maxRunes = 32, 5120
			for s := range sliced {
				if i >= maxLines || runeCount >= maxRunes {
					str.WriteString(gray.Render("... output visually truncated, full output captured"))
					str.WriteByte('\n')
					break
				}
				runeCount += utf8.RuneCountInString(s)
				str.WriteString(gray.Render(s))
				str.WriteByte('\n')
				i++
			}
			str.WriteString(renderJqOutputs(step.result.CLICommandResult.JqOutputs))
			availableVariables, expectsVariables := availableVariablesForCLIResult(*step.result.CLICommandResult)
			if expectsVariables {
				str.WriteString(renderVariableSection("Variables Available", availableVariables))
			}
		}

		if step.result.HTTPRequestResult != nil {
			str.WriteString(printHTTPRequestResult(*step.result.HTTPRequestResult))
		}
	}

	if m.result == api.VerificationResultSlugSuccess && m.isSubmit {
		str.WriteString("\n\n" + green.Render("All tests passed! 🎉") + "\n")
		if m.xpReward >= 0 {
			str.WriteString("\n")
			str.WriteString(green.Bold(true).Render(fmt.Sprintf("Gained +%d XP", m.xpReward)))
			str.WriteByte('\n')
			for _, item := range m.xpBreakdown {
				if item.XP == 0 {
					continue
				}
				sign := "+"
				xp := item.XP
				if xp < 0 {
					sign = "-"
					xp = -xp
				}
				if item.Percent > 0 {
					str.WriteString(gray.Render(fmt.Sprintf("%s%3d XP (%-4s %s)", sign, xp, fmt.Sprintf("%.0f%%", item.Percent*100), item.Name)))
				} else {
					str.WriteString(gray.Render(fmt.Sprintf("%s%3d XP (%s)", sign, xp, item.Name)))
				}
				str.WriteByte('\n')
			}
		}
		str.WriteString("\n" + green.Render("Return to your browser to continue with the next lesson.") + "\n\n")
	} else if m.result == api.VerificationResultSlugNoop {
		str.WriteString("\n\nTests failed! ❌")
		fmt.Fprintf(&str, "\n\nFailed Step: %v", m.failure.FailedStepIndex+1)
		str.WriteString("\nError: " + m.failure.ErrorMessage + "\n")
		str.WriteString("\n" + white.Render(safeStepIcon) + " This was a safe step.\n")
		str.WriteString("You haven't passed, but you also haven't lost armor or Sharpshooter progress.\n\n")
	} else if m.result == api.VerificationResultSlugFailure {
		str.WriteString("\n\n" + red.Render("Tests failed! ❌"))
		if m.failure != nil {
			if m.failure.FailedStepIndex >= 0 && m.failure.FailedStepIndex < len(m.steps) {
				fmt.Fprintf(&str, "%s", red.Render(fmt.Sprintf("\n\nFailed Command: %s", m.steps[m.failure.FailedStepIndex].step)))
			}
			fmt.Fprintf(&str, "%s", red.Render(fmt.Sprintf("\n\nFailed Step: %v", m.failure.FailedStepIndex+1)))
			fmt.Fprintf(&str, "%s", red.Render("\nError: "+m.failure.ErrorMessage))
		} else {
			fmt.Fprintf(&str, "%s", red.Render("\n\nFailed Step: unknown"))
			fmt.Fprintf(&str, "%s", red.Render("\nError: unknown"))
		}
		str.WriteString("\n\n")
		currentDate := time.Now().Format("2006-01-02")
		if strings.HasSuffix(currentDate, "04-01") {
			str.WriteString(magenta.Render(fmt.Sprintf("This incident has been reported to your system administrator. [%s]\n", currentDate)))
		}
	}

	return str.String()
}