package cmd

import (
	"testing"

	"github.com/ivuorinen/f2b/fail2ban"
)

// TestComprehensiveFrameworkCapabilities demonstrates the full power of the test framework
func TestComprehensiveFrameworkCapabilities(t *testing.T) {
	// Test 1: Basic command success testing
	t.Run("basic_success", func(t *testing.T) {
		NewCommandTest(t, "list-jails").
			WithSetup(func(mock *fail2ban.MockClient) {
				setMockJails(mock, []string{"sshd", "apache"})
			}).
			ExpectSuccess().
			ExpectOutput("sshd").
			Run()
	})

	// Test 2: Error handling and validation
	t.Run("error_handling", func(t *testing.T) {
		NewCommandTest(t, "ban").
			WithArgs("invalid-ip", "sshd").
			ExpectError().
			Run().
			AssertContains("invalid IP address")
	})

	// Test 3: JSON output testing with field validation
	t.Run("json_validation", func(t *testing.T) {
		NewCommandTest(t, "banned").
			WithArgs("sshd").
			WithJSONFormat().
			WithSetup(func(mock *fail2ban.MockClient) {
				setMockJails(mock, []string{"sshd"})
				_, _ = mock.BanIP("192.168.1.100", "sshd")
			}).
			ExpectSuccess().
			Run().
			AssertJSONField("Jail", "sshd").
			AssertJSONField("IP", "192.168.1.100")
	})

	// Test 4: Complex environment setup
	t.Run("environment_management", func(t *testing.T) {
		env := NewTestEnvironment().
			WithPrivileges(true).
			WithMockRunner().
			WithStdoutCapture()
		defer env.Cleanup()

		NewCommandTest(t, "status").
			WithArgs("all").
			WithEnvironment(env).
			WithSetup(func(mock *fail2ban.MockClient) {
				setMockJails(mock, []string{"sshd", "apache"})
				mock.StatusAllData = "All systems operational"
			}).
			ExpectSuccess().
			Run().
			AssertContains("operational")
	})

	// Test 5: Chained assertions
	t.Run("chained_assertions", func(t *testing.T) {
		result := NewCommandTest(t, "status").
			WithArgs("sshd").
			WithSetup(func(mock *fail2ban.MockClient) {
				setMockJails(mock, []string{"sshd"})
				mock.StatusJailData = map[string]string{
					"sshd": "Jail: sshd\nStatus: Active\nFiltered: 10 lines",
				}
			}).
			ExpectSuccess().
			Run()

		// Multiple validations on the same result
		result.AssertContains("Jail: sshd").
			AssertContains("Status: Active").
			AssertContains("Filtered").
			AssertNotContains("Error").
			AssertNotEmpty()
	})

	// Test 6: Table-driven testing with framework
	t.Run("table_driven", func(t *testing.T) {
		tests := []struct {
			name     string
			command  string
			args     []string
			expected string
			isError  bool
		}{
			{"ban_success", "ban", []string{"192.168.1.100", "sshd"}, "Banned", false},
			{"unban_success", "unban", []string{"192.168.1.100", "sshd"}, "Unbanned", false},
			{"test_banned", "test", []string{"192.168.1.100"}, "is banned", false},
			{"invalid_jail", "ban", []string{"192.168.1.100", "invalid"}, "not found", true},
		}

		for _, tt := range tests {
			t.Run(tt.name, func(t *testing.T) {
				builder := NewCommandTest(t, tt.command).
					WithArgs(tt.args...).
					WithSetup(func(mock *fail2ban.MockClient) {
						setMockJails(mock, []string{"sshd", "apache"})
						if tt.command == "unban" || tt.command == "test" {
							// Pre-ban IP for unban/test scenarios
							_, _ = mock.BanIP("192.168.1.100", "sshd")
						}
					})

				if tt.isError {
					builder = builder.ExpectError()
				} else {
					builder = builder.ExpectSuccess()
				}

				builder.ExpectOutput(tt.expected).Run()
			})
		}
	})
}

// TestFrameworkPerformance demonstrates framework efficiency
func TestFrameworkPerformance(t *testing.T) {
	// Measure how concise framework tests can be
	tests := map[string][]string{
		"ban":        {"192.168.1.100", "sshd"},
		"unban":      {"192.168.1.100", "sshd"},
		"status":     {"sshd"},
		"list-jails": {},
		"banned":     {"sshd"},
		"test":       {"192.168.1.100"},
	}

	for cmd, args := range tests {
		t.Run("performance_"+cmd, func(t *testing.T) {
			// Single line test execution
			NewCommandTest(t, cmd).
				WithArgs(args...).
				WithSetup(func(mock *fail2ban.MockClient) {
					setMockJails(mock, []string{"sshd"})
					if cmd != "ban" && cmd != "list-jails" {
						_, _ = mock.BanIP("192.168.1.100", "sshd")
					}
					if cmd == "status" && len(args) > 0 {
						mock.StatusJailData = map[string]string{"sshd": "Status for sshd"}
					}
				}).
				ExpectSuccess().
				Run()
		})
	}
}

// TestFrameworkEdgeCases tests framework robustness
func TestFrameworkEdgeCases(t *testing.T) {
	// Test empty output validation
	t.Run("empty_output", func(t *testing.T) {
		// Test framework with empty jail list setup
		NewCommandTest(t, "list-jails").
			WithSetup(func(mock *fail2ban.MockClient) {
				setMockJails(mock, []string{}) // No jails
			}).
			ExpectSuccess().
			Run()
	})

	// Test JSON parsing edge cases
	t.Run("json_array_handling", func(t *testing.T) {
		NewCommandTest(t, "banned").
			WithArgs("sshd").
			WithJSONFormat().
			WithSetup(func(mock *fail2ban.MockClient) {
				setMockJails(mock, []string{"sshd"})
				_, _ = mock.BanIP("192.168.1.100", "sshd")
				_, _ = mock.BanIP("192.168.1.101", "sshd")
			}).
			ExpectSuccess().
			Run().
			AssertJSONField("Jail", "sshd") // Should handle array and check first element
	})

	// Test exact output matching
	t.Run("exact_matching", func(t *testing.T) {
		NewCommandTest(t, "status").
			WithArgs("sshd").
			WithSetup(func(mock *fail2ban.MockClient) {
				setMockJails(mock, []string{"sshd"})
				mock.StatusJailData = map[string]string{"sshd": "Exact status message"}
			}).
			ExpectSuccess().
			Run().
			AssertContains("Exact status message") // Use contains instead of exact for robustness
	})
}

// BenchmarkFrameworkOverhead measures performance impact
func BenchmarkFrameworkOverhead(b *testing.B) {
	// Create a mock client once outside the loop
	mock := fail2ban.NewMockClient()
	setMockJails(mock, []string{"sshd"})

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		// Benchmark just the core client operation without cobra command overhead
		_, err := mock.ListJails()
		if err != nil {
			b.Fatalf("Client operation failed: %v", err)
		}
	}
}

// TestFrameworkCompatibility ensures framework works with existing helpers
func TestFrameworkCompatibility(t *testing.T) {
	// Test that framework can work alongside existing test helpers
	t.Run("mixed_approach", func(t *testing.T) {
		// Manual mock setup when needed
		mock := NewMockClient()
		setMockJails(mock, []string{"sshd", "apache"})

		// Use framework for execution and validation
		NewCommandTest(t, "list-jails").
			WithMockClient(mock).
			ExpectSuccess().
			ExpectOutput("sshd").
			Run().
			AssertContains("apache")
	})
}