step_test.go

package probe

import (
	"fmt"
	"strings"
	"sync"
	"testing"
	"time"

	"github.com/fatih/color"
)

func TestStep_parseWaitDuration(t *testing.T) {
	tests := []struct {
		name     string
		wait     string
		expected time.Duration
		hasError bool
	}{
		{
			name:     "seconds as integer string",
			wait:     "5",
			expected: 5 * time.Second,
			hasError: false,
		},
		{
			name:     "duration string with seconds",
			wait:     "3s",
			expected: 3 * time.Second,
			hasError: false,
		},
		{
			name:     "duration string with milliseconds",
			wait:     "500ms",
			expected: 500 * time.Millisecond,
			hasError: false,
		},
		{
			name:     "duration string with minutes",
			wait:     "2m",
			expected: 2 * time.Minute,
			hasError: false,
		},
		{
			name:     "invalid format",
			wait:     "invalid",
			expected: 0,
			hasError: true,
		},
		{
			name:     "empty string",
			wait:     "",
			expected: 0,
			hasError: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			step := &Step{}
			duration, err := step.parseWaitDuration(tt.wait)

			if tt.hasError {
				if err == nil {
					t.Errorf("expected error for wait '%s', but got none", tt.wait)
				}
			} else {
				if err != nil {
					t.Errorf("unexpected error for wait '%s': %v", tt.wait, err)
				}
				if duration != tt.expected {
					t.Errorf("expected %v, got %v", tt.expected, duration)
				}
			}
		})
	}
}

func TestStep_formatWaitTime(t *testing.T) {
	tests := []struct {
		name     string
		duration time.Duration
		expected string
	}{
		{
			name:     "exact seconds",
			duration: 5 * time.Second,
			expected: "5s",
		},
		{
			name:     "milliseconds",
			duration: 500 * time.Millisecond,
			expected: "500ms",
		},
		{
			name:     "mixed duration",
			duration: 2*time.Minute + 30*time.Second,
			expected: "150s",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			step := &Step{}
			result := step.formatWaitTime(tt.duration)
			if result != tt.expected {
				t.Errorf("expected %s, got %s", tt.expected, result)
			}
		})
	}
}

func TestStep_getWaitTimeForDisplay(t *testing.T) {
	tests := []struct {
		name     string
		wait     string
		expected string
	}{
		{
			name:     "no wait",
			wait:     "",
			expected: "",
		},
		{
			name:     "seconds",
			wait:     "5",
			expected: "5s",
		},
		{
			name:     "duration string",
			wait:     "500ms",
			expected: "500ms",
		},
		{
			name:     "invalid format returns empty",
			wait:     "invalid",
			expected: "",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			step := &Step{Wait: tt.wait}
			result := step.getWaitTimeForDisplay()
			if result != tt.expected {
				t.Errorf("expected %s, got %s", tt.expected, result)
			}
		})
	}
}

func TestStep_handleWait(t *testing.T) {
	tests := []struct {
		name         string
		wait         string
		expectedTime string
		minDuration  time.Duration
		maxDuration  time.Duration
	}{
		{
			name:         "no wait",
			wait:         "",
			expectedTime: "",
			minDuration:  0,
			maxDuration:  10 * time.Millisecond,
		},
		{
			name:         "short wait",
			wait:         "10ms",
			expectedTime: "10ms",
			minDuration:  8 * time.Millisecond,
			maxDuration:  50 * time.Millisecond,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			step := &Step{Wait: tt.wait}
			jCtx := &JobContext{
				Printer: &Printer{},
			}

			start := time.Now()
			step.handleWait(jCtx)
			duration := time.Since(start)

			// Skip expectedTime check for empty wait case
			if tt.wait != "" {
				expectedDuration, _ := time.ParseDuration(tt.expectedTime)
				if duration < expectedDuration {
					t.Errorf("expected at least %s, got %s", expectedDuration, duration)
				}
			}

			if duration < tt.minDuration {
				t.Errorf("Duration %v should be at least %v", duration, tt.minDuration)
			}

			if duration > tt.maxDuration {
				t.Errorf("Duration %v should not exceed %v", duration, tt.maxDuration)
			}
		})
	}
}

func TestStep_SkipIfWithWaitTiming(t *testing.T) {
	tests := []struct {
		name        string
		wait        string
		skipif      string
		expectSkip  bool
		maxDuration time.Duration
		minDuration time.Duration
	}{
		{
			name:        "skipped step with wait should not wait",
			wait:        "1s",
			skipif:      "true",
			expectSkip:  true,
			maxDuration: 50 * time.Millisecond, // Should be very fast since no wait
			minDuration: 0,
		},
		{
			name:        "non-skipped step with wait should wait",
			wait:        "100ms",
			skipif:      "false",
			expectSkip:  false,
			maxDuration: 200 * time.Millisecond, // Allow some overhead
			minDuration: 80 * time.Millisecond,  // Should wait at least this long
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			step := &Step{
				Name:   "Test Step",
				Uses:   "hello",
				Wait:   tt.wait,
				SkipIf: tt.skipif,
				Expr:   &Expr{},
			}

			jCtx := &JobContext{
				Printer: newBufferPrinter(), // Silent printer
				Config:  Config{},
			}

			start := time.Now()
			name, shouldContinue := step.prepare(jCtx)
			duration := time.Since(start)

			// Check skip behavior
			if tt.expectSkip && shouldContinue {
				t.Errorf("Expected step to be skipped (shouldContinue=false), got shouldContinue=%v", shouldContinue)
			}
			if !tt.expectSkip && !shouldContinue {
				t.Errorf("Expected step to continue (shouldContinue=true), got shouldContinue=%v", shouldContinue)
			}

			// Check timing
			if duration > tt.maxDuration {
				t.Errorf("Expected duration <= %v, got %v", tt.maxDuration, duration)
			}
			if duration < tt.minDuration {
				t.Errorf("Expected duration >= %v, got %v", tt.minDuration, duration)
			}

			if name != "Test Step" {
				t.Errorf("Expected step name 'Test Step', got %v", name)
			}
		})
	}
}

func TestStep_shouldSkip(t *testing.T) {
	tests := []struct {
		name     string
		skipif   string
		context  StepContext
		expected bool
		hasError bool
	}{
		{
			name:     "no skipif condition",
			skipif:   "",
			context:  StepContext{},
			expected: false,
			hasError: false,
		},
		{
			name:   "skipif returns true",
			skipif: "true",
			context: StepContext{
				Vars: map[string]any{},
			},
			expected: true,
			hasError: false,
		},
		{
			name:   "skipif returns false",
			skipif: "false",
			context: StepContext{
				Vars: map[string]any{},
			},
			expected: false,
			hasError: false,
		},
		{
			name:   "skipif with variable condition - skip",
			skipif: `vars.env == "production"`,
			context: StepContext{
				Vars: map[string]any{
					"env": "production",
				},
			},
			expected: true,
			hasError: false,
		},
		{
			name:   "skipif with variable condition - don't skip",
			skipif: `vars.env == "production"`,
			context: StepContext{
				Vars: map[string]any{
					"env": "development",
				},
			},
			expected: false,
			hasError: false,
		},
		{
			name:   "skipif with empty variable condition",
			skipif: `vars.url == ""`,
			context: StepContext{
				Vars: map[string]any{
					"url": "",
				},
			},
			expected: true,
			hasError: false,
		},
		{
			name:   "skipif with contains condition",
			skipif: `vars.url contains "production"`,
			context: StepContext{
				Vars: map[string]any{
					"url": "https://production.example.com",
				},
			},
			expected: true,
			hasError: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			step := &Step{
				SkipIf: tt.skipif,
				ctx:    tt.context,
				Expr:   &Expr{},
			}
			jCtx := &JobContext{
				Printer: &Printer{},
			}

			result := step.shouldSkip(jCtx)
			if result != tt.expected {
				t.Errorf("shouldSkip() = %v, want %v", result, tt.expected)
			}
		})
	}
}

func TestStep_createSkippedStepResult(t *testing.T) {
	step := &Step{
		Idx:  1,
		Wait: "2s",
	}
	jCtx := &JobContext{}
	name := "Test Step"

	result := step.createSkippedStepResult(name, jCtx, nil)

	if result.Index != 1 {
		t.Errorf("Index = %v, want %v", result.Index, 1)
	}
	if result.Name != "Test Step (SKIPPED)" {
		t.Errorf("Name = %v, want %v", result.Name, "Test Step (SKIPPED)")
	}
	if result.Status != StatusSkipped {
		t.Errorf("Status = %v, want %v", result.Status, StatusSkipped)
	}
	if result.WaitTime != "2s" {
		t.Errorf("WaitTime = %v, want %v", result.WaitTime, "2s")
	}
	if result.HasTest != false {
		t.Errorf("HasTest = %v, want %v", result.HasTest, false)
	}
	if result.RepeatCounter != nil {
		t.Errorf("RepeatCounter should be nil for non-repeat step, got %v", result.RepeatCounter)
	}
}

func TestStep_createSkippedStepResult_WithRepeatCounter(t *testing.T) {
	step := &Step{
		Idx:  1,
		Wait: "2s",
	}
	jCtx := &JobContext{}
	name := "Test Step"
	counter := &StepRepeatCounter{
		SuccessCount: 5,
		FailureCount: 2,
		Name:         "Test Counter",
		LastResult:   true,
	}

	result := step.createSkippedStepResult(name, jCtx, counter)

	if result.RepeatCounter == nil {
		t.Error("RepeatCounter should not be nil when provided")
	}
	if result.RepeatCounter != counter {
		t.Error("RepeatCounter should be the same instance that was passed")
	}
	if result.RepeatCounter.SuccessCount != 5 {
		t.Errorf("RepeatCounter.SuccessCount = %v, want %v", result.RepeatCounter.SuccessCount, 5)
	}
}

func TestStep_createStepResult_WithRepeatCounter(t *testing.T) {
	step := &Step{
		Idx:  1,
		Test: "res.status == 200",
		Echo: "Hello World",
		Wait: "1s",
		Expr: &Expr{},
		ctx: StepContext{
			Res: map[string]any{"status": 200},
			RT: ResponseTime{
				Duration: "250ms",
				Sec:      0.25,
			},
		},
	}
	jCtx := &JobContext{
		Config:  Config{RT: true},
		Printer: newBufferPrinter(),
	}
	name := "Test Step"
	counter := &StepRepeatCounter{
		SuccessCount: 3,
		FailureCount: 1,
		Name:         "Test Counter",
		LastResult:   true,
	}

	result := step.createStepResult(name, jCtx, counter)

	if result.RepeatCounter == nil {
		t.Error("RepeatCounter should not be nil when provided")
	}
	if result.RepeatCounter != counter {
		t.Error("RepeatCounter should be the same instance that was passed")
	}
	if result.RepeatCounter.SuccessCount != 3 {
		t.Errorf("RepeatCounter.SuccessCount = %v, want %v", result.RepeatCounter.SuccessCount, 3)
	}
	if result.RT != "250ms" {
		t.Errorf("RT = %v, want %v", result.RT, "250ms")
	}
	if result.RTSec != 0.25 {
		t.Errorf("RTSec = %v, want %v", result.RTSec, 0.25)
	}
}

func TestStep_createFailedStepResult(t *testing.T) {
	testErr := fmt.Errorf("test error message")
	step := &Step{
		Idx:  2,
		Test: "res.code == 200",
		Wait: "3s",
		err:  testErr,
		ctx: StepContext{
			RT: ResponseTime{
				Duration: "500ms",
				Sec:      0.5,
			},
			Res: map[string]any{"report": "HTTP error occurred"},
		},
	}
	jCtx := &JobContext{
		Config: Config{RT: true},
	}
	name := "Failed Step"

	result := step.createFailedStepResult(name, jCtx, nil)

	if result.Index != 2 {
		t.Errorf("Index = %v, want %v", result.Index, 2)
	}
	if result.Name != "Failed Step" {
		t.Errorf("Name = %v, want %v", result.Name, "Failed Step")
	}
	if result.Status != StatusError {
		t.Errorf("Status = %v, want %v", result.Status, StatusError)
	}
	if result.WaitTime != "3s" {
		t.Errorf("WaitTime = %v, want %v", result.WaitTime, "3s")
	}
	if result.HasTest != true {
		t.Errorf("HasTest = %v, want %v", result.HasTest, true)
	}
	if result.RT != "500ms" {
		t.Errorf("RT = %v, want %v", result.RT, "500ms")
	}
	if result.RTSec != 0.5 {
		t.Errorf("RTSec = %v, want %v", result.RTSec, 0.5)
	}
	if result.Report != "HTTP error occurred" {
		t.Errorf("Report = %v, want %v", result.Report, "HTTP error occurred")
	}
	if result.TestOutput != "test error message" {
		t.Errorf("TestOutput = %v, want %v", result.TestOutput, "test error message")
	}
	if result.RepeatCounter != nil {
		t.Errorf("RepeatCounter should be nil for non-repeat step, got %v", result.RepeatCounter)
	}
}

func TestStep_createFailedStepResult_WithRepeatCounter(t *testing.T) {
	testErr := fmt.Errorf("connection timeout")
	step := &Step{
		Idx:  3,
		Test: "res.status < 400",
		Wait: "1s",
		err:  testErr,
		ctx: StepContext{
			RT: ResponseTime{
				Duration: "10s",
				Sec:      10.0,
			},
		},
	}
	jCtx := &JobContext{
		Config: Config{RT: true},
	}
	name := "Timeout Step"
	counter := &StepRepeatCounter{
		SuccessCount: 1,
		FailureCount: 4,
		Name:         "Timeout Counter",
		LastResult:   false,
	}

	result := step.createFailedStepResult(name, jCtx, counter)

	if result.RepeatCounter == nil {
		t.Error("RepeatCounter should not be nil when provided")
	}
	if result.RepeatCounter != counter {
		t.Error("RepeatCounter should be the same instance that was passed")
	}
	if result.RepeatCounter.FailureCount != 4 {
		t.Errorf("RepeatCounter.FailureCount = %v, want %v", result.RepeatCounter.FailureCount, 4)
	}
	if result.Status != StatusError {
		t.Errorf("Status = %v, want %v", result.Status, StatusError)
	}
	if result.TestOutput != "connection timeout" {
		t.Errorf("TestOutput = %v, want %v", result.TestOutput, "connection timeout")
	}
}

func TestStep_createFailedStepResult_NoTest(t *testing.T) {
	step := &Step{
		Idx: 1,
		// No Test field
		ctx: StepContext{},
	}
	jCtx := &JobContext{}
	name := "No Test Step"

	result := step.createFailedStepResult(name, jCtx, nil)

	if result.HasTest != false {
		t.Errorf("HasTest = %v, want %v", result.HasTest, false)
	}
	if result.TestOutput != "" {
		t.Errorf("TestOutput = %v, want empty string", result.TestOutput)
	}
}

// Tests for refactored methods

func TestStep_prepare(t *testing.T) {
	tests := []struct {
		name           string
		stepName       string
		wait           string
		skipif         string
		skipCondition  map[string]any
		expectName     string
		expectContinue bool
		expectError    bool
	}{
		{
			name:           "normal step preparation",
			stepName:       "Test Step",
			wait:           "",
			skipif:         "",
			expectName:     "Test Step",
			expectContinue: true,
			expectError:    false,
		},
		{
			name:           "empty name gets default",
			stepName:       "",
			wait:           "",
			skipif:         "",
			expectName:     "Unknown Step",
			expectContinue: true,
			expectError:    false,
		},
		{
			name:           "step with wait",
			stepName:       "Wait Step",
			wait:           "10ms",
			skipif:         "",
			expectName:     "Wait Step",
			expectContinue: true,
			expectError:    false,
		},
		{
			name:           "skipped step",
			stepName:       "Skipped Step",
			wait:           "",
			skipif:         "true",
			expectName:     "Skipped Step",
			expectContinue: false,
			expectError:    false,
		},
		{
			name:           "step with conditional skip - skip",
			stepName:       "Conditional Step",
			wait:           "",
			skipif:         `vars.env == "test"`,
			skipCondition:  map[string]any{"env": "test"},
			expectName:     "Conditional Step",
			expectContinue: false,
			expectError:    false,
		},
		{
			name:           "step with conditional skip - continue",
			stepName:       "Conditional Step",
			wait:           "",
			skipif:         `vars.env == "test"`,
			skipCondition:  map[string]any{"env": "prod"},
			expectName:     "Conditional Step",
			expectContinue: true,
			expectError:    false,
		},
		{
			name:           "skipped step with wait should not wait",
			stepName:       "Skipped Wait Step",
			wait:           "2s",
			skipif:         "true",
			expectName:     "Skipped Wait Step",
			expectContinue: false,
			expectError:    false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			step := &Step{
				Name:   tt.stepName,
				Wait:   tt.wait,
				SkipIf: tt.skipif,
				Expr:   &Expr{},
			}

			// Set up context
			vars := tt.skipCondition
			if vars == nil {
				vars = map[string]any{}
			}
			step.ctx = StepContext{
				Vars: vars,
			}

			jCtx := &JobContext{
				Printer: newBufferPrinter(), // Use silent printer to avoid output during tests
			}

			name, shouldContinue := step.prepare(jCtx)

			if name != tt.expectName {
				t.Errorf("prepare() name = %v, want %v", name, tt.expectName)
			}
			if shouldContinue != tt.expectContinue {
				t.Errorf("prepare() shouldContinue = %v, want %v", shouldContinue, tt.expectContinue)
			}
		})
	}
}

func TestStep_executeAction(t *testing.T) {
	t.Run("with mock runner", func(t *testing.T) {
		step := &Step{
			Uses: "http",
			With: map[string]any{"url": "http://example.com"},
			Expr: &Expr{},
		}

		// Set up mock runner
		mock := NewMockActionRunner()
		mock.SetResult("http", map[string]any{
			"code": 0,
			"results": map[string]any{
				"status": 200,
				"body":   "OK",
			},
		})
		step.actionRunner = mock

		// Create minimal job context
		jCtx := &JobContext{
			Config: Config{Verbose: false},
		}

		// Initialize step context
		step.ctx = StepContext{}

		// Execute action
		result, err := step.executeAction("Test Step", jCtx)
		if err != nil {
			t.Errorf("Expected no error, got %v", err)
		}

		if result["code"] != 0 {
			t.Errorf("Expected code=0, got %v", result["code"])
		}

		results, ok := result["results"].(map[string]any)
		if !ok {
			t.Errorf("Expected results to be map[string]any")
		} else {
			if results["status"] != 200 {
				t.Errorf("Expected status=200, got %v", results["status"])
			}
		}
	})

	t.Run("with mock runner error", func(t *testing.T) {
		step := &Step{
			Uses: "failing-action",
			With: map[string]any{},
			Expr: &Expr{},
		}

		// Set up mock runner with error
		mock := NewMockActionRunner()
		testErr := fmt.Errorf("connection failed")
		mock.SetError("failing-action", testErr)
		step.actionRunner = mock

		// Create minimal job context
		jCtx := &JobContext{
			Config: Config{Verbose: false},
		}

		// Initialize step context
		step.ctx = StepContext{}

		// Execute action - should return error
		result, err := step.executeAction("Test Step", jCtx)
		if err != testErr {
			t.Errorf("Expected test error, got %v", err)
		}
		if result != nil {
			t.Errorf("Expected nil result on error, got %v", result)
		}
	})

	t.Run("uses default plugin runner when none set", func(t *testing.T) {
		step := &Step{
			Uses: "test-action",
			With: map[string]any{},
			Expr: &Expr{},
		}
		// Don't set actionRunner - should use default PluginActionRunner

		// Initialize step context
		step.ctx = StepContext{}

		// We can't actually test plugin execution, but we can verify
		// the method handles the default case without panicking
		// This will timeout in CI/CD, but verifies the code path exists
		var methodFunc = step.executeAction
		_ = methodFunc

		t.Logf("executeAction() default case verified successfully")
	})
}

func TestStep_processActionResult(t *testing.T) {
	tests := []struct {
		name         string
		actionResult map[string]any
		expectLogs   int
	}{
		{
			name: "normal action result",
			actionResult: map[string]any{
				"req": map[string]any{"url": "http://example.com"},
				"res": map[string]any{"status": 200, "body": "response"},
				"rt":  "100ms",
			},
			expectLogs: 1,
		},
		{
			name: "action result with JSON body",
			actionResult: map[string]any{
				"req": map[string]any{"url": "http://example.com"},
				"res": map[string]any{
					"status": 200,
					"body":   `{"message": "success"}`,
				},
				"rt": "150ms",
			},
			expectLogs: 1,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			step := &Step{
				Expr: &Expr{},
			}

			jCtx := &JobContext{}

			step.processActionResult(tt.actionResult, jCtx)
		})
	}
}

func TestStep_handleActionError(t *testing.T) {
	step := &Step{
		Uses: "mock-action-for-error-test",
		Expr: &Expr{},
	}

	jCtx := &JobContext{
		Printer: newBufferPrinter(),
	}

	originalErr := fmt.Errorf("test error")
	step.handleActionError(originalErr, "test-step", jCtx)

	// Check that error was set
	if step.err == nil {
		t.Errorf("handleActionError() should set step.err")
	}

	// Check that job was marked as failed
	if !jCtx.Failed {
		t.Errorf("handleActionError() should mark job as failed")
	}

	// Check error details
	if probeErr, ok := step.err.(*ProbeError); ok {
		if probeErr.Context["step_name"] != "test-step" {
			t.Errorf("handleActionError() should set step_name context")
		}
		if probeErr.Context["action_type"] != "mock-action-for-error-test" {
			t.Errorf("handleActionError() should set action_type context")
		}
	} else {
		t.Errorf("handleActionError() should create ProbeError")
	}
}

func TestStep_finalize(t *testing.T) {
	tests := []struct {
		name         string
		verbose      bool
		isRepeating  bool
		actionResult map[string]any
		expectCalled string // "verbose", "repeat", or "standard"
	}{
		{
			name:        "verbose mode",
			verbose:     true,
			isRepeating: false,
			actionResult: map[string]any{
				"req": map[string]any{"url": "http://example.com"},
				"res": map[string]any{"status": 200},
				"rt":  "100ms",
			},
			expectCalled: "verbose",
		},
		{
			name:        "repeat mode",
			verbose:     false,
			isRepeating: true,
			actionResult: map[string]any{
				"req": map[string]any{"url": "http://example.com"},
				"res": map[string]any{"status": 200},
				"rt":  "100ms",
			},
			expectCalled: "repeat",
		},
		{
			name:        "standard mode",
			verbose:     false,
			isRepeating: false,
			actionResult: map[string]any{
				"req": map[string]any{"url": "http://example.com"},
				"res": map[string]any{"status": 200},
				"rt":  "100ms",
			},
			expectCalled: "standard",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			step := &Step{
				Expr: &Expr{},
			}

			jCtx := &JobContext{
				Config: Config{
					Verbose: tt.verbose,
				},
				IsRepeating:  tt.isRepeating,
				Printer:      newBufferPrinter(),
				StepCounters: make(map[int]StepRepeatCounter),
				countersMu:   &sync.Mutex{},
			}

			// Note: This test mainly verifies that the correct code path is taken
			// More detailed testing of each path should be done in their specific test functions
			step.finalize("test-step", tt.actionResult, jCtx)

			// For now, we just verify the method doesn't panic
			// In a more complete test, we might track which methods were called
		})
	}
}

// Integration test for the refactored Do() method
func TestStep_Do_Integration(t *testing.T) {
	t.Run("step with skip condition", func(t *testing.T) {
		step := Step{
			Name:   "Skipped Step",
			Uses:   "", // Empty action since this step should be skipped anyway
			SkipIf: "true",
			Expr:   &Expr{},
		}

		step.ctx = StepContext{
			Vars: map[string]any{},
		}

		jobContext := JobContext{
			Printer: newBufferPrinter(),
		}

		// Execute the step (should be skipped)
		step.Do(&jobContext)

		// Since step is skipped, job should not fail
		if jobContext.Failed {
			t.Errorf("Do() with skip condition should not fail the job")
		}
	})

	t.Run("successful step execution with mock", func(t *testing.T) {
		step := Step{
			Name: "Test Step",
			Uses: "http",
			With: map[string]any{"url": "http://example.com"},
			Expr: &Expr{},
		}

		// Set up mock runner for successful execution
		mock := NewMockActionRunner()
		mock.SetResult("http", map[string]any{
			"code": 0,
			"results": map[string]any{
				"status": 200,
				"body":   "Success",
			},
			"rt": "100ms",
		})
		step.actionRunner = mock

		step.ctx = StepContext{
			Vars: map[string]any{},
		}

		jobContext := JobContext{
			Config:  Config{Verbose: false},
			Printer: newBufferPrinter(),
		}

		// Execute the step
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Do() method panicked: %v", r)
			}
		}()

		step.Do(&jobContext)

		// Verify successful execution
		if jobContext.Failed {
			t.Errorf("Do() with successful mock should not fail the job")
		}

		// Verify context was updated
		if step.ctx.RT.Duration != "100ms" {
			t.Errorf("Expected RT.Duration to be '100ms', got %v", step.ctx.RT.Duration)
		}
	})

	t.Run("failed step execution with mock", func(t *testing.T) {
		step := Step{
			Name: "Failed Step",
			Uses: "failing-action",
			Expr: &Expr{},
		}

		// Set up mock runner for failed execution
		mock := NewMockActionRunner()
		testErr := fmt.Errorf("network error")
		mock.SetError("failing-action", testErr)
		step.actionRunner = mock

		step.ctx = StepContext{
			Vars: map[string]any{},
		}

		jobContext := JobContext{
			Config:  Config{Verbose: false},
			Printer: newBufferPrinter(),
		}

		// Execute the step
		step.Do(&jobContext)

		// Verify failed execution
		if !jobContext.Failed {
			t.Errorf("Do() with failing mock should fail the job")
		}

		// Verify error was set
		if step.err == nil {
			t.Errorf("Expected step error to be set")
		}
	})
}

func TestSleepWithMessage(t *testing.T) {
	tests := []struct {
		name           string
		duration       time.Duration
		message        string
		expectFnCalled bool
		minCalls       int
		maxCalls       int
	}{
		{
			name:           "Short duration under 1s - no call",
			duration:       50 * time.Millisecond,
			message:        "ignored",
			expectFnCalled: false,
		},
		{
			name:           "1.25s duration - expect 1 to 2 calls",
			duration:       1250 * time.Millisecond,
			message:        "hello",
			expectFnCalled: true,
			minCalls:       1,
			maxCalls:       2,
		},
		{
			name:           "Exact 1.05s duration - expect 1 call",
			duration:       1050 * time.Millisecond,
			message:        "one",
			expectFnCalled: true,
			minCalls:       1,
			maxCalls:       1,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var mu sync.Mutex
			var calls []string

			sleepWithMessage(tt.duration, tt.message, func(m string) {
				mu.Lock()
				defer mu.Unlock()
				calls = append(calls, m)
			})

			if tt.expectFnCalled {
				count := len(calls)
				if count < tt.minCalls || count > tt.maxCalls {
					t.Errorf("expected between %d and %d calls, got %d", tt.minCalls, tt.maxCalls, count)
				}
				for _, msg := range calls {
					if msg != tt.message {
						t.Errorf("unexpected message: got %s, want %s", msg, tt.message)
					}
				}
			} else {
				if len(calls) > 0 {
					t.Errorf("expected no calls, but got %d", len(calls))
				}
			}
		})
	}
}

func TestStep_getEchoOutput(t *testing.T) {
	// Enable color output for testing
	originalNoColor := color.NoColor
	color.NoColor = false
	defer func() { color.NoColor = originalNoColor }()

	tests := []struct {
		name        string
		echo        string
		context     StepContext
		expected    string
		expectError bool
	}{
		{
			name:        "single line echo",
			echo:        "Hello World",
			context:     StepContext{},
			expected:    "       Hello World\n",
			expectError: false,
		},
		{
			name:        "multi-line echo with explicit newlines",
			echo:        "Line 1\nLine 2\nLine 3",
			context:     StepContext{},
			expected:    "       Line 1\n       Line 2\n       Line 3\n",
			expectError: false,
		},
		{
			name:        "complex multiline with indentation",
			echo:        "Header\n  Indented\n    More indented\nBack to left",
			context:     StepContext{},
			expected:    "       Header\n         Indented\n           More indented\n       Back to left\n",
			expectError: false,
		},
		{
			name:        "empty line handling",
			echo:        "Line 1\n\nLine 3",
			context:     StepContext{},
			expected:    "       Line 1\n       \n       Line 3\n",
			expectError: false,
		},
		{
			name:        "template expression",
			echo:        "Status: {{vars.status}}",
			context:     StepContext{Vars: map[string]any{"status": "OK"}},
			expected:    "       Status: OK\n",
			expectError: false,
		},
		{
			name:        "multiline template expression",
			echo:        "Status: {{vars.status}}\nCode: {{vars.code}}",
			context:     StepContext{Vars: map[string]any{"status": "OK", "code": "200"}},
			expected:    "       Status: OK\n       Code: 200\n",
			expectError: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			step := &Step{
				Echo: tt.echo,
				ctx:  tt.context,
				Expr: &Expr{},
			}
			printer := newBufferPrinter()

			result := step.getEchoOutput(printer)

			if result != tt.expected {
				t.Errorf("getEchoOutput() = %q, want %q", result, tt.expected)
			}
		})
	}
}

func TestStep_getEchoOutput_Error(t *testing.T) {
	step := &Step{
		Echo: "{{invalid_expression + }}", // Invalid syntax that will cause template error
		ctx:  StepContext{},
		Expr: &Expr{},
	}
	printer := newBufferPrinter()

	result := step.getEchoOutput(printer)

	// Should contain error indication when template evaluation fails
	if !strings.Contains(result, "CompileError") && !strings.Contains(result, "RuntimeError") && !strings.Contains(result, "Echo\nerror:") {
		t.Errorf("getEchoOutput() with invalid expression should return error message, got %q", result)
	}

	// Verify indentation is applied even to error messages
	lines := strings.SplitSeq(strings.TrimSuffix(result, "\n"), "\n")
	for line := range lines {
		if !strings.HasPrefix(line, "       ") {
			t.Errorf("getEchoOutput() should indent all lines including errors, line without indent: %q", line)
		}
	}
}

func TestStepContext_RepeatIndex(t *testing.T) {
	tests := []struct {
		name        string
		repeatIndex int
		expression  string
		expected    string
	}{
		{
			name:        "repeat_index in echo",
			repeatIndex: 3,
			expression:  "Repeat: {{repeat_index}}",
			expected:    "Repeat: 3",
		},
		{
			name:        "repeat_index in test",
			repeatIndex: 5,
			expression:  "repeat_index == 5",
			expected:    "true",
		},
		{
			name:        "repeat_index arithmetic",
			repeatIndex: 2,
			expression:  "{{repeat_index + 1}}",
			expected:    "3",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			ctx := StepContext{
				RepeatIndex: tt.repeatIndex,
			}

			expr := &Expr{}
			var result string
			var err error

			if strings.Contains(tt.expression, "{{") {
				// Template expression
				result, err = expr.EvalTemplate(tt.expression, ctx)
			} else {
				// Boolean/arithmetic expression
				output, evalErr := expr.Eval(tt.expression, ctx)
				err = evalErr
				if err == nil {
					result = fmt.Sprintf("%v", output)
				}
			}

			if err != nil {
				t.Errorf("Expression evaluation failed: %v", err)
				return
			}

			if result != tt.expected {
				t.Errorf("Expected %q, got %q", tt.expected, result)
			}
		})
	}
}

// SlowMockActionRunner is a mock that simulates slow action execution
type SlowMockActionRunner struct {
	delay time.Duration
}

func (m *SlowMockActionRunner) RunActions(name string, args []string, with map[string]any, verbose bool) (map[string]any, error) {
	time.Sleep(m.delay)
	return map[string]any{"status": 0}, nil
}

func TestStep_executeSingleAction_DefaultTimeout(t *testing.T) {
	step := &Step{
		Uses: "test-action",
		Expr: &Expr{},
		// No Timeout specified - should use DefaultStepTimeout
	}

	// Mock runner that completes quickly
	mock := NewMockActionRunner()
	mock.SetResult("test-action", map[string]any{"status": 0})

	jCtx := &JobContext{
		Config: Config{Verbose: false},
	}

	start := time.Now()
	result, err := step.executeSingleAction(mock, map[string]any{}, jCtx)
	duration := time.Since(start)

	if err != nil {
		t.Errorf("Expected no error, got %v", err)
	}
	if result == nil {
		t.Error("Expected result, got nil")
	}
	// Should complete quickly (well under default timeout)
	if duration > 1*time.Second {
		t.Errorf("Expected quick completion, took %v", duration)
	}
}

func TestStep_executeSingleAction_CustomTimeout(t *testing.T) {
	step := &Step{
		Uses:    "test-action",
		Timeout: Interval{Duration: 2 * time.Second},
		Expr:    &Expr{},
	}

	// Mock runner that takes 3 seconds (longer than timeout)
	slowMock := &SlowMockActionRunner{delay: 3 * time.Second}

	jCtx := &JobContext{
		Config: Config{Verbose: false},
	}

	start := time.Now()
	result, err := step.executeSingleAction(slowMock, map[string]any{}, jCtx)
	duration := time.Since(start)

	// Should timeout
	if err == nil {
		t.Error("Expected timeout error, got nil")
	}
	if !strings.Contains(err.Error(), "timed out") {
		t.Errorf("Expected timeout error, got: %v", err)
	}
	if result != nil {
		t.Errorf("Expected nil result on timeout, got %v", result)
	}
	// Should timeout around 2 seconds
	if duration < 1900*time.Millisecond || duration > 2500*time.Millisecond {
		t.Errorf("Expected timeout around 2s, took %v", duration)
	}
}

func TestStep_executeSingleAction_CompletesBeforeTimeout(t *testing.T) {
	step := &Step{
		Uses:    "test-action",
		Timeout: Interval{Duration: 3 * time.Second},
		Expr:    &Expr{},
	}

	// Mock runner that takes 1 second (less than timeout)
	slowMock := &SlowMockActionRunner{delay: 1 * time.Second}

	jCtx := &JobContext{
		Config: Config{Verbose: false},
	}

	start := time.Now()
	result, err := step.executeSingleAction(slowMock, map[string]any{}, jCtx)
	duration := time.Since(start)

	// Should complete successfully
	if err != nil {
		t.Errorf("Expected no error, got %v", err)
	}
	if result == nil {
		t.Error("Expected result, got nil")
	}
	if result["status"] != 0 {
		t.Errorf("Expected status=0, got %v", result["status"])
	}
	// Should complete around 1 second
	if duration < 900*time.Millisecond || duration > 1500*time.Millisecond {
		t.Errorf("Expected completion around 1s, took %v", duration)
	}
}

func TestStep_executeActionWithRetry_Timeout(t *testing.T) {
	step := &Step{
		Uses:    "test-action",
		Timeout: Interval{Duration: 500 * time.Millisecond},
		Retry: &StepRetry{
			MaxAttempts: 3,
			Interval:    Interval{Duration: 100 * time.Millisecond},
		},
		Expr: &Expr{},
	}

	// Mock runner that takes 1 second per attempt (longer than timeout)
	slowMock := &SlowMockActionRunner{delay: 1 * time.Second}

	jCtx := &JobContext{
		Config:  Config{Verbose: false},
		Printer: newBufferPrinter(),
	}

	start := time.Now()
	result, err := step.executeActionWithRetry(slowMock, map[string]any{}, jCtx, "test")
	duration := time.Since(start)

	// First attempt should timeout at 500ms
	if err == nil {
		t.Error("Expected timeout error, got nil")
	}
	if !strings.Contains(err.Error(), "timed out") {
		t.Errorf("Expected timeout error, got: %v", err)
	}

	// Should timeout on first attempt around 500ms, then retry with interval
	// Total: ~500ms (timeout) + 100ms (interval) + 500ms (timeout) + 100ms (interval) + 500ms (timeout) = ~1700ms
	expectedMin := 1500 * time.Millisecond
	expectedMax := 2000 * time.Millisecond
	if duration < expectedMin || duration > expectedMax {
		t.Errorf("Expected retry with timeout around 1700ms, took %v", duration)
	}

	// On timeout, result should be nil
	if result != nil {
		t.Errorf("Expected nil result on timeout, got %v", result)
	}
}

func TestStep_DefaultStepTimeout_Value(t *testing.T) {
	expected := 5 * time.Minute
	if DefaultStepTimeout != expected {
		t.Errorf("DefaultStepTimeout = %v, want %v", DefaultStepTimeout, expected)
	}
}

func TestParseExitStatus(t *testing.T) {
	tests := []struct {
		name     string
		input    any
		expected int
	}{
		{"nil", nil, int(ExitStatusFailure)},
		{"int 0", int(0), int(ExitStatusSuccess)},
		{"int 1", int(1), int(ExitStatusFailure)},
		{"int64 0", int64(0), int(ExitStatusSuccess)},
		{"int64 1", int64(1), int(ExitStatusFailure)},
		{"float64 0", float64(0), int(ExitStatusSuccess)},
		{"float64 1", float64(1), int(ExitStatusFailure)},
		{"string 0", "0", int(ExitStatusSuccess)},
		{"string 1", "1", int(ExitStatusFailure)},
		{"ExitStatus success", ExitStatusSuccess, int(ExitStatusSuccess)},
		{"ExitStatus failure", ExitStatusFailure, int(ExitStatusFailure)},
		{"unknown type", []int{0}, int(ExitStatusFailure)},
	}

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