util_rules_test.go

package github

import (
	"encoding/json"
	"testing"

	"github.com/google/go-github/v84/github"
	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
)

func TestExpandRulesBasicRules(t *testing.T) {
	// Test expanding basic boolean rules with RepositoryRulesetRules
	rulesMap := map[string]any{
		"creation":                true,
		"deletion":                true,
		"required_linear_history": true,
		"required_signatures":     false,
		"non_fast_forward":        true,
	}

	input := []any{rulesMap}
	result := expandRules(input, false)

	if result == nil {
		t.Fatal("Expected result to not be nil")
		return
	}

	// Check boolean rules - they use EmptyRuleParameters and are nil when false
	if result.Creation == nil {
		t.Error("Expected Creation rule to be set")
	}

	if result.Deletion == nil {
		t.Error("Expected Deletion rule to be set")
	}

	if result.RequiredLinearHistory == nil {
		t.Error("Expected RequiredLinearHistory rule to be set")
	}

	if result.RequiredSignatures != nil {
		t.Error("Expected RequiredSignatures rule to be nil (false)")
	}

	if result.NonFastForward == nil {
		t.Error("Expected NonFastForward rule to be set")
	}
}

func TestFlattenRulesBasicRules(t *testing.T) {
	// Test flattening basic boolean rules with RepositoryRulesetRules
	rules := &github.RepositoryRulesetRules{
		Creation:              &github.EmptyRuleParameters{},
		Deletion:              &github.EmptyRuleParameters{},
		RequiredLinearHistory: &github.EmptyRuleParameters{},
		RequiredSignatures:    nil, // false means nil
		NonFastForward:        &github.EmptyRuleParameters{},
	}

	result := flattenRules(t.Context(), rules, false)

	if len(result) != 1 {
		t.Fatalf("Expected 1 element in result, got %d", len(result))
	}

	rulesMap := result[0].(map[string]any)

	// Should contain the rules
	if !rulesMap["creation"].(bool) {
		t.Error("Expected creation rule to be true")
	}

	if !rulesMap["deletion"].(bool) {
		t.Error("Expected deletion rule to be true")
	}

	if !rulesMap["required_linear_history"].(bool) {
		t.Error("Expected required_linear_history rule to be true")
	}

	if rulesMap["required_signatures"].(bool) {
		t.Error("Expected required_signatures rule to be false")
	}

	if !rulesMap["non_fast_forward"].(bool) {
		t.Error("Expected non_fast_forward rule to be true")
	}
}

func TestExpandRulesMaxFilePathLength(t *testing.T) {
	// Test that max_file_path_length rule is properly expanded
	maxPathLength := 512

	rulesMap := map[string]any{
		"max_file_path_length": []any{
			map[string]any{
				"max_file_path_length": maxPathLength,
			},
		},
	}

	input := []any{rulesMap}
	result := expandRules(input, false)

	if result == nil {
		t.Fatal("Expected result to not be nil")
		return
	}

	if result.MaxFilePathLength == nil {
		t.Fatal("Expected MaxFilePathLength rule to be set")
		return
	}

	if result.MaxFilePathLength.MaxFilePathLength != maxPathLength {
		t.Errorf("Expected MaxFilePathLength to be %d, got %d", maxPathLength, result.MaxFilePathLength.MaxFilePathLength)
	}
}

func TestFlattenRulesMaxFilePathLength(t *testing.T) {
	// Test that max_file_path_length rule is properly flattened
	maxPathLength := 256
	rules := &github.RepositoryRulesetRules{
		MaxFilePathLength: &github.MaxFilePathLengthRuleParameters{
			MaxFilePathLength: maxPathLength,
		},
	}

	result := flattenRules(t.Context(), rules, false)

	if len(result) != 1 {
		t.Fatalf("Expected 1 element in result, got %d", len(result))
	}

	rulesMap := result[0].(map[string]any)
	maxFilePathLengthRules := rulesMap["max_file_path_length"].([]map[string]any)

	if len(maxFilePathLengthRules) != 1 {
		t.Fatalf("Expected 1 max_file_path_length rule, got %d", len(maxFilePathLengthRules))
	}

	if maxFilePathLengthRules[0]["max_file_path_length"] != maxPathLength {
		t.Errorf("Expected max_file_path_length to be %d, got %v", maxPathLength, maxFilePathLengthRules[0]["max_file_path_length"])
	}
}

func TestRoundTripMaxFilePathLength(t *testing.T) {
	// Test that max_file_path_length rule survives expand -> flatten round trip
	maxPathLength := 1024

	// Start with terraform configuration
	rulesMap := map[string]any{
		"max_file_path_length": []any{
			map[string]any{
				"max_file_path_length": maxPathLength,
			},
		},
	}

	input := []any{rulesMap}

	// Expand to GitHub API format
	expandedRules := expandRules(input, false)

	if expandedRules == nil {
		t.Fatal("Expected expandedRules to not be nil")
	}

	// Flatten back to terraform format
	flattenedResult := flattenRules(t.Context(), expandedRules, false)

	if len(flattenedResult) != 1 {
		t.Fatalf("Expected 1 flattened result, got %d", len(flattenedResult))
	}

	flattenedRulesMap := flattenedResult[0].(map[string]any)
	maxFilePathLengthRules := flattenedRulesMap["max_file_path_length"].([]map[string]any)

	if len(maxFilePathLengthRules) != 1 {
		t.Fatalf("Expected 1 max_file_path_length rule after round trip, got %d", len(maxFilePathLengthRules))
	}

	if maxFilePathLengthRules[0]["max_file_path_length"] != maxPathLength {
		t.Errorf("Expected max_file_path_length to be %d after round trip, got %v", maxPathLength, maxFilePathLengthRules[0]["max_file_path_length"])
	}
}

func TestExpandRulesMaxFileSize(t *testing.T) {
	// Test that max_file_size rule is properly expanded
	maxFileSize := int64(1048576) // 1MB

	rulesMap := map[string]any{
		"max_file_size": []any{
			map[string]any{
				"max_file_size": float64(maxFileSize),
			},
		},
	}

	input := []any{rulesMap}
	result := expandRules(input, false)

	if result == nil {
		t.Fatal("Expected result to not be nil")
		return
	}

	if result.MaxFileSize == nil {
		t.Fatal("Expected MaxFileSize rule to be set")
		return
	}

	if result.MaxFileSize.MaxFileSize != maxFileSize {
		t.Errorf("Expected MaxFileSize to be %d, got %d", maxFileSize, result.MaxFileSize.MaxFileSize)
	}
}

func TestFlattenRulesMaxFileSize(t *testing.T) {
	// Test that max_file_size rule is properly flattened
	maxFileSize := int64(5242880) // 5MB
	rules := &github.RepositoryRulesetRules{
		MaxFileSize: &github.MaxFileSizeRuleParameters{
			MaxFileSize: maxFileSize,
		},
	}

	result := flattenRules(t.Context(), rules, false)

	if len(result) != 1 {
		t.Fatalf("Expected 1 element in result, got %d", len(result))
	}

	rulesMap := result[0].(map[string]any)
	maxFileSizeRules := rulesMap["max_file_size"].([]map[string]any)

	if len(maxFileSizeRules) != 1 {
		t.Fatalf("Expected 1 max_file_size rule, got %d", len(maxFileSizeRules))
	}

	if maxFileSizeRules[0]["max_file_size"] != maxFileSize {
		t.Errorf("Expected max_file_size to be %d, got %v", maxFileSize, maxFileSizeRules[0]["max_file_size"])
	}
}

func TestExpandRulesFileExtensionRestriction(t *testing.T) {
	// Test that file_extension_restriction rule is properly expanded
	restrictedExtensions := []string{".exe", ".bat", ".com"}

	rulesMap := map[string]any{
		"file_extension_restriction": []any{
			map[string]any{
				"restricted_file_extensions": schema.NewSet(schema.HashString, []any{".exe", ".bat", ".com"}),
			},
		},
	}

	input := []any{rulesMap}
	result := expandRules(input, false)

	if result == nil {
		t.Fatal("Expected result to not be nil")
		return
	}

	if result.FileExtensionRestriction == nil {
		t.Fatal("Expected FileExtensionRestriction rule to be set")
		return
	}

	if len(result.FileExtensionRestriction.RestrictedFileExtensions) != len(restrictedExtensions) {
		t.Errorf("Expected %d restricted extensions, got %d", len(restrictedExtensions), len(result.FileExtensionRestriction.RestrictedFileExtensions))
	}

	resultExtensions := make(map[string]bool)
	for _, ext := range result.FileExtensionRestriction.RestrictedFileExtensions {
		resultExtensions[ext] = true
	}

	for _, expectedExt := range restrictedExtensions {
		if !resultExtensions[expectedExt] {
			t.Errorf("Expected extension %s not found in result", expectedExt)
		}
	}
}

func TestFlattenRulesFileExtensionRestriction(t *testing.T) {
	// Test that file_extension_restriction rule is properly flattened
	restrictedExtensions := []string{".exe", ".bat", ".com"}
	rules := &github.RepositoryRulesetRules{
		FileExtensionRestriction: &github.FileExtensionRestrictionRuleParameters{
			RestrictedFileExtensions: restrictedExtensions,
		},
	}

	result := flattenRules(t.Context(), rules, false)

	if len(result) != 1 {
		t.Fatalf("Expected 1 element in result, got %d", len(result))
	}

	rulesMap := result[0].(map[string]any)
	fileExtensionRules := rulesMap["file_extension_restriction"].([]map[string]any)

	if len(fileExtensionRules) != 1 {
		t.Fatalf("Expected 1 file_extension_restriction rule, got %d", len(fileExtensionRules))
	}

	actualExtensions := fileExtensionRules[0]["restricted_file_extensions"].([]string)
	if len(actualExtensions) != len(restrictedExtensions) {
		t.Errorf("Expected %d restricted extensions, got %d", len(restrictedExtensions), len(actualExtensions))
	}

	for i, ext := range restrictedExtensions {
		if actualExtensions[i] != ext {
			t.Errorf("Expected extension %s at index %d, got %s", ext, i, actualExtensions[i])
		}
	}
}

func TestCompletePushRulesetSupport(t *testing.T) {
	// Test that all push-specific rules are supported together
	rulesMap := map[string]any{
		"file_path_restriction": []any{
			map[string]any{
				"restricted_file_paths": []any{"secrets/", "*.key", "private/"},
			},
		},
		"max_file_size": []any{
			map[string]any{
				"max_file_size": 5, // 5MB
			},
		},
		"max_file_path_length": []any{
			map[string]any{
				"max_file_path_length": 300,
			},
		},
		"file_extension_restriction": []any{
			map[string]any{
				"restricted_file_extensions": schema.NewSet(schema.HashString, []any{".exe", ".bat", ".sh"}),
			},
		},
	}

	input := []any{rulesMap}

	// Expand to GitHub API format
	expandedRules := expandRules(input, false)

	if expandedRules == nil {
		t.Fatal("Expected expandedRules to not be nil")
		return
	}

	// Count how many rules we have
	ruleCount := 0
	if expandedRules.FilePathRestriction != nil {
		ruleCount++
	}
	if expandedRules.MaxFileSize != nil {
		ruleCount++
	}
	if expandedRules.MaxFilePathLength != nil {
		ruleCount++
	}
	if expandedRules.FileExtensionRestriction != nil {
		ruleCount++
	}

	if ruleCount != 4 {
		t.Fatalf("Expected 4 expanded rules for complete push ruleset, got %d", ruleCount)
	}

	// Flatten back to terraform format
	flattenedResult := flattenRules(t.Context(), expandedRules, false)

	if len(flattenedResult) != 1 {
		t.Fatalf("Expected 1 flattened result, got %d", len(flattenedResult))
	}

	flattenedRulesMap := flattenedResult[0].(map[string]any)

	// Verify file_path_restriction
	filePathRules := flattenedRulesMap["file_path_restriction"].([]map[string]any)
	if len(filePathRules) != 1 {
		t.Fatalf("Expected 1 file_path_restriction rule, got %d", len(filePathRules))
	}
	restrictedPaths := filePathRules[0]["restricted_file_paths"].([]string)
	if len(restrictedPaths) != 3 {
		t.Errorf("Expected 3 restricted file paths, got %d", len(restrictedPaths))
	}

	// Verify max_file_size
	maxFileSizeRules := flattenedRulesMap["max_file_size"].([]map[string]any)
	if len(maxFileSizeRules) != 1 {
		t.Fatalf("Expected 1 max_file_size rule, got %d", len(maxFileSizeRules))
	}
	if maxFileSizeRules[0]["max_file_size"] != int64(5) {
		t.Errorf("Expected max_file_size to be 5, got %v", maxFileSizeRules[0]["max_file_size"])
	}

	// Verify max_file_path_length
	maxFilePathLengthRules := flattenedRulesMap["max_file_path_length"].([]map[string]any)
	if len(maxFilePathLengthRules) != 1 {
		t.Fatalf("Expected 1 max_file_path_length rule, got %d", len(maxFilePathLengthRules))
	}
	if maxFilePathLengthRules[0]["max_file_path_length"] != 300 {
		t.Errorf("Expected max_file_path_length to be 300, got %v", maxFilePathLengthRules[0]["max_file_path_length"])
	}

	// Verify file_extension_restriction
	fileExtRules := flattenedRulesMap["file_extension_restriction"].([]map[string]any)
	if len(fileExtRules) != 1 {
		t.Fatalf("Expected 1 file_extension_restriction rule, got %d", len(fileExtRules))
	}
	restrictedExts := fileExtRules[0]["restricted_file_extensions"].([]string)
	if len(restrictedExts) != 3 {
		t.Errorf("Expected 3 restricted file extensions, got %d", len(restrictedExts))
	}
}

func TestCopilotCodeReviewRoundTrip(t *testing.T) {
	// Test that copilot_code_review rule survives expand -> flatten round trip
	rulesMap := map[string]any{
		"copilot_code_review": []any{
			map[string]any{
				"review_on_push":             true,
				"review_draft_pull_requests": false,
			},
		},
	}

	input := []any{rulesMap}

	// Expand to GitHub API format
	expandedRules := expandRules(input, false)

	if expandedRules == nil {
		t.Fatal("Expected expandedRules to not be nil")
	}

	if expandedRules.CopilotCodeReview == nil {
		t.Fatal("Expected CopilotCodeReview rule to be set")
	}

	if expandedRules.CopilotCodeReview.ReviewOnPush != true {
		t.Errorf("Expected ReviewOnPush to be true, got %v", expandedRules.CopilotCodeReview.ReviewOnPush)
	}

	if expandedRules.CopilotCodeReview.ReviewDraftPullRequests != false {
		t.Errorf("Expected ReviewDraftPullRequests to be false, got %v", expandedRules.CopilotCodeReview.ReviewDraftPullRequests)
	}

	// Flatten back to terraform format
	flattenedResult := flattenRules(t.Context(), expandedRules, false)

	if len(flattenedResult) != 1 {
		t.Fatalf("Expected 1 flattened result, got %d", len(flattenedResult))
	}

	flattenedRulesMap := flattenedResult[0].(map[string]any)
	copilotRules := flattenedRulesMap["copilot_code_review"].([]map[string]any)

	if len(copilotRules) != 1 {
		t.Fatalf("Expected 1 copilot_code_review rule after round trip, got %d", len(copilotRules))
	}

	if copilotRules[0]["review_on_push"] != true {
		t.Errorf("Expected review_on_push to be true, got %v", copilotRules[0]["review_on_push"])
	}

	if copilotRules[0]["review_draft_pull_requests"] != false {
		t.Errorf("Expected review_draft_pull_requests to be false, got %v", copilotRules[0]["review_draft_pull_requests"])
	}
}

func TestFlattenConditions_PushRuleset_WithRepositoryNameOnly(t *testing.T) {
	// Push rulesets don't use ref_name - they only have repository_name or repository_id.
	// flattenConditions should return the conditions even when RefName is nil.
	conditions := &github.RepositoryRulesetConditions{
		RefName: nil, // Push rulesets don't have ref_name
		RepositoryName: &github.RepositoryRulesetRepositoryNamesConditionParameters{
			Include: []string{"~ALL"},
			Exclude: []string{},
		},
	}

	result := flattenConditions(t.Context(), conditions, true) // org=true for organization rulesets

	if len(result) != 1 {
		t.Fatalf("Expected 1 conditions block, got %d", len(result))
	}

	conditionsMap := result[0].(map[string]any)

	// ref_name should be empty for push rulesets
	refNameSlice := conditionsMap["ref_name"]
	if refNameSlice != nil {
		t.Fatalf("Expected ref_name to be nil, got %T", conditionsMap["ref_name"])
	}

	// repository_name should be present
	repoNameSlice, ok := conditionsMap["repository_name"].([]map[string]any)
	if !ok {
		t.Fatalf("Expected repository_name to be []map[string]any, got %T", conditionsMap["repository_name"])
	}
	if len(repoNameSlice) != 1 {
		t.Fatalf("Expected 1 repository_name block, got %d", len(repoNameSlice))
	}

	include, ok := repoNameSlice[0]["include"].([]string)
	if !ok {
		t.Fatalf("Expected include to be []string, got %T", repoNameSlice[0]["include"])
	}
	if len(include) != 1 || include[0] != "~ALL" {
		t.Errorf("Expected include to be [~ALL], got %v", include)
	}
}

func TestFlattenConditions_BranchRuleset_WithRefNameAndRepositoryName(t *testing.T) {
	// Branch/tag rulesets have both ref_name and repository_name.
	// This test ensures we didn't break the existing behavior.
	conditions := &github.RepositoryRulesetConditions{
		RefName: &github.RepositoryRulesetRefConditionParameters{
			Include: []string{"~DEFAULT_BRANCH", "refs/heads/main"},
			Exclude: []string{"refs/heads/experimental-*"},
		},
		RepositoryName: &github.RepositoryRulesetRepositoryNamesConditionParameters{
			Include: []string{"~ALL"},
			Exclude: []string{"test-*"},
		},
	}

	result := flattenConditions(t.Context(), conditions, true) // org=true for organization rulesets

	if len(result) != 1 {
		t.Fatalf("Expected 1 conditions block, got %d", len(result))
	}

	conditionsMap := result[0].(map[string]any)

	// ref_name should be present for branch/tag rulesets
	refNameSlice, ok := conditionsMap["ref_name"].([]map[string]any)
	if !ok {
		t.Fatalf("Expected ref_name to be []map[string]any, got %T", conditionsMap["ref_name"])
	}
	if len(refNameSlice) != 1 {
		t.Fatalf("Expected 1 ref_name block, got %d", len(refNameSlice))
	}

	refInclude, ok := refNameSlice[0]["include"].([]string)
	if !ok {
		t.Fatalf("Expected ref_name include to be []string, got %T", refNameSlice[0]["include"])
	}
	if len(refInclude) != 2 {
		t.Errorf("Expected 2 ref_name includes, got %d", len(refInclude))
	}

	refExclude, ok := refNameSlice[0]["exclude"].([]string)
	if !ok {
		t.Fatalf("Expected ref_name exclude to be []string, got %T", refNameSlice[0]["exclude"])
	}
	if len(refExclude) != 1 {
		t.Errorf("Expected 1 ref_name exclude, got %d", len(refExclude))
	}

	// repository_name should also be present
	repoNameSlice, ok := conditionsMap["repository_name"].([]map[string]any)
	if !ok {
		t.Fatalf("Expected repository_name to be []map[string]any, got %T", conditionsMap["repository_name"])
	}
	if len(repoNameSlice) != 1 {
		t.Fatalf("Expected 1 repository_name block, got %d", len(repoNameSlice))
	}

	repoInclude, ok := repoNameSlice[0]["include"].([]string)
	if !ok {
		t.Fatalf("Expected repository_name include to be []string, got %T", repoNameSlice[0]["include"])
	}
	if len(repoInclude) != 1 || repoInclude[0] != "~ALL" {
		t.Errorf("Expected repository_name include to be [~ALL], got %v", repoInclude)
	}

	repoExclude, ok := repoNameSlice[0]["exclude"].([]string)
	if !ok {
		t.Fatalf("Expected repository_name exclude to be []string, got %T", repoNameSlice[0]["exclude"])
	}
	if len(repoExclude) != 1 || repoExclude[0] != "test-*" {
		t.Errorf("Expected repository_name exclude to be [test-*], got %v", repoExclude)
	}
}

func TestFlattenConditions_PushRuleset_WithRepositoryIdOnly(t *testing.T) {
	// Push rulesets can also use repository_id instead of repository_name.
	conditions := &github.RepositoryRulesetConditions{
		RefName: nil, // Push rulesets don't have ref_name
		RepositoryID: &github.RepositoryRulesetRepositoryIDsConditionParameters{
			RepositoryIDs: []int64{12345, 67890},
		},
	}

	result := flattenConditions(t.Context(), conditions, true) // org=true for organization rulesets

	if len(result) != 1 {
		t.Fatalf("Expected 1 conditions block, got %d", len(result))
	}

	conditionsMap := result[0].(map[string]any)

	// ref_name should be nil for push rulesets
	refNameSlice := conditionsMap["ref_name"]
	if refNameSlice != nil {
		t.Fatalf("Expected ref_name to be nil, got %T", conditionsMap["ref_name"])
	}

	// repository_id should be present
	repoIDs, ok := conditionsMap["repository_id"].([]int64)
	if !ok {
		t.Fatalf("Expected repository_id to be []int64, got %T", conditionsMap["repository_id"])
	}
	if len(repoIDs) != 2 {
		t.Fatalf("Expected 2 repository IDs, got %d", len(repoIDs))
	}
	if repoIDs[0] != 12345 || repoIDs[1] != 67890 {
		t.Errorf("Expected repository IDs [12345, 67890], got %v", repoIDs)
	}
}

func TestExpandRequiredReviewers(t *testing.T) {
	input := []any{
		map[string]any{
			"reviewer": []any{
				map[string]any{
					"id":   12345,
					"type": "Team",
				},
			},
			"file_patterns":     []any{"*.go", "src/**/*.ts"},
			"minimum_approvals": 2,
		},
		map[string]any{
			"reviewer": []any{
				map[string]any{
					"id":   67890,
					"type": "Team",
				},
			},
			"file_patterns":     []any{"docs/**/*.md"},
			"minimum_approvals": 1,
		},
	}

	result := expandRequiredReviewers(input)

	if len(result) != 2 {
		t.Fatalf("Expected 2 reviewers, got %d", len(result))
	}

	// Check first reviewer
	if result[0].Reviewer == nil {
		t.Fatal("Expected first reviewer to have a Reviewer")
	}
	if *result[0].Reviewer.ID != 12345 {
		t.Errorf("Expected first reviewer ID to be 12345, got %d", *result[0].Reviewer.ID)
	}
	if *result[0].Reviewer.Type != github.RulesetReviewerTypeTeam {
		t.Errorf("Expected first reviewer type to be Team, got %s", *result[0].Reviewer.Type)
	}
	if *result[0].MinimumApprovals != 2 {
		t.Errorf("Expected first reviewer minimum approvals to be 2, got %d", *result[0].MinimumApprovals)
	}
	if len(result[0].FilePatterns) != 2 {
		t.Fatalf("Expected first reviewer to have 2 file patterns, got %d", len(result[0].FilePatterns))
	}
	if result[0].FilePatterns[0] != "*.go" || result[0].FilePatterns[1] != "src/**/*.ts" {
		t.Errorf("Unexpected file patterns for first reviewer: %v", result[0].FilePatterns)
	}

	// Check second reviewer
	if result[1].Reviewer == nil {
		t.Fatal("Expected second reviewer to have a Reviewer")
	}
	if *result[1].Reviewer.ID != 67890 {
		t.Errorf("Expected second reviewer ID to be 67890, got %d", *result[1].Reviewer.ID)
	}
	if *result[1].MinimumApprovals != 1 {
		t.Errorf("Expected second reviewer minimum approvals to be 1, got %d", *result[1].MinimumApprovals)
	}
}

func TestExpandRequiredReviewersEmpty(t *testing.T) {
	result := expandRequiredReviewers([]any{})
	if result != nil {
		t.Error("Expected nil for empty input")
	}

	result = expandRequiredReviewers(nil)
	if result != nil {
		t.Error("Expected nil for nil input")
	}
}

func TestFlattenRequiredReviewers(t *testing.T) {
	reviewerType := github.RulesetReviewerTypeTeam
	reviewers := []*github.RulesetRequiredReviewer{
		{
			MinimumApprovals: new(2),
			FilePatterns:     []string{"*.go", "src/**/*.ts"},
			Reviewer: &github.RulesetReviewer{
				ID:   new(int64(12345)),
				Type: &reviewerType,
			},
		},
		{
			MinimumApprovals: new(1),
			FilePatterns:     []string{"docs/**/*.md"},
			Reviewer: &github.RulesetReviewer{
				ID:   new(int64(67890)),
				Type: &reviewerType,
			},
		},
	}

	result := flattenRequiredReviewers(reviewers)

	if len(result) != 2 {
		t.Fatalf("Expected 2 reviewers, got %d", len(result))
	}

	// Check first reviewer
	if result[0]["minimum_approvals"] != 2 {
		t.Errorf("Expected first reviewer minimum approvals to be 2, got %v", result[0]["minimum_approvals"])
	}
	filePatterns := result[0]["file_patterns"].([]string)
	if len(filePatterns) != 2 {
		t.Fatalf("Expected first reviewer to have 2 file patterns, got %d", len(filePatterns))
	}
	if filePatterns[0] != "*.go" || filePatterns[1] != "src/**/*.ts" {
		t.Errorf("Unexpected file patterns for first reviewer: %v", filePatterns)
	}

	reviewerBlock := result[0]["reviewer"].([]map[string]any)
	if len(reviewerBlock) != 1 {
		t.Fatalf("Expected 1 reviewer block, got %d", len(reviewerBlock))
	}
	if reviewerBlock[0]["id"] != 12345 {
		t.Errorf("Expected first reviewer ID to be 12345, got %v", reviewerBlock[0]["id"])
	}
	if reviewerBlock[0]["type"] != "Team" {
		t.Errorf("Expected first reviewer type to be Team, got %v", reviewerBlock[0]["type"])
	}

	// Check second reviewer
	if result[1]["minimum_approvals"] != 1 {
		t.Errorf("Expected second reviewer minimum approvals to be 1, got %v", result[1]["minimum_approvals"])
	}
}

func TestFlattenRequiredReviewersEmpty(t *testing.T) {
	result := flattenRequiredReviewers(nil)
	if result != nil {
		t.Error("Expected nil for nil input")
	}

	result = flattenRequiredReviewers([]*github.RulesetRequiredReviewer{})
	if result != nil {
		t.Error("Expected nil for empty slice input")
	}
}

func TestRoundTripRequiredReviewers(t *testing.T) {
	// Start with Terraform-style input
	input := []any{
		map[string]any{
			"reviewer": []any{
				map[string]any{
					"id":   12345,
					"type": "Team",
				},
			},
			"file_patterns":     []any{"*.go", "src/**/*.ts"},
			"minimum_approvals": 2,
		},
	}

	// Expand to go-github types
	expanded := expandRequiredReviewers(input)

	// Flatten back to Terraform types
	flattened := flattenRequiredReviewers(expanded)

	// Verify the round trip maintains data
	if len(flattened) != 1 {
		t.Fatalf("Expected 1 reviewer after round trip, got %d", len(flattened))
	}

	if flattened[0]["minimum_approvals"] != 2 {
		t.Errorf("Expected minimum_approvals to be 2 after round trip, got %v", flattened[0]["minimum_approvals"])
	}

	filePatterns := flattened[0]["file_patterns"].([]string)
	if len(filePatterns) != 2 {
		t.Fatalf("Expected 2 file patterns after round trip, got %d", len(filePatterns))
	}

	reviewerBlock := flattened[0]["reviewer"].([]map[string]any)
	if len(reviewerBlock) != 1 {
		t.Fatalf("Expected 1 reviewer block after round trip, got %d", len(reviewerBlock))
	}
	if reviewerBlock[0]["id"] != 12345 {
		t.Errorf("Expected reviewer ID to be 12345 after round trip, got %v", reviewerBlock[0]["id"])
	}
	if reviewerBlock[0]["type"] != "Team" {
		t.Errorf("Expected reviewer type to be Team after round trip, got %v", reviewerBlock[0]["type"])
	}
}

func TestExpandRepositoryPropertyConditions_SingleInclude(t *testing.T) {
	input := []any{
		map[string]any{
			"include": []any{
				map[string]any{
					"name":            "env",
					"source":          "custom",
					"property_values": []any{"prod"},
				},
			},
			"exclude": []any{},
		},
	}

	result := expandRepositoryPropertyConditions(input)

	if result == nil {
		t.Fatal("Expected result to not be nil")
	}

	if len(result.Include) != 1 {
		t.Fatalf("Expected 1 include property, got %d", len(result.Include))
	}

	if len(result.Exclude) != 0 {
		t.Fatalf("Expected 0 exclude properties, got %d", len(result.Exclude))
	}

	prop := result.Include[0]
	if prop.Name != "env" {
		t.Errorf("Expected name to be 'env', got %s", prop.Name)
	}
	if prop.Source == nil || *prop.Source != "custom" {
		t.Errorf("Expected source to be 'custom', got %v", prop.Source)
	}
	if len(prop.PropertyValues) != 1 || prop.PropertyValues[0] != "prod" {
		t.Errorf("Expected property_values to be ['prod'], got %v", prop.PropertyValues)
	}
}

func TestExpandRepositoryPropertyConditions_IncludeAndExclude(t *testing.T) {
	input := []any{
		map[string]any{
			"include": []any{
				map[string]any{
					"name":            "env",
					"source":          "custom",
					"property_values": []any{"prod"},
				},
			},
			"exclude": []any{
				map[string]any{
					"name":            "tier",
					"source":          "system",
					"property_values": []any{"free"},
				},
			},
		},
	}

	result := expandRepositoryPropertyConditions(input)

	if result == nil {
		t.Fatal("Expected result to not be nil")
	}

	if len(result.Include) != 1 {
		t.Fatalf("Expected 1 include property, got %d", len(result.Include))
	}

	if len(result.Exclude) != 1 {
		t.Fatalf("Expected 1 exclude property, got %d", len(result.Exclude))
	}

	includeProp := result.Include[0]
	if includeProp.Name != "env" {
		t.Errorf("Expected include name to be 'env', got %s", includeProp.Name)
	}
	if includeProp.Source == nil || *includeProp.Source != "custom" {
		t.Errorf("Expected include source to be 'custom', got %v", includeProp.Source)
	}

	excludeProp := result.Exclude[0]
	if excludeProp.Name != "tier" {
		t.Errorf("Expected exclude name to be 'tier', got %s", excludeProp.Name)
	}
	if excludeProp.Source == nil || *excludeProp.Source != "system" {
		t.Errorf("Expected exclude source to be 'system', got %v", excludeProp.Source)
	}
}

func TestExpandRepositoryPropertyConditions_MultipleValues(t *testing.T) {
	input := []any{
		map[string]any{
			"include": []any{
				map[string]any{
					"name":            "env",
					"source":          "custom",
					"property_values": []any{"prod", "staging", "dev"},
				},
			},
			"exclude": []any{},
		},
	}

	result := expandRepositoryPropertyConditions(input)

	if result == nil {
		t.Fatal("Expected result to not be nil")
	}

	if len(result.Include) != 1 {
		t.Fatalf("Expected 1 include property, got %d", len(result.Include))
	}

	prop := result.Include[0]
	if len(prop.PropertyValues) != 3 {
		t.Fatalf("Expected 3 property values, got %d", len(prop.PropertyValues))
	}

	expectedValues := []string{"prod", "staging", "dev"}
	for i, expected := range expectedValues {
		if prop.PropertyValues[i] != expected {
			t.Errorf("Expected property_values[%d] to be '%s', got '%s'", i, expected, prop.PropertyValues[i])
		}
	}
}

func TestExpandRepositoryPropertyConditions_MultipleProperties(t *testing.T) {
	input := []any{
		map[string]any{
			"include": []any{
				map[string]any{
					"name":            "env",
					"source":          "custom",
					"property_values": []any{"prod"},
				},
				map[string]any{
					"name":            "tier",
					"source":          "system",
					"property_values": []any{"premium", "enterprise"},
				},
			},
			"exclude": []any{},
		},
	}

	result := expandRepositoryPropertyConditions(input)

	if result == nil {
		t.Fatal("Expected result to not be nil")
	}

	if len(result.Include) != 2 {
		t.Fatalf("Expected 2 include properties, got %d", len(result.Include))
	}

	// Check first property
	if result.Include[0].Name != "env" {
		t.Errorf("Expected first property name to be 'env', got %s", result.Include[0].Name)
	}
	if len(result.Include[0].PropertyValues) != 1 {
		t.Errorf("Expected first property to have 1 value, got %d", len(result.Include[0].PropertyValues))
	}

	// Check second property
	if result.Include[1].Name != "tier" {
		t.Errorf("Expected second property name to be 'tier', got %s", result.Include[1].Name)
	}
	if len(result.Include[1].PropertyValues) != 2 {
		t.Errorf("Expected second property to have 2 values, got %d", len(result.Include[1].PropertyValues))
	}
}

func TestExpandRepositoryPropertyConditions_NilElements(t *testing.T) {
	input := []any{
		map[string]any{
			"include": []any{
				map[string]any{
					"name":            "env",
					"source":          "custom",
					"property_values": []any{"prod"},
				},
				nil,
				map[string]any{
					"name":            "tier",
					"source":          "system",
					"property_values": []any{"premium"},
				},
			},
			"exclude": []any{},
		},
	}

	result := expandRepositoryPropertyConditions(input)

	if result == nil {
		t.Fatal("Expected result to not be nil")
	}

	// Nil element should be skipped, so we should have 2 properties
	if len(result.Include) != 2 {
		t.Fatalf("Expected 2 include properties (nil skipped), got %d", len(result.Include))
	}

	if result.Include[0].Name != "env" {
		t.Errorf("Expected first property name to be 'env', got %s", result.Include[0].Name)
	}
	if result.Include[1].Name != "tier" {
		t.Errorf("Expected second property name to be 'tier', got %s", result.Include[1].Name)
	}
}

func TestExpandRepositoryPropertyConditions_NilPropertyValues(t *testing.T) {
	input := []any{
		map[string]any{
			"include": []any{
				map[string]any{
					"name":            "env",
					"source":          "custom",
					"property_values": []any{"prod", nil, "staging"},
				},
			},
			"exclude": []any{},
		},
	}

	result := expandRepositoryPropertyConditions(input)

	if result == nil {
		t.Fatal("Expected result to not be nil")
	}

	if len(result.Include) != 1 {
		t.Fatalf("Expected 1 include property, got %d", len(result.Include))
	}

	prop := result.Include[0]
	// Nil value should be skipped, so we should have 2 values
	if len(prop.PropertyValues) != 2 {
		t.Fatalf("Expected 2 property values (nil skipped), got %d", len(prop.PropertyValues))
	}

	if prop.PropertyValues[0] != "prod" {
		t.Errorf("Expected first value to be 'prod', got '%s'", prop.PropertyValues[0])
	}
	if prop.PropertyValues[1] != "staging" {
		t.Errorf("Expected second value to be 'staging', got '%s'", prop.PropertyValues[1])
	}
}

func TestFlattenRulesetRepositoryPropertyTargetParameters(t *testing.T) {
	input := []*github.RepositoryRulesetRepositoryPropertyTargetParameters{
		{
			Name:           "env",
			Source:         new("custom"),
			PropertyValues: []string{"prod", "staging"},
		},
		{
			Name:           "tier",
			Source:         new("system"),
			PropertyValues: []string{"premium"},
		},
	}

	result := flattenRulesetRepositoryPropertyTargetParameters(input)

	if len(result) != 2 {
		t.Fatalf("Expected 2 properties, got %d", len(result))
	}

	// Check first property
	if result[0]["name"] != "env" {
		t.Errorf("Expected first property name to be 'env', got %v", result[0]["name"])
	}
	if result[0]["source"] != "custom" {
		t.Errorf("Expected first property source to be 'custom', got %v", result[0]["source"])
	}
	values := result[0]["property_values"].([]string)
	if len(values) != 2 || values[0] != "prod" || values[1] != "staging" {
		t.Errorf("Expected first property values to be ['prod', 'staging'], got %v", values)
	}

	// Check second property
	if result[1]["name"] != "tier" {
		t.Errorf("Expected second property name to be 'tier', got %v", result[1]["name"])
	}
}

func TestFlattenRulesetRepositoryPropertyTargetParameters_EmptySource(t *testing.T) {
	input := []*github.RepositoryRulesetRepositoryPropertyTargetParameters{
		{
			Name:           "env",
			Source:         new(""),
			PropertyValues: []string{"prod"},
		},
	}

	result := flattenRulesetRepositoryPropertyTargetParameters(input)

	if len(result) != 1 {
		t.Fatalf("Expected 1 property, got %d", len(result))
	}

	// Empty source should default to "custom"
	if result[0]["source"] != "custom" {
		t.Errorf("Expected source to default to 'custom', got %v", result[0]["source"])
	}
}

func TestRoundTripRepositoryPropertyConditions(t *testing.T) {
	input := []any{
		map[string]any{
			"include": []any{
				map[string]any{
					"name":            "env",
					"source":          "custom",
					"property_values": []any{"prod", "staging"},
				},
				map[string]any{
					"name":            "tier",
					"source":          "system",
					"property_values": []any{"premium"},
				},
			},
			"exclude": []any{
				map[string]any{
					"name":            "region",
					"source":          "custom",
					"property_values": []any{"us-west"},
				},
			},
		},
	}

	// Expand
	expanded := expandRepositoryPropertyConditions(input)

	// Flatten
	flattenedInclude := flattenRulesetRepositoryPropertyTargetParameters(expanded.Include)
	flattenedExclude := flattenRulesetRepositoryPropertyTargetParameters(expanded.Exclude)

	// Verify include
	if len(flattenedInclude) != 2 {
		t.Fatalf("Expected 2 include properties after round trip, got %d", len(flattenedInclude))
	}

	if flattenedInclude[0]["name"] != "env" {
		t.Errorf("Expected first include name to be 'env', got %v", flattenedInclude[0]["name"])
	}
	if flattenedInclude[0]["source"] != "custom" {
		t.Errorf("Expected first include source to be 'custom', got %v", flattenedInclude[0]["source"])
	}
	includeValues := flattenedInclude[0]["property_values"].([]string)
	if len(includeValues) != 2 || includeValues[0] != "prod" || includeValues[1] != "staging" {
		t.Errorf("Expected first include values to be ['prod', 'staging'], got %v", includeValues)
	}

	if flattenedInclude[1]["name"] != "tier" {
		t.Errorf("Expected second include name to be 'tier', got %v", flattenedInclude[1]["name"])
	}

	// Verify exclude
	if len(flattenedExclude) != 1 {
		t.Fatalf("Expected 1 exclude property after round trip, got %d", len(flattenedExclude))
	}

	if flattenedExclude[0]["name"] != "region" {
		t.Errorf("Expected exclude name to be 'region', got %v", flattenedExclude[0]["name"])
	}
	excludeValues := flattenedExclude[0]["property_values"].([]string)
	if len(excludeValues) != 1 || excludeValues[0] != "us-west" {
		t.Errorf("Expected exclude values to be ['us-west'], got %v", excludeValues)
	}
}

func TestFlattenRulesetRepositoryPropertyTargetParameters_Empty(t *testing.T) {
	// Test nil input
	result := flattenRulesetRepositoryPropertyTargetParameters(nil)
	if len(result) != 0 {
		t.Errorf("Expected empty slice for nil input, got %v", result)
	}

	// Test empty slice input
	result = flattenRulesetRepositoryPropertyTargetParameters([]*github.RepositoryRulesetRepositoryPropertyTargetParameters{})
	if len(result) != 0 {
		t.Errorf("Expected empty slice for empty input, got %v", result)
	}
}

func TestFlattenRulesetRepositoryPropertyTargetParameters_SingleProperty(t *testing.T) {
	input := []*github.RepositoryRulesetRepositoryPropertyTargetParameters{
		{
			Name:           "env",
			Source:         new("system"),
			PropertyValues: []string{"prod", "staging"},
		},
	}

	result := flattenRulesetRepositoryPropertyTargetParameters(input)

	if len(result) != 1 {
		t.Fatalf("Expected 1 property, got %d", len(result))
	}

	if result[0]["name"] != "env" {
		t.Errorf("Expected name to be 'env', got %v", result[0]["name"])
	}

	if result[0]["source"] != "system" {
		t.Errorf("Expected source to be 'system', got %v", result[0]["source"])
	}

	values := result[0]["property_values"].([]string)
	if len(values) != 2 || values[0] != "prod" || values[1] != "staging" {
		t.Errorf("Expected property_values to be ['prod', 'staging'], got %v", values)
	}
}

func TestFlattenRulesetRepositoryPropertyTargetParameters_NilSource(t *testing.T) {
	input := []*github.RepositoryRulesetRepositoryPropertyTargetParameters{
		{
			Name:           "env",
			Source:         nil,
			PropertyValues: []string{"prod"},
		},
	}

	result := flattenRulesetRepositoryPropertyTargetParameters(input)

	if len(result) != 1 {
		t.Fatalf("Expected 1 property, got %d", len(result))
	}

	// Nil source should default to "custom"
	if result[0]["source"] != "custom" {
		t.Errorf("Expected source to default to 'custom' for nil source, got %v", result[0]["source"])
	}
}

func TestFlattenRulesetRepositoryPropertyTargetParameters_EmptyPropertyValues(t *testing.T) {
	input := []*github.RepositoryRulesetRepositoryPropertyTargetParameters{
		{
			Name:           "env",
			Source:         new("custom"),
			PropertyValues: []string{},
		},
	}

	result := flattenRulesetRepositoryPropertyTargetParameters(input)

	if len(result) != 1 {
		t.Fatalf("Expected 1 property, got %d", len(result))
	}

	values := result[0]["property_values"].([]string)
	if len(values) != 0 {
		t.Errorf("Expected property_values to be empty array, got %v", values)
	}
}

func TestFlattenRulesetRepositoryPropertyTargetParameters_NilPropertyValues(t *testing.T) {
	input := []*github.RepositoryRulesetRepositoryPropertyTargetParameters{
		{
			Name:           "env",
			Source:         new("custom"),
			PropertyValues: nil,
		},
	}

	result := flattenRulesetRepositoryPropertyTargetParameters(input)

	if len(result) != 1 {
		t.Fatalf("Expected 1 property, got %d", len(result))
	}

	// Nil PropertyValues should be preserved in the map
	values := result[0]["property_values"]
	if values != nil {
		if valSlice, ok := values.([]string); ok && len(valSlice) != 0 {
			t.Errorf("Expected property_values to be nil or empty, got %v", values)
		}
	}
}

func TestFixReviewerStringIDs(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected string
	}{
		{
			name:     "converts quoted integer id to unquoted",
			input:    `{"id": "12345", "type": "Team"}`,
			expected: `{"id":12345, "type": "Team"}`,
		},
		{
			name:     "leaves unquoted integer id unchanged",
			input:    `{"id": 12345, "type": "Team"}`,
			expected: `{"id": 12345, "type": "Team"}`,
		},
		{
			name:     "converts id without spaces after colon",
			input:    `{"id":"99999","type":"Team"}`,
			expected: `{"id":99999,"type":"Team"}`,
		},
		{
			name:     "handles multiple reviewer ids",
			input:    `[{"id": "111"}, {"id": "222"}]`,
			expected: `[{"id":111}, {"id":222}]`,
		},
		{
			name:     "does not convert non-digit string ids",
			input:    `{"id": "abc123", "type": "Team"}`,
			expected: `{"id": "abc123", "type": "Team"}`,
		},
		{
			name:     "does not convert empty string ids",
			input:    `{"id": "", "type": "Team"}`,
			expected: `{"id": "", "type": "Team"}`,
		},
		{
			name:     "handles full ruleset response with nested reviewer",
			input:    `{"id":1,"name":"test","rules":[{"type":"pull_request","parameters":{"required_reviewers":[{"reviewer":{"id":"12345","type":"Team"},"minimum_approvals":1}]}}]}`,
			expected: `{"id":1,"name":"test","rules":[{"type":"pull_request","parameters":{"required_reviewers":[{"reviewer":{"id":12345,"type":"Team"},"minimum_approvals":1}]}}]}`,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			result := fixReviewerStringIDs([]byte(tc.input))
			if string(result) != tc.expected {
				t.Errorf("fixReviewerStringIDs(%q) = %q, want %q", tc.input, string(result), tc.expected)
			}
		})
	}
}

func TestFixReviewerStringIDs_UnmarshalRoundTrip(t *testing.T) {
	// Simulate the actual GitHub API response that causes the bug:
	// reviewer.id is returned as a JSON string instead of a number.
	apiResponse := `{
		"id": 999,
		"name": "test-ruleset",
		"target": "branch",
		"source_type": "Repository",
		"source": "test-repo",
		"enforcement": "active",
		"rules": [
			{
				"type": "pull_request",
				"parameters": {
					"dismiss_stale_reviews_on_push": false,
					"require_code_owner_review": false,
					"require_last_push_approval": false,
					"required_approving_review_count": 1,
					"required_review_thread_resolution": false,
					"required_reviewers": [
						{
							"reviewer": {
								"id": "12345",
								"type": "Team"
							},
							"file_patterns": ["*.go"],
							"minimum_approvals": 1
						}
					]
				}
			}
		]
	}`

	// Without the fix, this would fail with:
	// json: cannot unmarshal string into Go struct field
	// RulesetReviewer.id of type int64
	fixed := fixReviewerStringIDs([]byte(apiResponse))

	var rs github.RepositoryRuleset
	if err := json.Unmarshal(fixed, &rs); err != nil {
		t.Fatalf("Failed to unmarshal fixed response: %v", err)
	}

	if rs.GetID() != 999 {
		t.Errorf("Expected ruleset ID 999, got %d", rs.GetID())
	}

	if rs.Rules == nil || rs.Rules.PullRequest == nil {
		t.Fatal("Expected pull_request rule to be parsed")
	}

	reviewers := rs.Rules.PullRequest.RequiredReviewers
	if len(reviewers) != 1 {
		t.Fatalf("Expected 1 required reviewer, got %d", len(reviewers))
	}

	if reviewers[0].Reviewer == nil {
		t.Fatal("Expected reviewer to be non-nil")
	}

	if reviewers[0].Reviewer.GetID() != 12345 {
		t.Errorf("Expected reviewer ID 12345, got %d", reviewers[0].Reviewer.GetID())
	}

	if reviewers[0].Reviewer.GetType() == nil || *reviewers[0].Reviewer.GetType() != github.RulesetReviewerTypeTeam {
		t.Errorf("Expected reviewer type Team, got %v", reviewers[0].Reviewer.GetType())
	}
}