summarizer_format_telegram.go

package taskengine

import (
	"html"
	"strings"
)

// formatTelegramFromStructured formats Summary into Telegram HTML using structured data
// Uses the PRD format: emoji + subject, network, time, executions list, footer
// All user-controlled content is HTML-escaped to prevent XSS attacks
func formatTelegramFromStructured(s Summary) string {
	var sb strings.Builder

	// Get status emoji - API returns subject WITHOUT emoji, aggregator prepends it
	statusEmoji := getStatusEmoji(s)

	// Subject as header with emoji prefix - only bold the workflow name
	if s.Subject != "" {
		sb.WriteString(statusEmoji)
		if statusEmoji != "" {
			sb.WriteString(" ")
		}
		sb.WriteString(formatSubjectWithBoldName(s.Subject))
		sb.WriteString("\n")
	}

	// Skipped note (success runs with branch-skipped steps) — surfaces why the
	// header shows ⚠️ instead of ✅.
	if s.SkippedNote != "" {
		sb.WriteString("<i>")
		sb.WriteString(html.EscapeString(s.SkippedNote))
		sb.WriteString("</i>\n")
	}

	// Network: use body.network field, fallback to workflow.chain or derive from chainID
	network := s.Network
	if network == "" && s.Workflow != nil {
		network = s.Workflow.Chain
		if network == "" && s.Workflow.ChainID > 0 {
			network = getChainDisplayName(s.Workflow.ChainID)
		}
	}

	// Network and Time section
	if network != "" || s.TriggeredAt != "" {
		sb.WriteString("\n")
		if network != "" {
			sb.WriteString("<b>Network:</b> ")
			sb.WriteString(html.EscapeString(network))
			sb.WriteString("\n")
		}
		if s.TriggeredAt != "" {
			sb.WriteString("<b>Time:</b> ")
			sb.WriteString(html.EscapeString(formatTimestampHumanReadable(s.TriggeredAt)))
			sb.WriteString("\n")
		}
	}

	// Trigger section
	if s.Trigger != "" {
		sb.WriteString("\n<b>Trigger:</b> ")
		sb.WriteString(html.EscapeString(s.Trigger))
		sb.WriteString("\n")
	}

	// Display executions with "Executed:" header (PRD format)
	if len(s.Executions) > 0 {
		sb.WriteString("\n<b>Executed:</b>\n")
		for _, exec := range s.Executions {
			sb.WriteString("• ")
			sb.WriteString(formatBackticksForChannel(exec.Description, "telegram"))
			sb.WriteString("\n")
			if exec.TxHash != "" {
				if explorerURL := buildTxExplorerURL(s, exec.TxHash); explorerURL != "" {
					sb.WriteString("  Transaction: <a href=\"")
					sb.WriteString(html.EscapeString(explorerURL))
					sb.WriteString("\">")
					sb.WriteString(html.EscapeString(truncateTxHash(exec.TxHash)))
					sb.WriteString("</a>\n")
				}
			}
		}
	}

	// "What Went Wrong" section — consistent with email
	if len(s.Errors) > 0 {
		sb.WriteString("\n<b>What Went Wrong:</b>\n")
		for _, err := range s.Errors {
			sb.WriteString("• ")
			sb.WriteString(formatBackticksForChannel(err, "telegram"))
			sb.WriteString("\n")
		}
	}

	if s.Annotation != "" {
		sb.WriteString("\n<i>")
		sb.WriteString(html.EscapeString(s.Annotation))
		sb.WriteString("</i>")
	}

	return strings.TrimSpace(sb.String())
}

// getStatusEmoji returns the emoji for the summary's status.
// A success run with branch-skipped steps renders ⚠️ (warn) rather than ✅,
// matching the yellow badge on email.
func getStatusEmoji(s Summary) string {
	switch s.Status {
	case "success":
		if s.SkippedSteps > 0 {
			return "⚠️"
		}
		return "✅"
	case "failed", "error":
		return "❌"
	default:
		return ""
	}
}

// formatSubjectWithBoldName formats the subject with <code> tags around the
// prefix + workflow name (everything except the trailing status suffix).
// Subject patterns:
//   - "Simulation: {name} successfully completed"
//   - "Run Node: {name} succeeded"
//   - "Run #N: {name} successfully completed"
//   - "{name} successfully completed"
//   - And similar patterns for "failed to execute" and "partially executed"
func formatSubjectWithBoldName(subject string) string {
	// Suffixes to look for (ordered from most specific to least)
	suffixes := []string{
		" successfully completed",
		" failed to execute",
		" partially executed",
		" succeeded",
	}

	// Prefixes to look for
	prefixes := []string{
		"Simulation: ",
		"Run Node: ",
	}

	// Check for "Run #N: " prefix pattern
	runPrefix := ""
	if strings.HasPrefix(subject, "Run #") {
		// Find the ": " after "Run #N"
		if idx := strings.Index(subject, ": "); idx > 0 {
			runPrefix = subject[:idx+2]
		}
	}

	// Find which suffix matches
	var suffix string
	var nameEnd int
	for _, s := range suffixes {
		if strings.HasSuffix(subject, s) {
			suffix = s
			nameEnd = len(subject) - len(s)
			break
		}
	}

	// Check for deployed workflow format: "{name}: succeeded (...)" or "{name}: failed at ..."
	// Must be checked before the generic " failed at " pattern to avoid splitting at the wrong point.
	if suffix == "" {
		for _, marker := range []string{": succeeded (", ": failed at "} {
			if idx := strings.Index(subject, marker); idx > 0 {
				suffix = subject[idx:]
				nameEnd = idx
				break
			}
		}
	}

	// Check for "failed at <stepName>" suffix (Run Node failure format)
	if suffix == "" && strings.Contains(subject, " failed at ") {
		idx := strings.LastIndex(subject, " failed at ")
		if idx > 0 {
			suffix = subject[idx:]
			nameEnd = idx
		}
	}

	// If no suffix found, just escape and return
	if suffix == "" {
		return html.EscapeString(subject)
	}

	// Find the prefix and extract the name
	var prefix string
	nameStart := 0

	if runPrefix != "" {
		prefix = runPrefix
		nameStart = len(runPrefix)
	} else {
		for _, p := range prefixes {
			if strings.HasPrefix(subject, p) {
				prefix = p
				nameStart = len(p)
				break
			}
		}
	}

	// Extract the workflow name
	name := subject[nameStart:nameEnd]

	// Build the formatted string: <code>prefix + name</code> + suffix
	// Using <code> prevents Telegram from auto-linking names that contain dots
	var sb strings.Builder
	sb.WriteString("<code>")
	if prefix != "" {
		sb.WriteString(html.EscapeString(prefix))
	}
	sb.WriteString(html.EscapeString(name))
	sb.WriteString("</code>")
	sb.WriteString(html.EscapeString(suffix))

	return sb.String()
}

func formatTelegramExampleMessage(workflowName, chainName string) string {
	var sb strings.Builder

	// Status line with emoji and workflow name (code-wrapped to prevent auto-linking)
	sb.WriteString("✅ <code>")
	sb.WriteString(html.EscapeString(workflowName))
	sb.WriteString("</code> completed\n\n")

	// Network
	sb.WriteString("<b>Network:</b> ")
	sb.WriteString(html.EscapeString(chainName))
	sb.WriteString("\n\n")

	// Executed section with example
	sb.WriteString("<b>Executed:</b>\n")
	sb.WriteString("• (Simulated) ")
	sb.WriteString(ExampleExecutionMessage)
	sb.WriteString("\n\n")

	// Example notice
	sb.WriteString("<i>")
	sb.WriteString(ExampleExecutionAnnotation)
	sb.WriteString("</i>")

	return sb.String()
}