summarizer_format_test.go

package taskengine

import (
	"context"
	"fmt"
	"math/big"
	"os"
	"strings"
	"testing"

	avsproto "github.com/AvaProtocol/EigenLayer-AVS/protobuf"
	"google.golang.org/protobuf/types/known/structpb"
)

const (
	// Default auth token for local context-memory tests
	ContextMemoryAuthToken = "test-auth-token-12345"
)

type fakeSummarizer struct {
	resp Summary
	err  error
}

func (f *fakeSummarizer) Summarize(ctx context.Context, vm *VM, currentStepName string) (Summary, error) {
	return f.resp, f.err
}

func TestComposeSummarySmart_FallbackDeterministic(t *testing.T) {
	SetSummarizer(nil)
	vm := NewVM()
	vm.mu.Lock()
	vm.vars["settings"] = map[string]interface{}{"name": "Workflow X"}
	vm.mu.Unlock()
	vm.ExecutionLogs = []*avsproto.Execution_Step{{
		Name:    "Step A",
		Success: true,
	}}

	s := ComposeSummarySmart(vm, "rest1")
	if !strings.Contains(s.Subject, "Workflow X: succeeded") {
		t.Fatalf("subject should contain 'Workflow X: succeeded', got: %q", s.Subject)
	}
	// Body should contain the workflow name and completion message
	// The exact format may vary based on available context (smart wallet, owner, etc.)
	// Just verify it contains the essential elements
	if s.Body == "" {
		t.Fatalf("body should not be empty")
	}
	if !strings.Contains(s.Body, "Workflow X") && !strings.Contains(s.Body, "Step A") {
		t.Fatalf("body should mention workflow or step name, got: %q", s.Body)
	}
}

func TestComposeSummarySmart_UsesAISummarizer(t *testing.T) {
	defer SetSummarizer(nil)

	// Check if we should use real context-memory API
	authToken := os.Getenv("SERVICE_AUTH_TOKEN")
	if authToken != "" {
		// Use real context-memory API
		baseURL := os.Getenv("CONTEXT_MEMORY_URL")
		if baseURL == "" {
			baseURL = ContextAPIURL // Default to production URL from source code
		}
		t.Logf("Using real context-memory API at: %s", baseURL)
		summarizer := NewContextMemorySummarizer(baseURL, authToken)
		SetSummarizer(summarizer)

		vm := NewVM()
		vm.mu.Lock()
		vm.vars["settings"] = map[string]interface{}{"name": "Test Workflow"}
		vm.mu.Unlock()
		vm.ExecutionLogs = []*avsproto.Execution_Step{
			{Id: "step1", Name: "test_step", Type: "balance", Success: true},
		}

		s := ComposeSummarySmart(vm, "current")
		if s.Subject == "" {
			t.Fatalf("AI summarizer should return non-empty subject, got empty")
		}
		if len(s.Body) < 40 {
			t.Fatalf("AI summarizer body should be at least 40 characters, got %d", len(s.Body))
		}
		t.Logf("Real API response - Subject: %s, Body length: %d", s.Subject, len(s.Body))
	} else {
		// Fallback to mock for CI/testing without SERVICE_AUTH_TOKEN
		// Body must be at least 40 characters to pass validation in ComposeSummarySmart
		f := &fakeSummarizer{resp: Summary{
			Subject: "AI subject",
			Body:    "This is a sufficiently long AI-generated body text that exceeds the 40 character minimum.",
		}}
		SetSummarizer(f)
		vm := NewVM()
		s := ComposeSummarySmart(vm, "current")
		if s.Subject != "AI subject" {
			t.Fatalf("ai summarizer subject not used: expected 'AI subject', got %q", s.Subject)
		}
		if !strings.Contains(s.Body, "AI-generated body text") {
			t.Fatalf("ai summarizer body not used: got %q", s.Body)
		}
	}
}

func TestComposeSummarySmart_AIFailsFallback(t *testing.T) {
	defer SetSummarizer(nil)
	f := &fakeSummarizer{err: context.DeadlineExceeded}
	SetSummarizer(f)
	vm := NewVM()
	vm.mu.Lock()
	vm.vars["settings"] = map[string]interface{}{"name": "Workflow Y"}
	vm.mu.Unlock()
	vm.ExecutionLogs = []*avsproto.Execution_Step{{
		Name:    "Done",
		Success: true,
	}}

	s := ComposeSummarySmart(vm, "rest1")
	if !strings.Contains(s.Subject, "Workflow Y: succeeded") {
		t.Fatalf("fallback failed, subject should contain 'Workflow Y: succeeded', got: %q", s.Subject)
	}
}

func TestFormatForMessageChannels_Telegram(t *testing.T) {
	tests := []struct {
		name            string
		summary         Summary
		expectedContain []string
		maxLength       int
	}{
		{
			name: "short summary with subject",
			summary: Summary{
				Subject: "Swap: succeeded (3 steps)",
				Body:    "Smart wallet 0xabc executed a swap on Uniswap V3.",
			},
			expectedContain: []string{"<b>Swap: succeeded (3 steps)</b>", "Smart wallet 0xabc executed a swap"},
			maxLength:       300,
		},
		{
			name: "long summary gets truncated",
			summary: Summary{
				Subject: "Trade: succeeded (5 steps)",
				Body: "Smart wallet 0x123 executed multiple trades on Uniswap V3. " +
					"First it approved 1000 USDC to the router contract at 0xdef. " +
					"Then it swapped 100 USDC for approximately 0.025 WETH via the pool. " +
					"Finally it performed another swap of 50 USDC for DAI tokens at contract 0x456. " +
					"All transactions completed successfully on Base network.",
			},
			expectedContain: []string{"<b>Trade: succeeded (5 steps)</b>", "Smart wallet 0x123"},
			maxLength:       300,
		},
		{
			name: "empty body returns subject",
			summary: Summary{
				Subject: "Workflow: failed (1 step)",
				Body:    "",
			},
			expectedContain: []string{"Workflow: failed (1 step)"},
			maxLength:       100,
		},
		{
			name: "body with double newlines extracts first paragraph",
			summary: Summary{
				Subject: "Approve: succeeded (1 step)",
				Body:    "Smart wallet 0xabc approved 500 USDC to Uniswap router.\n\nThis allows future swaps without additional approvals.",
			},
			expectedContain: []string{"<b>Approve: succeeded (1 step)</b>", "Smart wallet 0xabc approved 500 USDC"},
			maxLength:       300,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := FormatForMessageChannels(tt.summary, "telegram", nil)

			// Check that result contains expected strings
			for _, expected := range tt.expectedContain {
				if !strings.Contains(result, expected) {
					t.Errorf("expected result to contain %q, got: %s", expected, result)
				}
			}

			// Check length constraint
			if len(result) > tt.maxLength {
				t.Errorf("result too long: %d chars (max %d), got: %s", len(result), tt.maxLength, result)
			}

			// Verify HTML parse mode compatibility (should have <b> tags)
			if tt.summary.Subject != "" && tt.summary.Body != "" {
				if !strings.HasPrefix(result, "<b>") {
					t.Errorf("telegram message should start with <b> tag, got: %s", result)
				}
			}
		})
	}
}

func TestFormatForMessageChannels_Discord(t *testing.T) {
	summary := Summary{
		Subject: "Deploy: succeeded (2 steps)",
		Body:    "Contract deployed to 0xabc on Base network.",
	}

	result := FormatForMessageChannels(summary, "discord", nil)

	// Discord should use markdown bold
	if !strings.Contains(result, "**Deploy: succeeded (2 steps)**") {
		t.Errorf("discord message should use markdown bold, got: %s", result)
	}
	if !strings.Contains(result, "Contract deployed to 0xabc") {
		t.Errorf("discord message should contain body content, got: %s", result)
	}
}

func TestFormatTransferMessage(t *testing.T) {
	tests := []struct {
		name     string
		data     *TransferEventData
		expected string
	}{
		{
			name: "sent_eth",
			data: &TransferEventData{
				Direction:      "sent",
				FromAddress:    "0x5d814Cc9E94B2656f59Ee439D44AA1b6ca21434f",
				ToAddress:      "0x0000000000000000000000000000000000000002",
				Value:          "1.5",
				TokenSymbol:    "ETH",
				TokenName:      "Ether",
				BlockTimestamp: 1768943005000, // milliseconds
				ChainName:      "Sepolia",
			},
			expected: "⬆️ Sent <b>1.5 ETH</b> to <code>0x0000000000000000000000000000000000000002</code> on <b>Sepolia</b>",
		},
		{
			name: "received_usdc",
			data: &TransferEventData{
				Direction:      "received",
				FromAddress:    "0x1234567890123456789012345678901234567890",
				ToAddress:      "0x5d814Cc9E94B2656f59Ee439D44AA1b6ca21434f",
				Value:          "100.50",
				TokenSymbol:    "USDC",
				TokenName:      "USD Coin",
				BlockTimestamp: 1768943005, // seconds
				ChainName:      "Ethereum",
			},
			expected: "⬇️ Received <b>100.50 USDC</b> from <code>0x1234567890123456789012345678901234567890</code> on <b>Ethereum</b>",
		},
		{
			name:     "nil_data",
			data:     nil,
			expected: "",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := FormatTransferMessage(tt.data)
			if tt.expected == "" {
				if result != "" {
					t.Errorf("expected empty string, got: %s", result)
				}
				return
			}
			if !strings.Contains(result, tt.expected) {
				t.Errorf("expected result to contain %q, got: %s", tt.expected, result)
			}
		})
	}
}

// TestExtractTransferEventData_FromVars tests that transfer data can be extracted
// from vm.vars["transfer_monitor"] when ExecutionLogs has no Transfer event.
// This covers the single-node Telegram notification use case.
func TestExtractTransferEventData_FromVars(t *testing.T) {
	vm := NewVM()
	vm.mu.Lock()
	vm.vars = map[string]any{
		"transfer_monitor": map[string]interface{}{
			"data": map[string]interface{}{
				"eventName":      "Transfer",
				"direction":      "sent",
				"fromAddress":    "0x5d814Cc9E94B2656f59Ee439D44AA1b6ca21434f",
				"toAddress":      "0x0000000000000000000000000000000000000002",
				"value":          "1.5",
				"tokenSymbol":    "ETH",
				"tokenName":      "Ether",
				"blockTimestamp": int64(1768943005000),
			},
		},
		"settings": map[string]interface{}{
			"chain": "base",
		},
	}
	vm.ExecutionLogs = []*avsproto.Execution_Step{} // Empty - no trigger step
	vm.mu.Unlock()

	got := ExtractTransferEventData(vm)
	if got == nil {
		t.Fatal("expected non-nil TransferEventData from vars, got nil")
	}
	if got.Direction != "sent" {
		t.Errorf("expected Direction 'sent', got %q", got.Direction)
	}
	if got.Value != "1.5" {
		t.Errorf("expected Value '1.5', got %q", got.Value)
	}
	if got.TokenSymbol != "ETH" {
		t.Errorf("expected TokenSymbol 'ETH', got %q", got.TokenSymbol)
	}
	if got.FromAddress != "0x5d814Cc9E94B2656f59Ee439D44AA1b6ca21434f" {
		t.Errorf("expected FromAddress, got %q", got.FromAddress)
	}
	if got.ToAddress != "0x0000000000000000000000000000000000000002" {
		t.Errorf("expected ToAddress, got %q", got.ToAddress)
	}
	// ChainName should be resolved from settings (lowercase as stored)
	if got.ChainName != "base" {
		t.Errorf("expected ChainName 'base', got %q", got.ChainName)
	}

	// Verify FormatTransferMessage produces expected output
	msg := FormatTransferMessage(got)
	if !strings.Contains(msg, "1.5 ETH") {
		t.Errorf("expected message to contain '1.5 ETH', got: %s", msg)
	}
	if !strings.Contains(msg, "Sent") {
		t.Errorf("expected message to contain 'Sent', got: %s", msg)
	}
	if !strings.Contains(msg, "base") {
		t.Errorf("expected message to contain 'base', got: %s", msg)
	}
}

// TestExtractTransferEventData_ExecutionLogsTakesPrecedence verifies that
// ExecutionLogs data is used when present, even if transfer_monitor is also set.
func TestExtractTransferEventData_ExecutionLogsTakesPrecedence(t *testing.T) {
	vm := NewVM()

	// Create a protobuf struct for the event trigger data
	eventData := map[string]interface{}{
		"eventName":      "Transfer",
		"direction":      "received",
		"fromAddress":    "0x1111111111111111111111111111111111111111",
		"toAddress":      "0x2222222222222222222222222222222222222222",
		"value":          "99.0",
		"tokenSymbol":    "USDC",
		"tokenName":      "USD Coin",
		"blockTimestamp": float64(1768943005000),
	}

	// Convert to structpb.Value
	protoData, _ := structpb.NewValue(eventData)

	vm.mu.Lock()
	vm.ExecutionLogs = []*avsproto.Execution_Step{
		{
			Id:      "trigger",
			Name:    "eventTrigger",
			Type:    "eventTrigger",
			Success: true,
			OutputData: &avsproto.Execution_Step_EventTrigger{
				EventTrigger: &avsproto.EventTrigger_Output{
					Data: protoData,
				},
			},
		},
	}
	// Also set transfer_monitor with different data
	vm.vars = map[string]any{
		"transfer_monitor": map[string]interface{}{
			"data": map[string]interface{}{
				"eventName":   "Transfer",
				"direction":   "sent",
				"value":       "1.5",
				"tokenSymbol": "ETH",
			},
		},
		"settings": map[string]interface{}{
			"chain": "ethereum",
		},
	}
	vm.mu.Unlock()

	got := ExtractTransferEventData(vm)
	if got == nil {
		t.Fatal("expected non-nil TransferEventData, got nil")
	}
	// Should use ExecutionLogs data (received USDC), not transfer_monitor (sent ETH)
	if got.Direction != "received" {
		t.Errorf("expected Direction 'received' from ExecutionLogs, got %q", got.Direction)
	}
	if got.TokenSymbol != "USDC" {
		t.Errorf("expected TokenSymbol 'USDC' from ExecutionLogs, got %q", got.TokenSymbol)
	}
	if got.Value != "99.0" {
		t.Errorf("expected Value '99.0' from ExecutionLogs, got %q", got.Value)
	}
}

// TestFormatForMessageChannels_SingleNodeExample tests that single-node executions
// without transfer data show an example message with real workflow name and chain.
func TestFormatForMessageChannels_SingleNodeExample(t *testing.T) {
	vm := NewVM()
	vm.mu.Lock()
	// Single node execution: no TaskID, exactly one TaskNode
	vm.TaskNodes = map[string]*avsproto.TaskNode{
		"node1": {Id: "node1", Name: "singleNodeExecution_restApi"},
	}
	vm.vars = map[string]any{
		"settings": map[string]interface{}{
			"name":  "My Transfer Monitor",
			"chain": "Base",
		},
	}
	// No transfer_monitor data - should trigger example message
	vm.ExecutionLogs = []*avsproto.Execution_Step{}
	vm.mu.Unlock()

	// Empty summary - no structured data
	summary := Summary{}

	result := FormatForMessageChannels(summary, "telegram", vm)

	// Should contain workflow name from settings
	if !strings.Contains(result, "My Transfer Monitor") {
		t.Errorf("expected result to contain workflow name 'My Transfer Monitor', got: %s", result)
	}

	// Should contain chain name from settings
	if !strings.Contains(result, "Base") {
		t.Errorf("expected result to contain chain name 'Base', got: %s", result)
	}

	// Should contain the example execution line
	if !strings.Contains(result, "(Simulated) On-chain transaction successfully completed") {
		t.Errorf("expected result to contain example execution line, got: %s", result)
	}

	// Should contain the example notice
	if !strings.Contains(result, "This is an example") {
		t.Errorf("expected result to contain example notice, got: %s", result)
	}

	// Should be formatted as Telegram HTML
	if !strings.Contains(result, "<b>") {
		t.Errorf("expected Telegram HTML formatting with <b> tags, got: %s", result)
	}

	t.Logf("Example message:\n%s", result)
}

// TestFormatForMessageChannels_SingleNodeExample_Discord tests Discord formatting
func TestFormatForMessageChannels_SingleNodeExample_Discord(t *testing.T) {
	vm := NewVM()
	vm.mu.Lock()
	vm.TaskNodes = map[string]*avsproto.TaskNode{
		"node1": {Id: "node1", Name: "singleNodeExecution_restApi"},
	}
	vm.vars = map[string]any{
		"settings": map[string]interface{}{
			"name":     "Price Alert",
			"chain_id": 8453, // Base chain ID
		},
	}
	vm.ExecutionLogs = []*avsproto.Execution_Step{}
	vm.mu.Unlock()

	summary := Summary{}
	result := FormatForMessageChannels(summary, "discord", vm)

	// Should use Discord markdown formatting
	if !strings.Contains(result, "**Price Alert**") {
		t.Errorf("expected Discord markdown with **workflow name**, got: %s", result)
	}

	// Chain should be resolved from chain_id
	if !strings.Contains(result, "Base") {
		t.Errorf("expected chain name 'Base' resolved from chain_id, got: %s", result)
	}

	t.Logf("Discord example message:\n%s", result)
}

// TestComposeSummarySmart_WithRealWorkflowState tests the full flow
// with realistic workflow state. Uses real context-memory API if SERVICE_AUTH_TOKEN is set.
func TestComposeSummarySmart_WithRealWorkflowState(t *testing.T) {
	defer SetSummarizer(nil)

	vm := NewVM()
	vm.TaskID = "01K6H8R583M8WFXM2Z4APP7JTN"

	// Simulate a workflow that ran 4 out of 7 steps
	vm.ExecutionLogs = []*avsproto.Execution_Step{
		{Id: "trigger", Name: "eventTrigger", Type: "eventTrigger", Success: true},
		{Id: "step1", Name: "balance1", Type: "balance", Success: true},
		{Id: "step2", Name: "branch1", Type: "branch", Success: true},
		{Id: "step3", Name: "email_report", Type: "restApi", Success: true},
	}

	vm.mu.Lock()
	vm.TaskNodes = map[string]*avsproto.TaskNode{
		"node1": {Id: "node1", Name: "balance1"},
		"node2": {Id: "node2", Name: "branch1"},
		"node3": {Id: "node3", Name: "approve_token1"},
		"node4": {Id: "node4", Name: "get_quote"},
		"node5": {Id: "node5", Name: "run_swap"},
		"node6": {Id: "node6", Name: "email_report"},
	}
	vm.vars = map[string]interface{}{
		"settings": map[string]interface{}{
			"name":   "Test template",
			"chain":  "Sepolia",
			"runner": "0xeCb88a770e1b2Ba303D0dC3B1c6F239fAB014bAE",
		},
	}
	vm.mu.Unlock()

	// Check if we should use real context-memory API
	authToken := os.Getenv("SERVICE_AUTH_TOKEN")
	if authToken != "" {
		// Use real context-memory API (defaults to localhost:3000)
		baseURL := os.Getenv("CONTEXT_MEMORY_URL")
		if baseURL == "" {
			baseURL = ContextAPIURL // Default to production URL from source code
		}
		t.Logf("Using real context-memory API at: %s", baseURL)
		summarizer := NewContextMemorySummarizer(baseURL, authToken)
		SetSummarizer(summarizer)
	} else {
		// Use deterministic fallback if no auth token
		t.Log("SERVICE_AUTH_TOKEN not set, using deterministic fallback")
		SetSummarizer(nil)
	}

	summary := ComposeSummarySmart(vm, "email_report")

	// Should show workflow name and execution status
	if !strings.Contains(summary.Subject, "Test template") {
		t.Errorf("Subject should contain workflow name, got: %s", summary.Subject)
	}

	if summary.Body == "" {
		t.Error("Body should not be empty")
	}

	t.Logf("Subject: %s", summary.Subject)
	t.Logf("Body length: %d", len(summary.Body))
}

// TestComposeSummary_SimulationSubjectFormat tests that simulation workflows
// generate the correct subject format matching context-memory API expectations
func TestComposeSummary_SimulationSubjectFormat(t *testing.T) {
	tests := []struct {
		name            string
		workflowName    string
		executedSteps   int
		totalSteps      int
		hasFailures     bool
		hasSkippedNodes bool
		isSimulation    bool
		expectedSubject string
		expectedSummary string
	}{
		{
			name:            "simulation successfully completed",
			workflowName:    "Test Stoploss",
			executedSteps:   7,
			totalSteps:      7,
			hasFailures:     false,
			hasSkippedNodes: false,
			isSimulation:    true,
			expectedSubject: "Simulation: Test Stoploss successfully completed",
			expectedSummary: "Your workflow 'Test Stoploss' executed 7 out of 7 total steps",
		},
		{
			name:            "simulation partially executed",
			workflowName:    "Test Stoploss",
			executedSteps:   5,
			totalSteps:      8,
			hasFailures:     false,
			hasSkippedNodes: true,
			isSimulation:    true,
			expectedSubject: "Simulation: Test Stoploss partially executed",
			expectedSummary: "Your workflow 'Test Stoploss' executed 5 out of 8 total steps",
		},
		{
			name:            "simulation failed to execute",
			workflowName:    "Test Stoploss",
			executedSteps:   3,
			totalSteps:      8,
			hasFailures:     true,
			hasSkippedNodes: false,
			isSimulation:    true,
			expectedSubject: "Simulation: Test Stoploss failed to execute",
			expectedSummary: "Your workflow 'Test Stoploss' executed 3 out of 8 total steps",
		},
		{
			name:            "deployed workflow succeeded",
			workflowName:    "Test Stoploss",
			executedSteps:   7,
			totalSteps:      7,
			hasFailures:     false,
			hasSkippedNodes: false,
			isSimulation:    false,
			expectedSubject: "Test Stoploss: succeeded (7 out of 7 steps)",
			expectedSummary: "Your workflow 'Test Stoploss' executed 7 out of 7 total steps",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			vm := NewVM()
			vm.IsSimulation = tt.isSimulation

			// Set up workflow name
			vm.mu.Lock()
			vm.vars = map[string]interface{}{
				"settings": map[string]interface{}{
					"name":  tt.workflowName,
					"chain": "Sepolia",
				},
			}

			// Set up task nodes (for total steps calculation)
			vm.TaskNodes = make(map[string]*avsproto.TaskNode)
			for i := 0; i < tt.totalSteps-1; i++ { // -1 because trigger is counted separately
				nodeID := fmt.Sprintf("node%d", i)
				vm.TaskNodes[nodeID] = &avsproto.TaskNode{
					Id:   nodeID,
					Name: fmt.Sprintf("step%d", i),
				}
			}

			// Set up execution logs
			vm.ExecutionLogs = make([]*avsproto.Execution_Step, 0, tt.executedSteps)
			// Add trigger (always first)
			vm.ExecutionLogs = append(vm.ExecutionLogs, &avsproto.Execution_Step{
				Id:      "trigger",
				Name:    "eventTrigger",
				Type:    "TRIGGER_TYPE_EVENT",
				Success: true,
			})

			// Add executed steps
			for i := 0; i < tt.executedSteps-1; i++ { // -1 because trigger is already added
				stepName := fmt.Sprintf("step%d", i)
				success := true
				if tt.hasFailures && i == tt.executedSteps-2 { // Last step fails
					success = false
				}
				vm.ExecutionLogs = append(vm.ExecutionLogs, &avsproto.Execution_Step{
					Id:      fmt.Sprintf("step%d", i),
					Name:    stepName,
					Type:    "NODE_TYPE_BALANCE",
					Success: success,
					Error: func() string {
						if !success {
							return "test error"
						}
						return ""
					}(),
				})
			}

			// Mark some nodes as skipped if needed (by not including them in execution logs)
			// The skipped count is calculated by comparing TaskNodes to ExecutionLogs
			vm.mu.Unlock()

			summary := ComposeSummary(vm, "email1")

			// Verify subject format
			if summary.Subject != tt.expectedSubject {
				t.Errorf("Subject mismatch:\n  expected: %q\n  got:      %q", tt.expectedSubject, summary.Subject)
			}

			// Verify summary line format
			if summary.SummaryLine != tt.expectedSummary {
				t.Errorf("SummaryLine mismatch:\n  expected: %q\n  got:      %q", tt.expectedSummary, summary.SummaryLine)
			}

			// Verify body format - with the new structured format, Body starts with "Trigger: ..."
			// The "Your workflow..." summary is now in SummaryLine field
			if !strings.HasPrefix(summary.Body, "Trigger: ") {
				t.Errorf("Body format mismatch:\n  expected to start with: %q\n  got:                      %q", "Trigger: ", summary.Body)
			}
		})
	}
}

// TestComposeSummary_SimulationBodyFormat tests that simulation workflows
// generate the correct subject and summary line format matching context-memory API expectations
func TestComposeSummary_SimulationBodyFormat(t *testing.T) {
	vm := NewVM()
	vm.IsSimulation = true

	vm.mu.Lock()
	vm.vars = map[string]interface{}{
		"settings": map[string]interface{}{
			"name":  "Test Stoploss",
			"chain": "Sepolia",
		},
	}
	vm.TaskNodes = map[string]*avsproto.TaskNode{
		"node1": {Id: "node1", Name: "step1"},
		"node2": {Id: "node2", Name: "step2"},
	}
	vm.mu.Unlock()

	// Create execution logs
	vm.ExecutionLogs = []*avsproto.Execution_Step{
		{
			Id:      "trigger",
			Name:    "eventTrigger",
			Type:    "TRIGGER_TYPE_EVENT",
			Success: true,
		},
		{
			Id:      "step1",
			Name:    "step1",
			Type:    "NODE_TYPE_BALANCE",
			Success: true,
		},
		{
			Id:      "step2",
			Name:    "step2",
			Type:    "NODE_TYPE_BALANCE",
			Success: true,
		},
	}

	summary := ComposeSummary(vm, "email1")

	// Verify subject format matches context-memory API expectations
	expectedSubject := "Simulation: Test Stoploss successfully completed"
	if summary.Subject != expectedSubject {
		t.Errorf("Subject mismatch:\n  expected: %q\n  got:      %q", expectedSubject, summary.Subject)
	}

	// Verify summary line format matches context-memory API expectations
	expectedSummary := "Your workflow 'Test Stoploss' executed 3 out of 3 total steps"
	if summary.SummaryLine != expectedSummary {
		t.Errorf("SummaryLine mismatch:\n  expected: %q\n  got:      %q", expectedSummary, summary.SummaryLine)
	}

	// Verify body format - with the new structured format, Body starts with "Trigger: ..."
	// The "Your workflow..." summary is now in SummaryLine field
	if !strings.HasPrefix(summary.Body, "Trigger: ") {
		t.Errorf("Body format mismatch:\n  expected to start with: %q\n  got:                      %q", "Trigger: ", summary.Body)
	}

	// Verify SummaryLine contains the expected format
	expectedSummaryLine := "Your workflow 'Test Stoploss' executed 3 out of 3 total steps"
	if summary.SummaryLine != expectedSummaryLine {
		t.Errorf("SummaryLine mismatch:\n  expected: %q\n  got:      %q", expectedSummaryLine, summary.SummaryLine)
	}

	t.Logf("Subject: %s", summary.Subject)
	t.Logf("SummaryLine: %s", summary.SummaryLine)
	t.Logf("Body: %s", summary.Body)
}

// TestFormatTelegramFromStructured_PRDFormat tests the PRD-based Telegram format
// that uses body.network and body.executions array with emoji prepended by aggregator
func TestFormatTelegramFromStructured_PRDFormat(t *testing.T) {
	tests := []struct {
		name            string
		summary         Summary
		expectedContain []string
		notContain      []string
	}{
		{
			name: "simulation with transfer - PRD format",
			summary: Summary{
				Subject:     "Simulation: Recurring Payment successfully completed", // No emoji from API
				Status:      "success",
				Network:     "Sepolia",
				Trigger:     "(Simulated) Your scheduled task (every 3 days at 11:00 PM) triggered on Sepolia.",
				TriggeredAt: "2026-01-22T04:51:18.509Z",
				Executions: []ExecutionEntry{
					{Description: "(Simulated) Transferred 0.01 ETH to 0xc60e...C788"},
				},
			},
			expectedContain: []string{
				"✅ <code>Simulation: Recurring Payment</code> successfully completed", // Prefix + name code-wrapped
				"<b>Network:</b> Sepolia",
				"<b>Time:</b> Jan 22, 2026 at 4:51 AM UTC",
				"<b>Trigger:</b> (Simulated) Your scheduled task (every 3 days at 11:00 PM) triggered on Sepolia.",
				"<b>Executed:</b>",
				"• (Simulated) Transferred 0.01 ETH to 0xc60e...C788",
			},
			notContain: []string{},
		},
		{
			name: "deployed run with transfer - PRD format",
			summary: Summary{
				Subject:     "Run #3: Recurring Payment successfully completed", // No emoji from API
				Status:      "success",
				Network:     "Sepolia",
				TriggeredAt: "2026-01-22T04:51:18.509Z",
				Executions: []ExecutionEntry{
					{Description: "Transferred 0.01 ETH to 0xc60e...C788"},
				},
			},
			expectedContain: []string{
				"✅ <code>Run #3: Recurring Payment</code> successfully completed", // Prefix + name code-wrapped
				"<b>Network:</b> Sepolia",
				"<b>Time:</b> Jan 22, 2026 at 4:51 AM UTC",
				"<b>Executed:</b>",
				"• Transferred 0.01 ETH to 0xc60e...C788",
			},
			notContain: []string{
				"No on-chain transaction was executed", // No simulation notice for real runs
			},
		},
		{
			name: "failed run - PRD format",
			summary: Summary{
				Subject:     "Run #5: Recurring Payment failed to execute", // No emoji from API
				Status:      "failed",
				Network:     "Sepolia",
				TriggeredAt: "2026-01-22T04:51:18.509Z",
				Errors:      []string{"transfer1: Insufficient balance for transfer"},
			},
			expectedContain: []string{
				"❌ <code>Run #5: Recurring Payment</code> failed to execute", // Prefix + name code-wrapped
				"<b>Network:</b> Sepolia",
				"<b>What Went Wrong:</b>",
				"• transfer1: Insufficient balance for transfer",
			},
			notContain: []string{
				"<b>Executed:</b>",
			},
		},
		{
			name: "success with skipped nodes renders warn emoji and skippedNote",
			summary: Summary{
				Subject:      "Run #2: My Workflow successfully completed",
				Status:       "success",
				SkippedSteps: 1,
				SkippedNote:  "1 node was skipped by Branch condition.",
				Network:      "Ethereum",
				TriggeredAt:  "2026-01-22T04:51:18.509Z",
				Executions: []ExecutionEntry{
					{Description: "Approved 100 USDC to router"},
				},
			},
			expectedContain: []string{
				"⚠️ <code>Run #2: My Workflow</code> successfully completed",
				"<i>1 node was skipped by Branch condition.</i>",
				"<b>Network:</b> Ethereum",
				"<b>Executed:</b>",
				"• Approved 100 USDC to router",
			},
			notContain: []string{},
		},
		{
			name: "success with branch-skipped errors and backtick expression",
			summary: Summary{
				Subject:      "Simulation: Copy of Test Recurring Batch Send successfully completed",
				Status:       "success",
				SkippedSteps: 1,
				SkippedNote:  "1 node was skipped by Branch condition.",
				Network:      "Sepolia",
				TriggeredAt:  "2026-01-22T04:51:18.509Z",
				Trigger:      "(Simulated) Your scheduled task (every 3 minutes) triggered on Sepolia.",
				Errors:       []string{"loop1 - skipped due to condition not met: `code1.data.balance >= code1.data.totalNeeded` evaluated to false"},
			},
			expectedContain: []string{
				"⚠️ <code>Simulation: Copy of Test Recurring Batch Send</code> successfully completed",
				"<i>1 node was skipped by Branch condition.</i>",
				"<b>Network:</b> Sepolia",
				"<b>What Went Wrong:</b>",
				"• loop1 - skipped due to condition not met: <code>code1.data.balance &gt;= code1.data.totalNeeded</code> evaluated to false",
			},
			notContain: []string{
				"<b>Executed:</b>",
				"`", // backticks should be converted to <code> tags
			},
		},
		{
			name: "network fallback from workflow.chain",
			summary: Summary{
				Subject: "Simulation: Test successfully completed",
				Status:  "success",
				Network: "", // Empty network from API
				Workflow: &WorkflowInfo{
					Chain:   "Base",
					ChainID: 8453,
				},
				Executions: []ExecutionEntry{{Description: "(Simulated) Test executed"}},
			},
			expectedContain: []string{
				"<b>Network:</b> Base", // Falls back to workflow.chain
			},
		},
		{
			name: "network fallback from chainID",
			summary: Summary{
				Subject: "Simulation: Test successfully completed",
				Status:  "success",
				Network: "", // Empty network from API
				Workflow: &WorkflowInfo{
					Chain:   "", // Empty chain name
					ChainID: 11155111,
				},
				Executions: []ExecutionEntry{{Description: "(Simulated) Test executed"}},
			},
			expectedContain: []string{
				"<b>Network:</b> Sepolia", // Derived from chainID
			},
		},
		{
			name: "execution descriptions with backtick method names",
			summary: Summary{
				Subject: "Run #1: DeFi Bot successfully completed",
				Status:  "success",
				Network: "Ethereum",
				Executions: []ExecutionEntry{
					{Description: "Called `approve` on 0xC364...42a0"},
					{Description: "`getUserAccountData` returned healthFactor: 1.85"},
				},
			},
			expectedContain: []string{
				"<b>Executed:</b>",
				"• Called <code>approve</code> on 0xC364...42a0",
				"• <code>getUserAccountData</code> returned healthFactor: 1.85",
			},
			notContain: []string{
				"`approve`", // backticks should be converted
				"`getUserAccountData`",
			},
		},
		{
			name: "no on-chain executions - fallback populated by ComposeSummary",
			summary: Summary{
				Subject:     "Simulation: My Workflow successfully completed",
				Status:      "success",
				Network:     "Sepolia",
				TriggeredAt: "2026-01-28T07:31:51Z",
				Trigger:     "(Simulated) Scheduled task ran on Sepolia",
				// ComposeSummary populates fallback execution entry when buildExecutionsArray returns empty
				Executions: []ExecutionEntry{{Description: "(Simulated) On-chain transaction successfully completed"}},
			},
			expectedContain: []string{
				"✅ <code>Simulation: My Workflow</code> successfully completed",
				"<b>Network:</b> Sepolia",
				"<b>Trigger:</b> (Simulated) Scheduled task ran on Sepolia",
				"<b>Executed:</b>",
				"• (Simulated) On-chain transaction successfully completed",
			},
			notContain: []string{},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := FormatForMessageChannels(tt.summary, "telegram", nil)

			// Check expected strings are present
			for _, expected := range tt.expectedContain {
				if !strings.Contains(result, expected) {
					t.Errorf("expected result to contain %q\nGot:\n%s", expected, result)
				}
			}

			// Check unwanted strings are not present
			for _, notExpected := range tt.notContain {
				if strings.Contains(result, notExpected) {
					t.Errorf("result should NOT contain %q\nGot:\n%s", notExpected, result)
				}
			}
		})
	}
}

// TestFormatTelegramFromStructured_Annotation tests that annotation renders in italic for Telegram
func TestFormatTelegramFromStructured_Annotation(t *testing.T) {
	summary := Summary{
		Subject:    "Run Node: My Workflow succeeded",
		Status:     "success",
		Network:    "Sepolia",
		Executions: []ExecutionEntry{{Description: "Transferred 0.01 ETH"}},
		Annotation: "This is an example. Actual execution details will appear when the workflow is simulated or triggered by a real event.",
	}

	result := FormatForMessageChannels(summary, "telegram", nil)

	// Should contain annotation in italic
	if !strings.Contains(result, "<i>This is an example.") {
		t.Errorf("expected Telegram output to contain italic annotation, got:\n%s", result)
	}
	if !strings.Contains(result, "</i>") {
		t.Errorf("expected Telegram output to close italic tag, got:\n%s", result)
	}

	// Without annotation, no italic tag
	summaryNoAnnotation := Summary{
		Subject:    "Simulation: My Workflow successfully completed",
		Status:     "success",
		Network:    "Sepolia",
		Executions: []ExecutionEntry{{Description: "(Simulated) Transferred 0.01 ETH"}},
	}
	resultNoAnnotation := FormatForMessageChannels(summaryNoAnnotation, "telegram", nil)
	if strings.Contains(resultNoAnnotation, "<i>") {
		t.Errorf("expected no italic tag when Annotation is empty, got:\n%s", resultNoAnnotation)
	}

	t.Logf("With annotation:\n%s", result)
	t.Logf("Without annotation:\n%s", resultNoAnnotation)
}

// TestFormatTelegramFromStructured_RunnerAndFees verifies the Runner and Cost
// blocks render from Summary.Runner / Summary.Fees, mirroring what the
// context-memory API now returns. Numbers come from the real Sepolia run
// captured in aggregator-sepolia.log on 2026-05-02 (see PRD).
func TestFormatTelegramFromStructured_RunnerAndFees(t *testing.T) {
	summary := Summary{
		Subject:     "Run #1: Automatically Split Incoming USDC Payments successfully completed",
		Status:      "success",
		Network:     "Sepolia",
		Trigger:     "Transfer event detected: received 1 USDC from 0x804e...1557 on Sepolia",
		TriggeredAt: "2026-05-02T04:05:29.526Z",
		Executions: []ExecutionEntry{
			{Description: "Transferred 0.2 USDC to 0x804e...1557"},
			{Description: "Transferred 0.5 USDC to 0x25d9...321D"},
			{Description: "Transferred 0.3 USDC to 0xfE66...bDA9"},
		},
		Workflow: &WorkflowInfo{IsSimulation: false},
		Runner: &RunnerInfo{
			SmartWallet: "0x8Ee38eB323c14a1752DABDA1cca9661AEE377017",
			OwnerEOA:    "0x804e49e8C4eDb560AE7c48B554f6d2e27Bb81557",
		},
		Fees: &FeesInfo{
			ExecutionFee: &FeeAmount{Amount: "0.020000", Unit: "USD"},
			Total: []*TokenTotal{
				{Amount: "0.000003", Unit: "ETH", USD: "0.01"},
				{Amount: "0.02", Unit: "USD", USD: "0.02"}, // platform fee — renders as "$0.02 platform fee"
			},
		},
	}

	out := FormatForMessageChannels(summary, "telegram", nil)

	// Runner line: smart wallet + chain qualifier on a single line ("Runner:
	// 0x… on Sepolia"). Owner intentionally omitted on Telegram — kept compact
	// for the channel. Address is truncated (7-char prefix + 4-char suffix),
	// NOT <code>-wrapped (per PRD).
	if !strings.Contains(out, "<b>Runner:</b> 0x8Ee38...7017 on Sepolia") {
		t.Errorf("missing combined Runner+chain line in:\n%s", out)
	}
	// Standalone Network line should NOT render when Runner is present —
	// chain is folded into the Runner line.
	if strings.Contains(out, "<b>Network:</b>") {
		t.Errorf("standalone Network line should not render when Runner is present, got:\n%s", out)
	}
	if strings.Contains(out, "<b>Owner:</b>") {
		t.Errorf("Owner line should NOT render on Telegram, got:\n%s", out)
	}
	if strings.Contains(out, "<code>0x8Ee3") {
		t.Errorf("runner address should not be <code>-wrapped, got:\n%s", out)
	}

	// Cost line: native gas first, then platform fee as a separate "$X platform fee".
	if !strings.Contains(out, "⛽ <b>Cost:</b> 0.000003 ETH ($0.01), $0.02 platform fee") {
		t.Errorf("missing combined gas+platform Cost line in:\n%s", out)
	}
	if strings.Contains(out, "(~") || strings.Contains(out, "<b>Value fee:</b>") {
		t.Errorf("Telegram should not render gas-units detail or Value fee line, got:\n%s", out)
	}
	if strings.Contains(out, "(see cost estimate before deploy)") {
		t.Errorf("deployed run should not show simulation placeholder, got:\n%s", out)
	}

	// Cost line follows Runner directly inside the metadata block (no blank
	// line between them).
	if !strings.Contains(out, "<b>Runner:</b> 0x8Ee38...7017 on Sepolia\n⛽ <b>Cost:</b> ") {
		t.Errorf("Cost line should immediately follow Runner line, got:\n%s", out)
	}

	t.Logf("Telegram render:\n%s", out)
}

// TestFormatTelegramFromStructured_PlatformFeeOnly covers the read-only path:
// no on-chain steps, only the platform fee. Renders as "$0.02 platform fee"
// with no gas-equivalent ETH line that could be misread as gas.
func TestFormatTelegramFromStructured_PlatformFeeOnly(t *testing.T) {
	summary := Summary{
		Subject:  "Run #1: Read-Only Workflow successfully completed",
		Status:   "success",
		Network:  "Sepolia",
		Workflow: &WorkflowInfo{IsSimulation: false},
		Runner:   &RunnerInfo{SmartWallet: "0x8Ee38eB323c14a1752DABDA1cca9661AEE377017"},
		Fees: &FeesInfo{
			ExecutionFee: &FeeAmount{Amount: "0.02", Unit: "USD"},
			Total: []*TokenTotal{
				{Amount: "0.02", Unit: "USD", USD: "0.02"},
			},
		},
	}
	out := FormatForMessageChannels(summary, "telegram", nil)
	if !strings.Contains(out, "⛽ <b>Cost:</b> $0.02 platform fee") {
		t.Errorf("expected platform-fee-only Cost line, got:\n%s", out)
	}
	if strings.Contains(out, " ETH (") {
		t.Errorf("read-only run should not render an ETH line, got:\n%s", out)
	}
}

// TestFormatTelegramFromStructured_NoPriceService covers Moralis-not-configured:
// gas renders with $? for USD; platform fee still shows as the canonical $X.
func TestFormatTelegramFromStructured_NoPriceService(t *testing.T) {
	summary := Summary{
		Subject:  "Run #1: Workflow successfully completed",
		Status:   "success",
		Network:  "Sepolia",
		Workflow: &WorkflowInfo{IsSimulation: false},
		Runner:   &RunnerInfo{SmartWallet: "0x8Ee38eB323c14a1752DABDA1cca9661AEE377017"},
		Fees: &FeesInfo{
			ExecutionFee: &FeeAmount{Amount: "0.02", Unit: "USD"},
			Total: []*TokenTotal{
				{Amount: "0.000003", Unit: "ETH", USD: ""}, // unpriced — renders "$?"
				{Amount: "0.02", Unit: "USD", USD: "0.02"},
			},
		},
	}
	out := FormatForMessageChannels(summary, "telegram", nil)
	if !strings.Contains(out, "⛽ <b>Cost:</b> 0.000003 ETH ($?), $0.02 platform fee") {
		t.Errorf("expected unpriced ETH + platform fee, got:\n%s", out)
	}
}

// TestFormatTelegramFromStructured_MultiToken_USDPlaceholder verifies the
// multi-token comma-separated render and the "$?" placeholder for unpriceable
// entries. Mirror of the format spec in the PRD's Rendering section.
func TestFormatTelegramFromStructured_MultiToken_USDPlaceholder(t *testing.T) {
	summary := Summary{
		Subject:    "Run #1: Multi-token Workflow successfully completed",
		Status:     "success",
		Network:    "Ethereum",
		Executions: []ExecutionEntry{{Description: "Transferred 1.2 USDC"}},
		Workflow:   &WorkflowInfo{IsSimulation: false},
		Runner:     &RunnerInfo{SmartWallet: "0x8Ee38eB323c14a1752DABDA1cca9661AEE377017"},
		Fees: &FeesInfo{
			Total: []*TokenTotal{
				{Amount: "0.01", Unit: "ETH", USD: "25.00"},
				{Amount: "1.2", Unit: "USDC", USD: "1.20"},
				{Amount: "0.005", Unit: "PEPE", USD: ""}, // unpriceable
			},
		},
	}

	out := FormatForMessageChannels(summary, "telegram", nil)
	want := "⛽ <b>Cost:</b> 0.01 ETH ($25.00), 1.2 USDC ($1.20), 0.005 PEPE ($?)"
	if !strings.Contains(out, want) {
		t.Errorf("missing multi-token Cost line %q in:\n%s", want, out)
	}
}

// TestPercentOfRaw verifies the value-fee percentage math against raw amounts.
func TestPercentOfRaw(t *testing.T) {
	pct := func(s string) *big.Float {
		v, _ := new(big.Float).SetString(s)
		return v
	}
	cases := []struct {
		name string
		raw  string
		pct  *big.Float
		want string
	}{
		{"1 USDC × 0.03% = 300 raw (6 decimals)", "1000000", pct("0.0003"), "300"},
		{"1000 USDC × 0.03%", "1000000000", pct("0.0003"), "300000"},
		{"zero raw", "0", pct("0.0003"), ""},
		{"zero pct", "1000000", pct("0"), ""},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			rawInt, _ := new(big.Int).SetString(tc.raw, 10)
			got := percentOfRaw(rawInt, tc.pct)
			if tc.want == "" {
				if got != nil && got.Sign() > 0 {
					t.Errorf("expected nil/zero, got %s", got.String())
				}
				return
			}
			if got == nil || got.String() != tc.want {
				t.Errorf("percentOfRaw(%s, %s) = %v, want %s", tc.raw, tc.pct.String(), got, tc.want)
			}
		})
	}
}

// TestTokenBucketToTokenTotal verifies stablecoin shortcut + zero-rounding.
func TestTokenBucketToTokenTotal(t *testing.T) {
	cases := []struct {
		name       string
		bucket     *tokenBucket
		chainID    uint64
		wantNil    bool
		wantAmount string
		wantUnit   string
		wantUSD    string
	}{
		{
			name: "USDC mainnet 1.0 token via stablecoin shortcut",
			bucket: &tokenBucket{
				contract: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
				symbol:   "USDC",
				decimals: 6,
				raw:      mustBigInt("1000000"),
			},
			chainID:    1,
			wantAmount: "1",
			wantUnit:   "USDC",
			wantUSD:    "1",
		},
		{
			name: "0.0003 USDC via stablecoin shortcut",
			bucket: &tokenBucket{
				contract: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
				symbol:   "USDC",
				decimals: 6,
				raw:      mustBigInt("300"),
			},
			chainID:    1,
			wantAmount: "0.0003",
			wantUnit:   "USDC",
			wantUSD:    "0",
		},
		{
			name: "below precision rounds to zero — omit",
			bucket: &tokenBucket{
				contract: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
				symbol:   "USDC",
				decimals: 6,
				raw:      mustBigInt("0"),
			},
			chainID: 1,
			wantNil: true,
		},
		{
			name: "unknown ERC20 with no price service → empty USD",
			bucket: &tokenBucket{
				contract: "0xff00000000000000000000000000000000000099",
				symbol:   "?",
				decimals: 18,
				raw:      mustBigInt("1000000000000000000"),
			},
			chainID:    1,
			wantAmount: "1",
			wantUnit:   "?",
			wantUSD:    "",
		},
	}
	// Ensure no globalPriceService leaks into these tests.
	prev := globalPriceService
	globalPriceService = nil
	t.Cleanup(func() { globalPriceService = prev })

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			got := tc.bucket.toTokenTotal(tc.chainID)
			if tc.wantNil {
				if got != nil {
					t.Errorf("expected nil, got %+v", got)
				}
				return
			}
			if got == nil {
				t.Fatalf("expected non-nil")
			}
			if got.Amount != tc.wantAmount {
				t.Errorf("Amount = %q, want %q", got.Amount, tc.wantAmount)
			}
			if got.Unit != tc.wantUnit {
				t.Errorf("Unit = %q, want %q", got.Unit, tc.wantUnit)
			}
			if got.USD != tc.wantUSD {
				t.Errorf("USD = %q, want %q", got.USD, tc.wantUSD)
			}
		})
	}
}

func mustBigInt(s string) *big.Int {
	v, _ := new(big.Int).SetString(s, 10)
	return v
}

// TestFormatTelegramFromStructured_Simulation_PlaceholderCost confirms simulation
// runs render the "(see cost estimate before deploy)" placeholder instead of fake-precision
// numbers. Sim gas prices are conservative chain defaults, so any specific ETH/gas
// figure would mislead the user.
func TestFormatTelegramFromStructured_Simulation_PlaceholderCost(t *testing.T) {
	summary := Summary{
		Subject:    "Simulation: Test Workflow successfully completed",
		Status:     "success",
		Network:    "Sepolia",
		Executions: []ExecutionEntry{{Description: "(Simulated) Transferred 0.01 ETH"}},
		Workflow:   &WorkflowInfo{IsSimulation: true},
		Runner: &RunnerInfo{
			SmartWallet: "0x8Ee38eB323c14a1752DABDA1cca9661AEE377017",
			OwnerEOA:    "0x804e49e8C4eDb560AE7c48B554f6d2e27Bb81557",
		},
		Fees: &FeesInfo{
			ExecutionFee: &FeeAmount{Amount: "0.020000", Unit: "USD"},
			Cogs: []*NodeCOGS{{
				NodeID:   "transfer1",
				StepName: "transfer1",
				CostType: "gas",
				Fee:      &FeeAmount{Amount: "10500000000000", Unit: "WEI"},
				GasUnits: "21000",
			}},
		},
	}

	out := FormatForMessageChannels(summary, "telegram", nil)

	if !strings.Contains(out, "⛽ <i>(see cost estimate before deploy)</i>") {
		t.Errorf("simulation should render the deploy-time placeholder, got:\n%s", out)
	}
	for _, banned := range []string{"<b>Cost:</b>", "0.0000105 ETH", "21 K gas", "platform fee"} {
		if strings.Contains(out, banned) {
			t.Errorf("simulation should not render %q, got:\n%s", banned, out)
		}
	}
}

// TestTruncateAddress tests the address truncation helper function
func TestTruncateAddress(t *testing.T) {
	tests := []struct {
		input    string
		expected string
	}{
		{"0x5d814Cc9E94B2656f59Ee439D44AA1b6ca21434f", "0x5d814...434f"},
		{"0xc60e71bd0f2e6d8832Fea1a2d56091C48493C788", "0xc60e7...C788"},
		{"0x1234567890abcdef1234567890abcdef12345678", "0x12345...5678"},
		{"short", "short"}, // Too short to truncate
		{"", ""},           // Empty string
	}

	for _, tt := range tests {
		t.Run(tt.input, func(t *testing.T) {
			result := truncateAddress(tt.input)
			if result != tt.expected {
				t.Errorf("truncateAddress(%q) = %q, want %q", tt.input, result, tt.expected)
			}
		})
	}
}

// TestGetBlockExplorerURL tests the block explorer URL helper function
func TestGetBlockExplorerURL(t *testing.T) {
	tests := []struct {
		name     string
		chainID  int64
		expected string
	}{
		{"ethereum", 1, "https://etherscan.io"},
		{"sepolia", 11155111, "https://sepolia.etherscan.io"},
		{"polygon", 137, "https://polygonscan.com"},
		{"arbitrum", 42161, "https://arbiscan.io"},
		{"optimism", 10, "https://optimistic.etherscan.io"},
		{"base", 8453, "https://basescan.org"},
		{"base_sepolia", 84532, "https://sepolia.basescan.org"},
		{"bsc", 56, "https://bscscan.com"},
		{"avalanche", 43114, "https://snowtrace.io"},
		{"unknown", 999999, ""},
		{"zero", 0, ""},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := getBlockExplorerURL(tt.chainID)
			if result != tt.expected {
				t.Errorf("getBlockExplorerURL(%d) = %q, want %q", tt.chainID, result, tt.expected)
			}
		})
	}
}

// TestMapNameToChainID tests the chain name to chain ID reverse mapping
func TestMapNameToChainID(t *testing.T) {
	tests := []struct {
		name     string
		expected int64
	}{
		{"Mainnet", 1},
		{"Ethereum", 1},
		{"Sepolia", 11155111},
		{"Polygon", 137},
		{"Arbitrum", 42161},
		{"Arbitrum One", 42161},
		{"Optimism", 10},
		{"Base", 8453},
		{"Base-Sepolia", 84532},
		{"BSC", 56},
		{"BNB Chain", 56},
		{"Avalanche", 43114},
		{"Unknown", 0},
		{"", 0},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := mapNameToChainID(tt.name)
			if result != tt.expected {
				t.Errorf("mapNameToChainID(%q) = %d, want %d", tt.name, result, tt.expected)
			}
		})
	}
}

// TestGetChainDisplayName tests the chain ID to display name helper function
func TestGetChainDisplayName(t *testing.T) {
	tests := []struct {
		chainID  int64
		expected string
	}{
		{1, "Ethereum"},
		{11155111, "Sepolia"},
		{137, "Polygon"},
		{42161, "Arbitrum One"},
		{10, "Optimism"},
		{8453, "Base"},
		{84532, "Base Sepolia"},
		{56, "BNB Chain"},
		{43114, "Avalanche"},
		{999999, ""}, // Unknown chain
	}

	for _, tt := range tests {
		t.Run(fmt.Sprintf("chainID_%d", tt.chainID), func(t *testing.T) {
			result := getChainDisplayName(tt.chainID)
			if result != tt.expected {
				t.Errorf("getChainDisplayName(%d) = %q, want %q", tt.chainID, result, tt.expected)
			}
		})
	}
}

// TestGetStatusEmoji tests the status emoji helper function.
// The warn variant (⚠️) is derived from (Status="success", SkippedSteps>0), not
// from a dedicated status string — that's the whole point of the new contract.
func TestGetStatusEmoji(t *testing.T) {
	tests := []struct {
		name     string
		summary  Summary
		expected string
	}{
		{"success clean", Summary{Status: "success"}, "✅"},
		{"success with skipped", Summary{Status: "success", SkippedSteps: 1}, "⚠️"},
		{"failed", Summary{Status: "failed"}, "❌"},
		{"error", Summary{Status: "error"}, "❌"},
		{"unknown", Summary{Status: "unknown"}, ""},
		{"empty", Summary{}, ""},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := getStatusEmoji(tt.summary)
			if result != tt.expected {
				t.Errorf("getStatusEmoji(%+v) = %q, want %q", tt.summary, result, tt.expected)
			}
		})
	}
}

// TestFormatSubjectWithBoldName tests that formatSubjectWithBoldName wraps the workflow name in <code> tags
func TestFormatSubjectWithBoldName(t *testing.T) {
	tests := []struct {
		name     string
		subject  string
		expected string
	}{
		{
			name:     "simulation success",
			subject:  "Simulation: My Workflow successfully completed",
			expected: "<code>Simulation: My Workflow</code> successfully completed",
		},
		{
			name:     "simulation failure",
			subject:  "Simulation: Test Workflow failed to execute",
			expected: "<code>Simulation: Test Workflow</code> failed to execute",
		},
		{
			name:     "simulation partial",
			subject:  "Simulation: Another Workflow partially executed",
			expected: "<code>Simulation: Another Workflow</code> partially executed",
		},
		{
			name:     "run number success",
			subject:  "Run #3: Payment Flow successfully completed",
			expected: "<code>Run #3: Payment Flow</code> successfully completed",
		},
		{
			name:     "run number failure",
			subject:  "Run #15: Swap Workflow failed to execute",
			expected: "<code>Run #15: Swap Workflow</code> failed to execute",
		},
		{
			name:     "no prefix success",
			subject:  "Simple Workflow successfully completed",
			expected: "<code>Simple Workflow</code> successfully completed",
		},
		{
			name:     "no prefix failure",
			subject:  "Basic Task failed to execute",
			expected: "<code>Basic Task</code> failed to execute",
		},
		{
			name:     "workflow name with special chars",
			subject:  "Simulation: Copy of Recurring Payment & Report successfully completed",
			expected: "<code>Simulation: Copy of Recurring Payment &amp; Report</code> successfully completed",
		},
		{
			name:     "run node success",
			subject:  "Run Node: My Transfer succeeded",
			expected: "<code>Run Node: My Transfer</code> succeeded",
		},
		{
			name:     "run node failure",
			subject:  "Run Node: My Transfer failed at transfer1",
			expected: "<code>Run Node: My Transfer</code> failed at transfer1",
		},
		{
			name:     "deployed workflow success",
			subject:  "My AAVE Workflow: succeeded (3 out of 3 steps)",
			expected: "<code>My AAVE Workflow</code>: succeeded (3 out of 3 steps)",
		},
		{
			name:     "deployed workflow failure",
			subject:  "My AAVE Workflow: failed at transfer1 (2 out of 3 steps)",
			expected: "<code>My AAVE Workflow</code>: failed at transfer1 (2 out of 3 steps)",
		},
		{
			name:     "unknown format - fallback to escaped",
			subject:  "Some random subject",
			expected: "Some random subject",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := formatSubjectWithBoldName(tt.subject)
			if result != tt.expected {
				t.Errorf("formatSubjectWithBoldName(%q)\n  got:  %q\n  want: %q", tt.subject, result, tt.expected)
			}
		})
	}
}

// TestComposeSummary_SimulateTaskFromClientPayload tests the deterministic path using
// the exact client payload from a SimulateTask request with settings.name as canonical source.
// Client payload:
//
//	inputVariables: {
//	    transfer1: { data: {} },
//	    balance1: { data: {} },
//	    timeTrigger: { data: {} },
//	    settings: {
//	        name: 'Test settings.name',
//	        chain: 'Sepolia',
//	        runner: '0x5d814Cc9E94B2656f59Ee439D44AA1b6ca21434f',
//	        chain_id: 11155111,
//	        recipient: '0xc60e71bd0f2e6d8832Fea1a2d56091C48493C788',
//	        token_amount: { amount: '10000000000000000', address: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', decimals: 18 }
//	    }
//	}
func TestComposeSummary_SimulateTaskFromClientPayload(t *testing.T) {
	vm := NewVM()
	vm.IsSimulation = true

	vm.mu.Lock()
	vm.vars = map[string]interface{}{
		"transfer1": map[string]interface{}{
			"data": map[string]interface{}{},
		},
		"balance1": map[string]interface{}{
			"data": map[string]interface{}{},
		},
		"timeTrigger": map[string]interface{}{
			"data": map[string]interface{}{},
		},
		"settings": map[string]interface{}{
			"name":      "Test settings.name",
			"chain":     "Sepolia",
			"runner":    "0x5d814Cc9E94B2656f59Ee439D44AA1b6ca21434f",
			"chain_id":  11155111,
			"recipient": "0xc60e71bd0f2e6d8832Fea1a2d56091C48493C788",
			"token_amount": map[string]interface{}{
				"amount":   "10000000000000000",
				"address":  "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
				"decimals": 18,
			},
		},
	}

	// Set up task nodes matching the workflow (trigger + 2 processing nodes + 1 notification node)
	vm.TaskNodes = map[string]*avsproto.TaskNode{
		"transfer1": {Id: "transfer1", Name: "transfer1"},
		"balance1":  {Id: "balance1", Name: "balance1"},
		"telegram_send": {
			Id:   "telegram_send",
			Name: "telegram_send",
			Type: avsproto.NodeType_NODE_TYPE_REST_API,
			TaskType: &avsproto.TaskNode_RestApi{
				RestApi: &avsproto.RestAPINode{
					Config: &avsproto.RestAPINode_Config{
						Url:    "https://api.telegram.org/bot123/sendMessage",
						Method: "POST",
					},
				},
			},
		},
	}
	vm.mu.Unlock()

	// Set up execution logs: cron trigger + 2 processing steps + 1 notification step
	// The notification step (telegram_send) should NOT inflate the executed count
	startTime := int64(1738051035000) // 2025-01-28T07:57:15Z in ms
	vm.ExecutionLogs = []*avsproto.Execution_Step{
		{
			Id:      "timeTrigger",
			Name:    "timeTrigger",
			Type:    "TRIGGER_TYPE_CRON",
			Success: true,
			StartAt: startTime,
		},
		{
			Id:      "balance1",
			Name:    "balance1",
			Type:    "NODE_TYPE_BALANCE",
			Success: true,
		},
		{
			Id:      "transfer1",
			Name:    "transfer1",
			Type:    "NODE_TYPE_ETH_TRANSFER",
			Success: true,
		},
		{
			Id:      "telegram_send",
			Name:    "telegram_send",
			Type:    "NODE_TYPE_REST_API",
			Success: true,
		},
	}

	summary := ComposeSummary(vm, "transfer1")

	// Verify subject uses settings.name with Simulation prefix (SimulateTask is multi-node)
	expectedSubject := "Simulation: Test settings.name successfully completed"
	if summary.Subject != expectedSubject {
		t.Errorf("Subject mismatch:\n  expected: %q\n  got:      %q", expectedSubject, summary.Subject)
	}
	// Note: This is NOT a single-node execution (has 2+ TaskNodes), so it uses "Simulation:" prefix.
	// Single-node RunNodeImmediately uses "Run Node:" prefix instead.

	// Verify step count excludes notification nodes: 3 total (trigger + balance1 + transfer1),
	// NOT 4 (which would incorrectly include telegram_send)
	expectedSummaryLine := "Your workflow 'Test settings.name' executed 3 out of 3 total steps"
	if summary.SummaryLine != expectedSummaryLine {
		t.Errorf("SummaryLine mismatch:\n  expected: %q\n  got:      %q", expectedSummaryLine, summary.SummaryLine)
	}

	// Verify status
	if summary.Status != "success" {
		t.Errorf("Status: expected %q, got %q", "success", summary.Status)
	}

	// Verify Network is populated from settings.chain
	if summary.Network != "Sepolia" {
		t.Errorf("Network: expected %q, got %q", "Sepolia", summary.Network)
	}

	// Verify Trigger is set (cron trigger with simulation prefix)
	if !strings.Contains(summary.Trigger, "(Simulated)") {
		t.Errorf("Trigger should contain '(Simulated)', got: %q", summary.Trigger)
	}
	if !strings.Contains(summary.Trigger, "Scheduled task ran") {
		t.Errorf("Trigger should contain 'Scheduled task ran', got: %q", summary.Trigger)
	}
	if !strings.Contains(summary.Trigger, "Sepolia") {
		t.Errorf("Trigger should contain 'Sepolia', got: %q", summary.Trigger)
	}

	// Verify TriggeredAt is set from the trigger step's StartAt
	if summary.TriggeredAt == "" {
		t.Error("TriggeredAt should not be empty")
	}

	// Verify Executions fallback (no CONTRACT_WRITE steps, so fallback entry is added)
	if len(summary.Executions) != 1 {
		t.Fatalf("Executions: expected 1 fallback entry, got %d: %v", len(summary.Executions), summary.Executions)
	}
	if summary.Executions[0].Description != "(Simulated) On-chain transaction successfully completed" {
		t.Errorf("Executions[0]: expected fallback entry, got: %q", summary.Executions[0].Description)
	}

	// Annotation should be empty for simulate_task (multi-node) executions
	if summary.Annotation != "" {
		t.Errorf("Annotation should be empty for simulate_task, got: %q", summary.Annotation)
	}

	// Verify Telegram formatting
	telegram := FormatForMessageChannels(summary, "telegram", nil)

	expectedTelegramContents := []string{
		"✅ <code>Simulation: Test settings.name</code> successfully completed",
		"<b>Runner:</b> ", // chain qualifier folded onto Runner line — see formatTelegramFromStructured
		" on Sepolia",
		"<b>Time:</b>",
		"<b>Trigger:</b> (Simulated) Scheduled task ran on Sepolia",
		"<b>Executed:</b>",
		"• (Simulated) On-chain transaction successfully completed",
	}
	for _, expected := range expectedTelegramContents {
		if !strings.Contains(telegram, expected) {
			t.Errorf("Telegram output missing %q\nFull output:\n%s", expected, telegram)
		}
	}

	// Standalone Network line should NOT render — chain is folded into Runner.
	if strings.Contains(telegram, "<b>Network:</b>") {
		t.Errorf("standalone Network line should not render when Runner is present, got:\n%s", telegram)
	}

	// The simulation Cost placeholder uses italic text; allow that but no other italics.
	if strings.Contains(telegram, "<i>") && !strings.Contains(telegram, "<i>(see cost estimate before deploy)</i>") {
		t.Errorf("Telegram should not contain italic annotation other than the cost placeholder, got:\n%s", telegram)
	}

	t.Logf("Subject: %s", summary.Subject)
	t.Logf("Status: %s", summary.Status)
	t.Logf("Network: %s", summary.Network)
	t.Logf("Trigger: %s", summary.Trigger)
	t.Logf("TriggeredAt: %s", summary.TriggeredAt)
	t.Logf("Executions: %v", summary.Executions)
	t.Logf("Telegram:\n%s", telegram)
}

// TestComposeSummary_RunNodeImmediateSubjectPrefix tests that single-node
// RunNodeImmediately executions use "Run Node:" prefix, not "Simulation:".
func TestComposeSummary_RunNodeImmediateSubjectPrefix(t *testing.T) {
	vm := NewVM()
	// RunNodeImmediately: no TaskID, exactly one TaskNode
	vm.mu.Lock()
	vm.TaskNodes = map[string]*avsproto.TaskNode{
		"transfer1": {Id: "transfer1", Name: "transfer1"},
	}
	vm.vars = map[string]interface{}{
		"settings": map[string]interface{}{
			"name":     "My Transfer Workflow",
			"chain":    "Sepolia",
			"chain_id": 11155111,
		},
	}
	vm.mu.Unlock()

	vm.ExecutionLogs = []*avsproto.Execution_Step{
		{
			Id:      "transfer1",
			Name:    "transfer1",
			Type:    "NODE_TYPE_ETH_TRANSFER",
			Success: true,
		},
	}

	summary := ComposeSummary(vm, "transfer1")

	// Should use "Run Node:" prefix, not "Simulation:"
	expectedSubject := "Run Node: My Transfer Workflow succeeded"
	if summary.Subject != expectedSubject {
		t.Errorf("Subject mismatch:\n  expected: %q\n  got:      %q", expectedSubject, summary.Subject)
	}

	// Network should be populated
	if summary.Network != "Sepolia" {
		t.Errorf("Network: expected %q, got %q", "Sepolia", summary.Network)
	}

	// SummaryLine should say "1 out of 1" (not "0 out of 1")
	expectedSummaryLine := "Your workflow 'My Transfer Workflow' executed 1 out of 1 total steps"
	if summary.SummaryLine != expectedSummaryLine {
		t.Errorf("SummaryLine mismatch:\n  expected: %q\n  got:      %q", expectedSummaryLine, summary.SummaryLine)
	}

	// Annotation should be set for single-node runs
	if summary.Annotation == "" {
		t.Error("Annotation should be set for single-node RunNodeImmediately executions")
	}
	if !strings.Contains(summary.Annotation, "This is an example") {
		t.Errorf("Annotation should contain example disclaimer, got: %q", summary.Annotation)
	}

	t.Logf("Subject: %s", summary.Subject)
	t.Logf("Network: %s", summary.Network)
	t.Logf("SummaryLine: %s", summary.SummaryLine)
	t.Logf("Annotation: %s", summary.Annotation)
}

// TestIsValidTxHash tests the Ethereum tx hash validation helper
func TestIsValidTxHash(t *testing.T) {
	tests := []struct {
		name     string
		hash     string
		expected bool
	}{
		{"valid_hash", "0xdef456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0", true},
		{"valid_hash_uppercase", "0xDEF456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0", true},
		{"valid_hash_mixed", "0xAbCdEf0123456789abcdef0123456789AbCdEf0123456789abcdef0123456789", true},
		{"empty", "", false},
		{"no_prefix", "def456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0a", false},
		{"too_short", "0x1234", false},
		{"too_long", "0xdef456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0a", false},
		{"non_hex_chars", "0xggg456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0", false},
		{"bigint_simulation_id", "0x0000000000000000000000000000000000000000000001769651703156844000", true}, // 64 hex chars, format-valid (caught by isStepSimulated instead)
		{"just_0x", "0x", false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := isValidTxHash(tt.hash)
			if result != tt.expected {
				t.Errorf("isValidTxHash(%q) = %v, want %v (len=%d)", tt.hash, result, tt.expected, len(tt.hash))
			}
		})
	}
}

// TestIsStepSimulated tests the per-step simulation detection helper
func TestIsStepSimulated(t *testing.T) {
	// Helper to create ExecutionContext structpb.Value
	makeCtx := func(m map[string]interface{}) *structpb.Value {
		v, _ := structpb.NewValue(m)
		return v
	}

	tests := []struct {
		name     string
		step     *avsproto.Execution_Step
		expected bool
	}{
		{
			"nil_context",
			&avsproto.Execution_Step{},
			false,
		},
		{
			"snake_case_true",
			&avsproto.Execution_Step{
				ExecutionContext: makeCtx(map[string]interface{}{
					"is_simulated": true,
					"provider":     "tenderly",
				}),
			},
			true,
		},
		{
			"snake_case_false",
			&avsproto.Execution_Step{
				ExecutionContext: makeCtx(map[string]interface{}{
					"is_simulated": false,
					"provider":     "chain_rpc",
				}),
			},
			false,
		},
		{
			"camel_case_true",
			&avsproto.Execution_Step{
				ExecutionContext: makeCtx(map[string]interface{}{
					"isSimulated": true,
					"provider":    "tenderly",
				}),
			},
			true,
		},
		{
			"camel_case_false",
			&avsproto.Execution_Step{
				ExecutionContext: makeCtx(map[string]interface{}{
					"isSimulated": false,
					"provider":    "chain_rpc",
				}),
			},
			false,
		},
		{
			"no_simulated_key",
			&avsproto.Execution_Step{
				ExecutionContext: makeCtx(map[string]interface{}{
					"provider": "chain_rpc",
				}),
			},
			false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := isStepSimulated(tt.step)
			if result != tt.expected {
				t.Errorf("isStepSimulated() = %v, want %v", result, tt.expected)
			}
		})
	}
}

// TestBuildExecutionsArray_SkipsSimulatedTxHash verifies that buildExecutionsArray
// does not attach txHash for simulated steps or invalid tx hashes
func TestBuildExecutionsArray_SkipsSimulatedTxHash(t *testing.T) {
	makeCtx := func(isSimulated bool) *structpb.Value {
		v, _ := structpb.NewValue(map[string]interface{}{
			"is_simulated": isSimulated,
			"provider":     "tenderly",
		})
		return v
	}

	validTxHash := "0xdef456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0"
	malformedHash := "0x1234" // too short to be valid

	// Metadata with valid tx hash
	validMeta, _ := structpb.NewValue(map[string]interface{}{
		"transactionHash": validTxHash,
	})
	// Metadata with malformed hash (wrong length)
	malformedMeta, _ := structpb.NewValue(map[string]interface{}{
		"transactionHash": malformedHash,
	})

	// Contract write config with callData
	writeConfig, _ := structpb.NewValue(map[string]interface{}{
		"contractAddress": "0x1234567890abcdef1234567890abcdef12345678",
		"callData":        "transfer(address,uint256)",
	})

	vm := NewVM()
	vm.IsSimulation = true
	vm.ExecutionLogs = []*avsproto.Execution_Step{
		{
			Id: "step1", Name: "transfer_real", Type: avsproto.NodeType_NODE_TYPE_CONTRACT_WRITE.String(),
			Success:          true,
			Config:           writeConfig,
			Metadata:         validMeta,
			ExecutionContext: makeCtx(false), // real execution
		},
		{
			Id: "step2", Name: "transfer_simulated", Type: avsproto.NodeType_NODE_TYPE_CONTRACT_WRITE.String(),
			Success:          true,
			Config:           writeConfig,
			Metadata:         validMeta,
			ExecutionContext: makeCtx(true), // simulated — should skip txHash
		},
		{
			Id: "step3", Name: "transfer_malformed_hash", Type: avsproto.NodeType_NODE_TYPE_CONTRACT_WRITE.String(),
			Success:          true,
			Config:           writeConfig,
			Metadata:         malformedMeta,
			ExecutionContext: makeCtx(false), // real but malformed hash — should skip txHash
		},
	}

	executions := buildExecutionsArray(vm)

	if len(executions) != 3 {
		t.Fatalf("Expected 3 executions, got %d", len(executions))
	}

	// Step 1: real execution, valid hash → should have txHash
	if executions[0].TxHash != validTxHash {
		t.Errorf("Step 1 (real, valid hash): expected txHash=%q, got %q", validTxHash, executions[0].TxHash)
	}

	// Step 2: simulated → should NOT have txHash
	if executions[1].TxHash != "" {
		t.Errorf("Step 2 (simulated): expected empty txHash, got %q", executions[1].TxHash)
	}

	// Step 3: real but malformed hash → should NOT have txHash
	if executions[2].TxHash != "" {
		t.Errorf("Step 3 (real, malformed hash): expected empty txHash, got %q", executions[2].TxHash)
	}
}

func TestFormatBackticksToHTML(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected string
	}{
		{
			name:     "no backticks",
			input:    "loop1 - skipped due to branch condition",
			expected: "loop1 - skipped due to branch condition",
		},
		{
			name:     "single backtick expression",
			input:    "condition not met: `balance >= totalNeeded` evaluated to false",
			expected: "condition not met: <code>balance &gt;= totalNeeded</code> evaluated to false",
		},
		{
			name:     "multiple backtick expressions",
			input:    "`code1.data.balance` is less than `code1.data.totalNeeded`",
			expected: "<code>code1.data.balance</code> is less than <code>code1.data.totalNeeded</code>",
		},
		{
			name:     "unclosed backtick passes through",
			input:    "missing closing `backtick",
			expected: "missing closing `backtick",
		},
		{
			name:     "HTML chars outside backticks are escaped",
			input:    "value <foo> with `expr >= 0` end",
			expected: "value &lt;foo&gt; with <code>expr &gt;= 0</code> end",
		},
		{
			name:     "empty backticks",
			input:    "empty `` expression",
			expected: "empty <code></code> expression",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := formatBackticksToHTML(tt.input)
			if got != tt.expected {
				t.Errorf("formatBackticksToHTML(%q)\n  got:  %q\n  want: %q", tt.input, got, tt.expected)
			}
		})
	}
}

func TestFormatBackticksForChannel(t *testing.T) {
	input := "condition: `x >= y` failed"
	expectedHTML := "condition: <code>x &gt;= y</code> failed"

	// Telegram and email should convert backticks to <code> with proper escaping
	for _, ch := range []string{"telegram", "email"} {
		got := formatBackticksForChannel(input, ch)
		if got != expectedHTML {
			t.Errorf("channel %q:\n  got:  %q\n  want: %q", ch, got, expectedHTML)
		}
	}

	// Discord and plaintext should pass through as-is
	for _, ch := range []string{"discord", "plaintext", ""} {
		got := formatBackticksForChannel(input, ch)
		if got != input {
			t.Errorf("channel %q: expected pass-through, got %q", ch, got)
		}
	}
}

func TestBuildStatusHtml(t *testing.T) {
	tests := []struct {
		name      string
		summary   Summary
		wantColor string
		wantText  string
	}{
		{"success clean", Summary{Status: "success"}, "#D1FAE5", "All steps completed successfully"},
		{"success with skipped uses skippedNote", Summary{Status: "success", SkippedSteps: 1, SkippedNote: "1 node was skipped by Branch condition."}, "#FEF3C7", "1 node was skipped by Branch condition."},
		{"failed", Summary{Status: "failed"}, "#FEE2E2", "Execution failed"},
		{"error", Summary{Status: "error"}, "#FEE2E2", "System error"},
		{"default", Summary{}, "#D1FAE5", "Completed"},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			html := buildStatusHtml(tt.summary)
			if !strings.Contains(html, tt.wantColor) {
				t.Errorf("buildStatusHtml(%+v): expected color %q in output:\n%s", tt.summary, tt.wantColor, html)
			}
			if !strings.Contains(html, tt.wantText) {
				t.Errorf("buildStatusHtml(%+v): expected text %q in output:\n%s", tt.summary, tt.wantText, html)
			}
		})
	}
}