package testutil

import (
	"errors"
	"os"
	"testing"
)

func TestVerifyContentContains(t *testing.T) {
	// Test successful verification
	t.Run(
		"all substrings present", func(t *testing.T) {
			content := "This is a test file with multiple lines"
			VerifyContentContains(t, content, []string{"test file", "multiple lines"})
			// If we get here, the test passed
		},
	)

	// Test empty expected substrings
	t.Run(
		"empty expected substrings", func(t *testing.T) {
			content := "Any content"
			VerifyContentContains(t, content, []string{})
			// Should pass with no expected strings
		},
	)

	// For failure cases, we'll test indirectly by verifying behavior
	t.Run(
		"verify error reporting", func(t *testing.T) {
			// We can't easily test the failure case directly since it calls t.Errorf
			// But we can at least verify the function doesn't panic
			defer func() {
				if r := recover(); r != nil {
					t.Errorf("VerifyContentContains panicked: %v", r)
				}
			}()

			// This would normally fail, but we're just checking it doesn't panic
			content := "test"
			expected := []string{"not found"}
			// Create a subtest that we expect to fail
			t.Run(
				"expected_failure", func(t *testing.T) {
					t.Skip("Skipping actual failure test")
					VerifyContentContains(t, content, expected)
				},
			)
		},
	)
}

func TestMustSucceed(t *testing.T) {
	// Test with nil error (should succeed)
	t.Run(
		"nil error", func(t *testing.T) {
			MustSucceed(t, nil, "successful operation")
			// If we get here, the test passed
		},
	)

	// Test error behavior without causing test failure
	t.Run(
		"verify error handling", func(t *testing.T) {
			// We can't test the failure case directly since it calls t.Fatalf
			// But we can verify the function exists and is callable
			defer func() {
				if r := recover(); r != nil {
					t.Errorf("MustSucceed panicked: %v", r)
				}
			}()

			// Create a subtest that we expect to fail
			t.Run(
				"expected_failure", func(t *testing.T) {
					t.Skip("Skipping actual failure test")
					MustSucceed(t, errors.New("test error"), "failed operation")
				},
			)
		},
	)
}

func TestCloseFile(t *testing.T) {
	// Test closing a normal file
	t.Run(
		"close normal file", func(t *testing.T) {
			file, err := os.CreateTemp(t.TempDir(), "test")
			if err != nil {
				t.Fatalf("Failed to create test file: %v", err)
			}

			CloseFile(t, file)

			// Verify file is closed by trying to write to it
			_, writeErr := file.Write([]byte("test"))
			if writeErr == nil {
				t.Error("Expected write to fail on closed file")
			}
		},
	)

	// Test that CloseFile doesn't panic on already closed files
	// Note: We can't easily test the error case without causing test failure
	// since CloseFile calls t.Errorf, which is the expected behavior
	t.Run(
		"verify CloseFile function exists and is callable", func(t *testing.T) {
			// This test just verifies the function signature and basic functionality
			// The error case is tested in integration tests where failures are expected
			file, err := os.CreateTemp(t.TempDir(), "test")
			if err != nil {
				t.Fatalf("Failed to create test file: %v", err)
			}

			// Test normal case - file should close successfully
			CloseFile(t, file)

			// Verify file is closed
			_, writeErr := file.Write([]byte("test"))
			if writeErr == nil {
				t.Error("Expected write to fail on closed file")
			}
		},
	)
}