tui: add dashboard overview tab renderer

3 files changed, 221 insertions, 1 deletions

diff --git a/internal/tui/dashboard/model.go b/internal/tui/dashboard/model.go
index 3c4d9b8..1178dc9 100644
--- a/internal/tui/dashboard/model.go
+++ b/internal/tui/dashboard/model.go
@@ -134,7 +134,7 @@ func renderActiveTab(tab Tab, snap *statsengine.Snapshot, width, height int) str
 
 	switch tab {
 	case TabOverview:
-		return tui.PanelStyle.Render(fmt.Sprintf("Overview: %d syscalls", snap.TotalSyscalls))
+		return renderOverview(snap, width, height)
 	case TabSyscalls:
 		return tui.PanelStyle.Render(fmt.Sprintf("Syscalls: %d rows", len(snap.Syscalls())))
 	case TabFiles:
diff --git a/internal/tui/dashboard/overview.go b/internal/tui/dashboard/overview.go
new file mode 100644
index 0000000..3f563d4
--- /dev/null
+++ b/internal/tui/dashboard/overview.go
@@ -0,0 +1,152 @@
+package dashboard
+
+import (
+	"fmt"
+	"ior/internal/statsengine"
+	"ior/internal/tui"
+	"strings"
+	"time"
+)
+
+func renderOverview(snap *statsengine.Snapshot, width, height int) string {
+	_ = height
+	if snap == nil {
+		return tui.PanelStyle.Render("Overview: waiting for stats...")
+	}
+
+	boxWidth := summaryBoxWidth(width)
+	box1 := renderSyscallBox(snap, boxWidth)
+	box2 := renderBytesBox(snap, boxWidth)
+	box3 := renderErrorBox(snap, boxWidth)
+
+	row := strings.Join([]string{box1, box2, box3}, "\n")
+	trends := fmt.Sprintf(
+		"Trends: latency %s  gap %s  throughput %s",
+		trendWithArrow(snap.LatencyTrend),
+		trendWithArrow(snap.GapTrend),
+		trendWithArrow(snap.ThroughputTrend),
+	)
+
+	latencySpark := "Latency: " + renderSparkline(snap.LatencySeriesNs(), sparklineWidth(width))
+	throughputSpark := "Throughput: " + renderSparkline(snap.ThroughputSeriesB(), sparklineWidth(width))
+	topSyscalls := "Top syscalls: " + summarizeTopSyscalls(snap)
+
+	return strings.Join(
+		[]string{
+			row,
+			tui.HighlightStyle.Render(trends),
+			tui.PanelStyle.Render(latencySpark),
+			tui.PanelStyle.Render(throughputSpark),
+			tui.PanelStyle.Render(topSyscalls),
+		},
+		"\n",
+	)
+}
+
+func renderSyscallBox(snap *statsengine.Snapshot, width int) string {
+	content := fmt.Sprintf(
+		"Elapsed: %s\nSyscalls: %d\nRate: %.1f/s",
+		formatElapsed(snap.Elapsed),
+		snap.TotalSyscalls,
+		snap.SyscallRatePerSec,
+	)
+	return tui.PanelStyle.Width(width).Render(content)
+}
+
+func renderBytesBox(snap *statsengine.Snapshot, width int) string {
+	content := fmt.Sprintf(
+		"Read/s: %s\nWrite/s: %s\nTotal: %s",
+		formatBytes(snap.ReadBytesPerSec),
+		formatBytes(snap.WriteBytesPerSec),
+		formatBytes(float64(snap.TotalBytes)),
+	)
+	return tui.PanelStyle.Width(width).Render(content)
+}
+
+func renderErrorBox(snap *statsengine.Snapshot, width int) string {
+	errPercent := 0.0
+	if snap.TotalSyscalls > 0 {
+		errPercent = float64(snap.TotalErrors) / float64(snap.TotalSyscalls) * 100
+	}
+	content := fmt.Sprintf(
+		"Errors: %d\nError rate: %.2f%%\nLatency mean: %.0fns",
+		snap.TotalErrors,
+		errPercent,
+		snap.LatencyMeanNs,
+	)
+	return tui.PanelStyle.Width(width).Render(content)
+}
+
+func trendWithArrow(trend statsengine.Trend) string {
+	switch trend.Direction {
+	case statsengine.TrendRising:
+		return fmt.Sprintf("↑ %.1f%%", trend.DeltaPercent)
+	case statsengine.TrendFalling:
+		return fmt.Sprintf("↓ %.1f%%", trend.DeltaPercent)
+	default:
+		return fmt.Sprintf("→ %.1f%%", trend.DeltaPercent)
+	}
+}
+
+func summarizeTopSyscalls(snap *statsengine.Snapshot) string {
+	syscalls := snap.Syscalls()
+	if len(syscalls) == 0 {
+		return "none"
+	}
+
+	limit := 3
+	if len(syscalls) < limit {
+		limit = len(syscalls)
+	}
+
+	parts := make([]string, 0, limit)
+	for _, syscall := range syscalls[:limit] {
+		parts = append(parts, fmt.Sprintf("%s(%d)", syscall.Name, syscall.Count))
+	}
+	return strings.Join(parts, ", ")
+}
+
+func formatElapsed(elapsed time.Duration) string {
+	if elapsed <= 0 {
+		return "0s"
+	}
+	return elapsed.Round(time.Second).String()
+}
+
+func formatBytes(value float64) string {
+	units := []string{"B", "KB", "MB", "GB", "TB"}
+	unit := 0
+	for value >= 1024 && unit < len(units)-1 {
+		value /= 1024
+		unit++
+	}
+	if unit == 0 {
+		return fmt.Sprintf("%.0f%s", value, units[unit])
+	}
+	return fmt.Sprintf("%.1f%s", value, units[unit])
+}
+
+func summaryBoxWidth(width int) int {
+	if width <= 0 {
+		return 24
+	}
+	w := (width - 4) / 3
+	if w < 18 {
+		return 18
+	}
+	return w
+}
+
+func sparklineWidth(width int) int {
+	if width <= 0 {
+		return 20
+	}
+	w := width - 14
+	if w < 8 {
+		return 8
+	}
+	if w > 80 {
+		return 80
+	}
+	return w
+}
diff --git a/internal/tui/dashboard/overview_test.go b/internal/tui/dashboard/overview_test.go
new file mode 100644
index 0000000..ca1544c
--- /dev/null
+++ b/internal/tui/dashboard/overview_test.go
@@ -0,0 +1,68 @@
+package dashboard
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"ior/internal/statsengine"
+)
+
+func TestRenderOverviewIncludesCoreMetrics(t *testing.T) {
+	snap := &statsengine.Snapshot{
+		Elapsed:           95 * time.Second,
+		TotalSyscalls:     1200,
+		SyscallRatePerSec: 12.5,
+		TotalBytes:        10 * 1024 * 1024,
+		ReadBytesPerSec:   4096,
+		WriteBytesPerSec:  8192,
+		TotalErrors:       12,
+		LatencyMeanNs:     5000,
+		LatencyTrend:      statsengine.Trend{Direction: statsengine.TrendRising, DeltaPercent: 12.5},
+		GapTrend:          statsengine.Trend{Direction: statsengine.TrendFalling, DeltaPercent: -7.4},
+		ThroughputTrend:   statsengine.Trend{Direction: statsengine.TrendStable, DeltaPercent: 0},
+	}
+
+	out := renderOverview(snap, 120, 40)
+	for _, token := range []string{
+		"Elapsed:",
+		"Syscalls:",
+		"Read/s:",
+		"Errors:",
+		"Trends:",
+		"Latency:",
+		"Throughput:",
+		"Top syscalls:",
+	} {
+		if !strings.Contains(out, token) {
+			t.Fatalf("expected token %q in overview output", token)
+		}
+	}
+}
+
+func TestSummarizeTopSyscalls(t *testing.T) {
+	snap := statsengine.NewSnapshot(
+		nil, nil, nil,
+		[]statsengine.SyscallSnapshot{
+			{Name: "read", Count: 50},
+			{Name: "write", Count: 20},
+			{Name: "openat", Count: 10},
+			{Name: "close", Count: 5},
+		},
+		nil, nil,
+		statsengine.HistogramSnapshot{},
+		statsengine.HistogramSnapshot{},
+	)
+
+	got := summarizeTopSyscalls(&snap)
+	if got != "read(50), write(20), openat(10)" {
+		t.Fatalf("unexpected top syscall summary: %q", got)
+	}
+}
+
+func TestRenderOverviewWithoutSnapshot(t *testing.T) {
+	out := renderOverview(nil, 80, 24)
+	if !strings.Contains(out, "waiting for stats") {
+		t.Fatalf("expected waiting placeholder, got %q", out)
+	}
+}