api_test.go

package matcher

import (
	"context"
	"os"
	"regexp"
	"testing"
	"time"
)

func TestNewMatcherEngineWithDefaults(t *testing.T) {
	// Create temporary directory for persistence
	tempDir, err := os.MkdirTemp("", "matcher-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Errorf("NewMatcherEngineWithDefaults failed: %v", err)
	}
	defer engine.Close()

	if engine == nil {
		t.Error("Expected non-nil engine")
	}
}

func TestAPIUpdateRule(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "matcher-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create engine: %v", err)
	}
	defer engine.Close()

	// Add dimension configurations
	regionConfig := NewDimensionConfig("region", 0, false)
	regionConfig.SetWeight(MatchTypeEqual, 10.0)
	err = engine.AddDimension(regionConfig)
	if err != nil {
		t.Fatalf("Failed to add region dimension: %v", err)
	}

	envConfig := NewDimensionConfig("env", 1, false)
	envConfig.SetWeight(MatchTypeEqual, 8.0)
	err = engine.AddDimension(envConfig)
	if err != nil {
		t.Fatalf("Failed to add env dimension: %v", err)
	}

	// Add a rule first
	originalRule := NewRule("api-update-test").
		Dimension("region", "us-west", MatchTypeEqual).
		Dimension("env", "prod", MatchTypeEqual).
		Build()

	if err := engine.AddRule(originalRule); err != nil {
		t.Fatalf("Failed to add rule: %v", err)
	}

	// Verify the original rule works
	query := &QueryRule{
		Values: map[string]string{
			"region": "us-west",
			"env":    "prod",
		},
	}

	matches, err := engine.FindAllMatches(query)
	if err != nil {
		t.Fatalf("FindAllMatches failed: %v", err)
	}

	if len(matches) != 1 {
		t.Fatalf("Expected 1 match for original rule, got %d", len(matches))
	}

	if matches[0].Rule.ID != "api-update-test" {
		t.Errorf("Expected rule 'api-update-test', got '%s'", matches[0].Rule.ID)
	}

	// Update the rule with different dimensions
	updatedRule := NewRule("api-update-test").
		Dimension("region", "us-east", MatchTypeEqual).
		Dimension("env", "staging", MatchTypeEqual).
		Build()

	if err := engine.UpdateRule(updatedRule); err != nil {
		t.Errorf("UpdateRule failed: %v", err)
	}

	// Verify the original query no longer matches
	matches, err = engine.FindAllMatches(query)
	if err != nil {
		t.Fatalf("FindAllMatches failed after update: %v", err)
	}

	if len(matches) != 0 {
		t.Errorf("Expected 0 matches for original query after update, got %d", len(matches))
	}

	// Verify the updated rule works with new query
	updatedQuery := &QueryRule{
		Values: map[string]string{
			"region": "us-east",
			"env":    "staging",
		},
	}

	matches, err = engine.FindAllMatches(updatedQuery)
	if err != nil {
		t.Fatalf("FindAllMatches failed for updated query: %v", err)
	}

	if len(matches) != 1 {
		t.Fatalf("Expected 1 match for updated rule, got %d", len(matches))
	}

	if matches[0].Rule.ID != "api-update-test" {
		t.Errorf("Expected updated rule 'api-update-test', got '%s'", matches[0].Rule.ID)
	}

	// Test updating a non-existent rule
	nonExistentRule := NewRule("non-existent").
		Dimension("region", "us-west", MatchTypeEqual).
		Build()

	// This should fail - updateRule should only update existing rules
	if err := engine.UpdateRule(nonExistentRule); err == nil {
		t.Error("UpdateRule should return an error for non-existent rules")
	}

	// Verify the non-existent rule was not added
	nonExistentQuery := &QueryRule{
		Values: map[string]string{
			"region": "us-west",
		},
	}

	matches, err = engine.FindAllMatches(nonExistentQuery)
	if err != nil {
		t.Fatalf("FindAllMatches failed for non-existent rule query: %v", err)
	}

	// Should not find the rule since it was not created
	found := false
	for _, match := range matches {
		if match.Rule.ID == "non-existent" {
			found = true
			break
		}
	}

	if found {
		t.Error("Non-existent rule should not have been created by UpdateRule")
	}
}

func TestAPIUpdateRuleStatus(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "matcher-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create engine: %v", err)
	}
	defer engine.Close()

	// Add dimension configuration
	regionConfig := NewDimensionConfig("region", 0, false)
	regionConfig.SetWeight(MatchTypeEqual, 10.0)
	err = engine.AddDimension(regionConfig)
	if err != nil {
		t.Fatalf("Failed to add region dimension: %v", err)
	}

	// Add a rule
	rule := NewRule("status-update-test").
		Dimension("region", "us-west", MatchTypeEqual).
		Build()

	if err := engine.AddRule(rule); err != nil {
		t.Fatalf("Failed to add rule: %v", err)
	}

	// Update the rule status to draft
	if err := engine.UpdateRuleStatus("status-update-test", RuleStatusDraft); err != nil {
		t.Errorf("UpdateRuleStatus failed: %v", err)
	}

	// Verify the rule was updated
	updatedRule, err := engine.GetRule("status-update-test")
	if err != nil {
		t.Fatalf("Failed to get updated rule: %v", err)
	}

	if updatedRule.Status != RuleStatusDraft {
		t.Errorf("Expected status %s, got %s", RuleStatusDraft, updatedRule.Status)
	}

	// Verify other fields remained unchanged
	if updatedRule.ID != "status-update-test" {
		t.Errorf("Expected ID 'status-update-test', got '%s'", updatedRule.ID)
	}

	if len(updatedRule.Dimensions) != 1 {
		t.Errorf("Expected 1 dimension, got %d", len(updatedRule.Dimensions))
	}

	if dim, ok := updatedRule.Dimensions["region"]; !ok || dim.DimensionName != "region" {
		t.Errorf("Expected dimension 'region' to be present and named 'region'")
	}

	// Test updating non-existent rule
	err = engine.UpdateRuleStatus("non-existent", RuleStatusWorking)
	if err == nil {
		t.Error("Expected error when updating non-existent rule status")
	}
}

func TestAPIUpdateRuleMetadata(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "matcher-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create engine: %v", err)
	}
	defer engine.Close()

	// Add dimension configuration
	regionConfig := NewDimensionConfig("region", 0, false)
	regionConfig.SetWeight(MatchTypeEqual, 10.0)
	err = engine.AddDimension(regionConfig)
	if err != nil {
		t.Fatalf("Failed to add region dimension: %v", err)
	}

	// Add a rule with initial metadata
	rule := NewRule("metadata-update-test").
		Dimension("region", "us-west", MatchTypeEqual).
		Build()

	rule.Metadata = map[string]string{
		"owner":       "team-alpha",
		"description": "original description",
	}

	if err := engine.AddRule(rule); err != nil {
		t.Fatalf("Failed to add rule: %v", err)
	}

	// Update the rule metadata
	newMetadata := map[string]string{
		"owner":       "team-beta",
		"description": "updated description",
		"priority":    "high",
	}

	if err := engine.UpdateRuleMetadata("metadata-update-test", newMetadata); err != nil {
		t.Errorf("UpdateRuleMetadata failed: %v", err)
	}

	// Verify the rule was updated
	updatedRule, err := engine.GetRule("metadata-update-test")
	if err != nil {
		t.Fatalf("Failed to get updated rule: %v", err)
	}

	if updatedRule.Metadata["owner"] != "team-beta" {
		t.Errorf("Expected owner 'team-beta', got '%s'", updatedRule.Metadata["owner"])
	}

	if updatedRule.Metadata["description"] != "updated description" {
		t.Errorf("Expected description 'updated description', got '%s'", updatedRule.Metadata["description"])
	}

	if updatedRule.Metadata["priority"] != "high" {
		t.Errorf("Expected priority 'high', got '%s'", updatedRule.Metadata["priority"])
	}

	// Verify other fields remained unchanged
	if updatedRule.ID != "metadata-update-test" {
		t.Errorf("Expected ID 'metadata-update-test', got '%s'", updatedRule.ID)
	}

	if len(updatedRule.Dimensions) != 1 {
		t.Errorf("Expected 1 dimension, got %d", len(updatedRule.Dimensions))
	}

	// Test updating non-existent rule
	err = engine.UpdateRuleMetadata("non-existent", newMetadata)
	if err == nil {
		t.Error("Expected error when updating non-existent rule metadata")
	}
}

func TestAPIGetRule(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "matcher-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create engine: %v", err)
	}
	defer engine.Close()

	// Add dimension configuration
	regionConfig := NewDimensionConfig("region", 0, false)
	regionConfig.SetWeight(MatchTypeEqual, 10.0)
	err = engine.AddDimension(regionConfig)
	if err != nil {
		t.Fatalf("Failed to add region dimension: %v", err)
	}

	// Add a rule
	originalRule := NewRule("get-rule-test").
		Dimension("region", "us-west", MatchTypeEqual).
		Build()

	originalRule.Metadata = map[string]string{
		"owner": "team-alpha",
		"type":  "routing",
	}
	originalRule.Status = RuleStatusWorking

	if err := engine.AddRule(originalRule); err != nil {
		t.Fatalf("Failed to add rule: %v", err)
	}

	// Get the rule
	retrievedRule, err := engine.GetRule("get-rule-test")
	if err != nil {
		t.Fatalf("GetRule failed: %v", err)
	}

	// Verify all fields
	if retrievedRule.ID != "get-rule-test" {
		t.Errorf("Expected ID 'get-rule-test', got '%s'", retrievedRule.ID)
	}

	if retrievedRule.Status != RuleStatusWorking {
		t.Errorf("Expected status %s, got %s", RuleStatusWorking, retrievedRule.Status)
	}

	if len(retrievedRule.Dimensions) != 1 {
		t.Errorf("Expected 1 dimension, got %d", len(retrievedRule.Dimensions))
	}

	if dim := retrievedRule.GetDimensionValue("region"); dim == nil {
		t.Errorf("Expected dimension 'region' to exist")
	} else {
		if dim.Value != "us-west" {
			t.Errorf("Expected value 'us-west', got '%s'", dim.Value)
		}
	}

	if retrievedRule.Metadata["owner"] != "team-alpha" {
		t.Errorf("Expected owner 'team-alpha', got '%s'", retrievedRule.Metadata["owner"])
	}

	if retrievedRule.Metadata["type"] != "routing" {
		t.Errorf("Expected type 'routing', got '%s'", retrievedRule.Metadata["type"])
	}

	// Test getting non-existent rule
	_, err = engine.GetRule("non-existent")
	if err == nil {
		t.Error("Expected error when getting non-existent rule")
	}

	// Test that the returned rule is a copy (modifying it shouldn't affect the original)
	retrievedRule.Metadata["owner"] = "modified"

	// Get the rule again to verify it wasn't modified
	againRule, err := engine.GetRule("get-rule-test")
	if err != nil {
		t.Fatalf("GetRule failed on second call: %v", err)
	}

	if againRule.Metadata["owner"] != "team-alpha" {
		t.Error("Rule was modified when it should have been a copy")
	}
}

func TestAPIDeleteRule(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "matcher-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create engine: %v", err)
	}
	defer engine.Close()

	// Add dimension config first
	config := NewDimensionConfig("region", 0, false)
	if err := engine.AddDimension(config); err != nil {
		t.Fatalf("Failed to add dimension config: %v", err)
	}

	// Add a rule first
	rule := NewRule("api-delete-test").
		Dimension("region", "us-west", MatchTypeEqual).
		Build()
	if err := engine.AddRule(rule); err != nil {
		t.Fatalf("Failed to add rule: %v", err)
	}

	// Delete the rule
	if err := engine.DeleteRule("api-delete-test"); err != nil {
		t.Errorf("DeleteRule failed: %v", err)
	}
}

func TestAPIAddDimension(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "matcher-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create engine: %v", err)
	}
	defer engine.Close()

	// Add a dimension
	dim := NewDimensionConfig("api-test-dim", 100, false)
	if err := engine.AddDimension(dim); err != nil {
		t.Errorf("AddDimension failed: %v", err)
	}
}

func TestAPIFindBestMatch(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "matcher-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create engine: %v", err)
	}
	defer engine.Close()

	// Add dimension config first
	config := NewDimensionConfig("region", 0, false)
	if err := engine.AddDimension(config); err != nil {
		t.Fatalf("Failed to add dimension config: %v", err)
	}

	// Add a rule
	rule := NewRule("best-match-test").
		Dimension("region", "us-west", MatchTypeEqual).
		Build()
	if err := engine.AddRule(rule); err != nil {
		t.Fatalf("Failed to add rule: %v", err)
	}

	// Find best match
	query := CreateQuery(map[string]string{"region": "us-west"})
	result, err := engine.FindBestMatch(query)
	if err != nil {
		t.Errorf("FindBestMatch failed: %v", err)
	}
	if result == nil {
		t.Error("Expected match result")
	}
	if result != nil && result.Rule.ID != "best-match-test" {
		t.Errorf("Expected rule ID 'best-match-test', got '%s'", result.Rule.ID)
	}
}

func TestAPIFindAllMatches(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "matcher-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create engine: %v", err)
	}
	defer engine.Close()

	// Add dimension config to control weights
	config := NewDimensionConfig("region", 0, false)
	if err := engine.AddDimension(config); err != nil {
		t.Fatalf("Failed to add dimension config: %v", err)
	}

	// Add multiple rules with different manual weights to avoid conflicts
	for i := 0; i < 3; i++ {
		rule := NewRule("all-match-test").
			Dimension("region", "us-west", MatchTypeEqual).
			Build()
		rule.ID = rule.ID + string(rune('a'+i)) // Make unique IDs
		// Give each rule a different manual weight to avoid conflicts
		manualWeight := float64(10 + i)
		rule.ManualWeight = &manualWeight
		if err := engine.AddRule(rule); err != nil {
			t.Fatalf("Failed to add rule %d: %v", i, err)
		}
	}

	// Find all matches
	query := CreateQuery(map[string]string{"region": "us-west"})
	results, err := engine.FindAllMatches(query)
	if err != nil {
		t.Errorf("FindAllMatches failed: %v", err)
	}
	if len(results) == 0 {
		t.Error("Expected at least one match")
	}
}

func TestAPIBatchAddRules(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "matcher-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create engine: %v", err)
	}
	defer engine.Close()

	// Add dimension config to control weights
	config := NewDimensionConfig("region", 0, false)
	if err := engine.AddDimension(config); err != nil {
		t.Fatalf("Failed to add dimension config: %v", err)
	}

	// Create batch rules
	var rules []*Rule
	for i := 0; i < 5; i++ {
		rule := NewRule("batch-test").
			Dimension("region", "us-west", MatchTypeEqual).
			Build()
		rule.ID = rule.ID + string(rune('a'+i)) // Make unique IDs
		// Give each rule a different manual weight to avoid conflicts
		manualWeight := float64(5 + i)
		rule.ManualWeight = &manualWeight
		rules = append(rules, rule)
	}

	// Batch add rules
	err = engine.BatchAddRules(rules)
	if err != nil {
		t.Errorf("BatchAddRules failed: %v", err)
	}
}

func TestAPIAddSimpleRule(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "matcher-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create engine: %v", err)
	}
	defer engine.Close()

	// Add dimension configurations before adding rule
	regionDim := NewDimensionConfig("region", 0, false)
	regionDim.SetWeight(MatchTypeEqual, 10.0)
	if err := engine.AddDimension(regionDim); err != nil {
		t.Fatalf("Failed to add region dimension: %v", err)
	}

	envDim := NewDimensionConfig("env", 1, false)
	envDim.SetWeight(MatchTypeEqual, 5.0)
	if err := engine.AddDimension(envDim); err != nil {
		t.Fatalf("Failed to add env dimension: %v", err)
	}

	// Add simple rule
	dimensions := map[string]string{"region": "us-west", "env": "prod"}
	manualWeight := 5.0

	err = engine.AddSimpleRule("simple-test", dimensions, &manualWeight)
	if err != nil {
		t.Errorf("AddSimpleRule failed: %v", err)
	}
}

func TestAPIAddAnyRule(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "matcher-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create engine: %v", err)
	}
	defer engine.Close()

	// Add dimension configurations before adding rule
	dimensionNames := []string{"region", "env", "service"}
	for i, name := range dimensionNames {
		dim := NewDimensionConfig(name, i, false)
		dim.SetWeight(MatchTypeAny, 5.0)
		if err := engine.AddDimension(dim); err != nil {
			t.Fatalf("Failed to add %s dimension: %v", name, err)
		}
	}

	// Add any rule
	manualWeight := 10.0

	err = engine.AddAnyRule("any-test", dimensionNames, manualWeight)
	if err != nil {
		t.Errorf("AddAnyRule failed: %v", err)
	}
}

func TestAPIGetStats(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "matcher-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create engine: %v", err)
	}
	defer engine.Close()

	// Get stats
	stats := engine.GetStats()
	if stats == nil {
		t.Error("GetStats returned nil")
	}
}

func TestAPIValidateRule(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "matcher-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create engine: %v", err)
	}
	defer engine.Close()

	// Validate a good rule
	rule := NewRule("validate-test").
		Dimension("region", "us-west", MatchTypeEqual).
		Build()

	err = engine.ValidateRule(rule)
	if err != nil {
		t.Errorf("ValidateRule failed for valid rule: %v", err)
	}
}

func TestGenerateDefaultNodeID(t *testing.T) {
	// Test that function is publicly accessible
	nodeID := GenerateDefaultNodeID()

	// Check that result is not empty
	if nodeID == "" {
		t.Fatal("GenerateDefaultNodeID returned empty string")
	}

	// Check format: hostname-6digits
	pattern := regexp.MustCompile(`^.+-\d{6}$`)
	if !pattern.MatchString(nodeID) {
		t.Errorf("NodeID format incorrect. Expected hostname-6digits, got: %s", nodeID)
	}

	// Test that it contains hostname
	hostname, err := os.Hostname()
	if err != nil {
		hostname = "unknown"
	}

	expectedPrefix := hostname + "-"
	if len(nodeID) < len(expectedPrefix) || nodeID[:len(expectedPrefix)] != expectedPrefix {
		t.Errorf("NodeID should start with '%s', got: %s", expectedPrefix, nodeID)
	}

	// Test that suffix is exactly 6 digits
	suffix := nodeID[len(expectedPrefix):]
	if len(suffix) != 6 {
		t.Errorf("Suffix should be 6 digits, got %d digits: %s", len(suffix), suffix)
	}

	// Test that each call generates different IDs (randomness)
	nodeID2 := GenerateDefaultNodeID()
	if nodeID == nodeID2 {
		t.Log("Warning: Two consecutive calls generated the same nodeID. This is unlikely but possible due to randomness.")
	}

	// Test multiple calls to ensure format consistency
	for i := 0; i < 10; i++ {
		testNodeID := GenerateDefaultNodeID()
		if !pattern.MatchString(testNodeID) {
			t.Errorf("Iteration %d: NodeID format incorrect: %s", i, testNodeID)
		}
	}
}

// ========================================
// MERGED TESTS FROM additional_coverage_test.go and api_dynamic_configs_test.go
// ========================================

func TestDimensionConfig_GetWeight(t *testing.T) {
	// Test case 1: GetWeight with defined match type weights
	config := NewDimensionConfig("test", 0, false)
	config.SetWeight(MatchTypeEqual, 10.0)
	config.SetWeight(MatchTypePrefix, 7.0)
	config.SetWeight(MatchTypeAny, 2.0)

	// Test getting defined weights
	if weight, exists := config.GetWeight(MatchTypeEqual); !exists || weight != 10.0 {
		t.Errorf("Expected weight 10.0 for Equal match type, got %.1f (exists: %v)", weight, exists)
	}

	if weight, exists := config.GetWeight(MatchTypePrefix); !exists || weight != 7.0 {
		t.Errorf("Expected weight 7.0 for Prefix match type, got %.1f (exists: %v)", weight, exists)
	}

	if weight, exists := config.GetWeight(MatchTypeAny); !exists || weight != 2.0 {
		t.Errorf("Expected weight 2.0 for Any match type, got %.1f (exists: %v)", weight, exists)
	}

	// Test getting undefined weight (should return 0.0, no default weight anymore)
	if weight, exists := config.GetWeight(MatchTypeSuffix); exists || weight != 0.0 {
		t.Errorf("Expected 0.0 for undefined Suffix match type, got %.1f (exists: %v)", weight, exists)
	}

	// Test case 2: GetWeight with no defined weights (all should return 0.0)
	emptyConfig := NewDimensionConfig("empty", 1, true)

	matchTypes := []MatchType{MatchTypeEqual, MatchTypePrefix, MatchTypeSuffix, MatchTypeAny}
	for _, mt := range matchTypes {
		if weight, exists := emptyConfig.GetWeight(mt); exists || weight != 0.0 {
			t.Errorf("Expected 0.0 for %s match type, got %.1f (exists: %v)", mt, weight, exists)
		}
	}

	// Test case 3: GetWeight after setting and overriding weights
	overrideConfig := NewDimensionConfig("override", 2, false)

	// Set initial weight
	overrideConfig.SetWeight(MatchTypeEqual, 8.0)
	if weight, exists := overrideConfig.GetWeight(MatchTypeEqual); !exists || weight != 8.0 {
		t.Errorf("Expected weight 8.0 after initial set, got %.1f (exists: %v)", weight, exists)
	}

	// Override the weight
	overrideConfig.SetWeight(MatchTypeEqual, 12.0)
	if weight, exists := overrideConfig.GetWeight(MatchTypeEqual); !exists || weight != 12.0 {
		t.Errorf("Expected weight 12.0 after override, got %.1f (exists: %v)", weight, exists)
	}

	// Other match types should still return 0.0 (no default weight anymore)
	if weight, exists := overrideConfig.GetWeight(MatchTypePrefix); exists || weight != 0.0 {
		t.Errorf("Expected 0.0 for Prefix after override, got %.1f (exists: %v)", weight, exists)
	}
}

func TestDimensionConfig_SetWeightFunction(t *testing.T) {
	config := NewDimensionConfig("test", 0, false)

	// Test setting weights for all match types
	weights := map[MatchType]float64{
		MatchTypeEqual:  10.0,
		MatchTypePrefix: 7.5,
		MatchTypeSuffix: 5.0,
		MatchTypeAny:    2.5,
	}

	for matchType, weight := range weights {
		config.SetWeight(matchType, weight)
	}

	// Verify all weights were set correctly
	for matchType, expectedWeight := range weights {
		actualWeight, exists := config.GetWeight(matchType)
		if !exists || actualWeight != expectedWeight {
			t.Errorf("Match type %s: expected weight %.1f, got %.1f (exists: %v)", matchType, expectedWeight, actualWeight, exists)
		}
	}

	// Test that the weights map was properly initialized
	if config.Weights == nil {
		t.Error("Weights map should not be nil after setting weights")
	}

	if len(config.Weights) != 4 {
		t.Errorf("Expected 4 weights in map, got %d", len(config.Weights))
	}
}

func TestNewDimensionConfigWithWeightsFunction(t *testing.T) {
	weights := map[MatchType]float64{
		MatchTypeEqual:  15.0,
		MatchTypePrefix: 10.0,
		MatchTypeSuffix: 8.0,
		MatchTypeAny:    3.0,
	}

	config := NewDimensionConfigWithWeights("weighted", 1, true, weights)

	if config.Name != "weighted" {
		t.Errorf("Expected name 'weighted', got '%s'", config.Name)
	}

	if config.Index != 1 {
		t.Errorf("Expected index 1, got %d", config.Index)
	}

	if !config.Required {
		t.Error("Expected required to be true")
	}

	// Test that unset match types return 0.0 (no DefaultWeight anymore)
	// Note: All match types in the weights map above are set, so we need to test a different approach
	// or verify that GetWeight returns the correct explicit values
	if weight, exists := config.GetWeight(MatchTypePrefix); !exists || weight != 10.0 {
		t.Errorf("Expected MatchTypePrefix weight 10.0 from explicit weights, got %.1f (exists: %v)", weight, exists)
	}

	// Test what happens if we query a type that was explicitly set
	// Since all match types are covered in weights map, this test verifies explicit weights work

	// Test that all weights were set correctly
	for matchType, expectedWeight := range weights {
		actualWeight, exists := config.GetWeight(matchType)
		if !exists || actualWeight != expectedWeight {
			t.Errorf("Match type %s: expected weight %.1f, got %.1f (exists: %v)", matchType, expectedWeight, actualWeight, exists)
		}
	}

	// Test that weights map is properly initialized
	if config.Weights == nil {
		t.Error("Weights map should not be nil")
	}

	if len(config.Weights) != 4 {
		t.Errorf("Expected 4 weights in map, got %d", len(config.Weights))
	}
}

func TestInitializeDimensionFunction(t *testing.T) {
	// Create a temporary directory for this test
	tempDir := t.TempDir()

	// Create matcher engine
	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create matcher engine: %v", err)
	}
	defer engine.Close()

	// Access the forest index to call InitializeDimension
	forestIndex := engine.matcher.getOrCreateForestIndex("", "")

	// Call InitializeDimension (this was at 0% coverage)
	// The function takes a string, not a DimensionConfig
	forestIndex.InitializeDimension("test_dimension")

	// Since InitializeDimension is a no-op, we just verify it doesn't crash
	// and we can still add dimensions normally
	config := NewDimensionConfig("test_dimension", 0, false)
	config.SetWeight(MatchTypeEqual, 20.0)
	config.SetWeight(MatchTypePrefix, 15.0)

	err = engine.AddDimension(config)
	if err != nil {
		t.Fatalf("Failed to add dimension after initialization: %v", err)
	}

	// Test that we can add a rule using this dimension
	rule := NewRule("test-rule").
		Dimension("test_dimension", "test-value", MatchTypeEqual).
		Build()

	err = engine.AddRule(rule)
	if err != nil {
		t.Fatalf("Failed to add rule after dimension initialization: %v", err)
	}

	// Verify we can query using this dimension
	query := &QueryRule{
		Values: map[string]string{
			"test_dimension": "test-value",
		},
	}

	matches, err := engine.FindAllMatches(query)
	if err != nil {
		t.Fatalf("FindAllMatches failed: %v", err)
	}

	if len(matches) != 1 {
		t.Errorf("Expected 1 match, got %d", len(matches))
	}

	if len(matches) > 0 && matches[0].Rule.ID != "test-rule" {
		t.Errorf("Expected rule 'test-rule', got '%s'", matches[0].Rule.ID)
	}
}

func TestDeleteDimensionFunction(t *testing.T) {
	// Create a temporary directory for this test
	tempDir := t.TempDir()

	// Create matcher engine
	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create matcher engine: %v", err)
	}
	defer engine.Close()

	// Add a dimension
	config := NewDimensionConfig("removable", 0, false)
	err = engine.AddDimension(config)
	if err != nil {
		t.Fatalf("Failed to add dimension: %v", err)
	}

	// Add a rule using this dimension
	rule := NewRule("test-rule").
		Dimension("removable", "value", MatchTypeEqual).
		Build()

	err = engine.AddRule(rule)
	if err != nil {
		t.Fatalf("Failed to add rule: %v", err)
	}

	// Verify the rule matches before deletion
	query := &QueryRule{
		Values: map[string]string{
			"removable": "value",
		},
	}

	matches, err := engine.FindAllMatches(query)
	if err != nil {
		t.Fatalf("FindAllMatches failed: %v", err)
	}

	if len(matches) != 1 {
		t.Errorf("Expected 1 match before deletion, got %d", len(matches))
	}

	// Test deleteDimension function (this was at 0% coverage)
	err = engine.matcher.deleteDimension("removable")
	if err != nil {
		t.Fatalf("deleteDimension failed: %v", err)
	}

	// Verify the dimension was removed from the list
	dimensions, err := engine.ListDimensions()
	if err != nil {
		t.Fatalf("ListDimensions failed: %v", err)
	}

	for _, dim := range dimensions {
		if dim.Name == "removable" {
			t.Error("Dimension 'removable' should have been deleted")
		}
	}

	// Test deleting a non-existent dimension (should not error, just do nothing)
	initialDimCount := len(dimensions)
	err = engine.matcher.deleteDimension("non-existent")
	if err != nil {
		t.Fatalf("deleteDimension with non-existent dimension failed: %v", err)
	}

	// Verify dimension count didn't change
	dimensions, err = engine.ListDimensions()
	if err != nil {
		t.Fatalf("ListDimensions failed after deleting non-existent: %v", err)
	}

	if len(dimensions) != initialDimCount {
		t.Errorf("Dimension count changed after deleting non-existent dimension: expected %d, got %d", initialDimCount, len(dimensions))
	}
}

func TestCacheCleanupExpired(t *testing.T) {
	// Create a cache with very short TTL for testing
	cache := NewQueryCache(100, 1*time.Second) // 1 second TTL

	// Create mock results for testing
	mockResult := &MatchResult{
		Rule:        &Rule{ID: "test"},
		TotalWeight: 1.0,
	}

	// Create mock queries
	query1 := &QueryRule{Values: map[string]string{"key": "value1"}}
	query2 := &QueryRule{Values: map[string]string{"key": "value2"}}

	// Add entries with custom TTL - one that will expire quickly
	cache.SetWithTTL(query1, mockResult, 1*time.Millisecond) // Very short TTL
	cache.Set(query2, mockResult)                            // Normal TTL

	initialSize := cache.Size()
	if initialSize != 2 {
		t.Errorf("Expected initial cache size 2, got %d", initialSize)
	}

	// Wait for the first entry to expire
	time.Sleep(10 * time.Millisecond)

	// Call CleanupExpired (this was at 70% coverage, let's get it to 100%)
	cleanedCount := cache.CleanupExpired()
	if cleanedCount != 1 {
		t.Errorf("Expected 1 entry to be cleaned, got %d", cleanedCount)
	}

	// The expired entry should be removed
	finalSize := cache.Size()
	if finalSize != 1 {
		t.Errorf("Expected final cache size 1 after cleanup, got %d", finalSize)
	}

	// Test that cleanup works when all entries are expired
	cache.SetWithTTL(query2, mockResult, 1*time.Millisecond) // Make the remaining entry expire
	time.Sleep(10 * time.Millisecond)

	cleanedCount = cache.CleanupExpired()
	if cleanedCount != 1 {
		t.Errorf("Expected 1 entry to be cleaned in second cleanup, got %d", cleanedCount)
	}

	emptySize := cache.Size()
	if emptySize != 0 {
		t.Errorf("Expected empty cache size 0 after all expired, got %d", emptySize)
	}

	// Test cleanup when no entries are expired
	cache.Set(query1, mockResult) // Add a fresh entry
	cleanedCount = cache.CleanupExpired()
	if cleanedCount != 0 {
		t.Errorf("Expected 0 entries to be cleaned when none expired, got %d", cleanedCount)
	}

	if cache.Size() != 1 {
		t.Errorf("Expected 1 entry to remain after cleanup with no expired entries, got %d", cache.Size())
	}
}

func TestCreateQueryWithDynamicConfigs(t *testing.T) {
	values := map[string]string{
		"region": "us-west",
		"env":    "prod",
	}

	dynamicConfigs := NewDimensionConfigs()
	dynamicConfigs.Add(NewDimensionConfig("region", 0, false))

	query := CreateQueryWithDynamicConfigs(values, dynamicConfigs)

	if query == nil {
		t.Fatal("CreateQueryWithDynamicConfigs returned nil")
	}

	if query.Values["region"] != "us-west" {
		t.Errorf("Expected region value 'us-west', got '%s'", query.Values["region"])
	}

	if query.Values["env"] != "prod" {
		t.Errorf("Expected env value 'prod', got '%s'", query.Values["env"])
	}

	if query.IncludeAllRules {
		t.Error("Expected IncludeAllRules to be false")
	}

	if query.DynamicDimensionConfigs.Count() != 1 {
		t.Errorf("Expected 1 dynamic config, got %d", query.DynamicDimensionConfigs.Count())
	}

	// Test that the region config is accessible via GetSortedNames
	sortedNames := query.DynamicDimensionConfigs.GetSortedNames()
	if len(sortedNames) != 1 || sortedNames[0] != "region" {
		t.Errorf("Expected sorted names to contain 'region', got %v", sortedNames)
	}
}

func TestCreateQueryWithTenantAndDynamicConfigs(t *testing.T) {
	tenantID := "tenant1"
	applicationID := "app1"
	values := map[string]string{
		"category": "urgent",
		"priority": "high",
	}

	dynamicConfigs := NewDimensionConfigs()
	dynamicConfigs.Add(NewDimensionConfig("category", 0, true))
	dynamicConfigs.Add(NewDimensionConfig("priority", 1, false))

	query := CreateQueryWithTenantAndDynamicConfigs(tenantID, applicationID, values, dynamicConfigs)

	if query == nil {
		t.Fatal("CreateQueryWithTenantAndDynamicConfigs returned nil")
	}

	if query.TenantID != tenantID {
		t.Errorf("Expected tenant ID '%s', got '%s'", tenantID, query.TenantID)
	}

	if query.ApplicationID != applicationID {
		t.Errorf("Expected application ID '%s', got '%s'", applicationID, query.ApplicationID)
	}

	if query.Values["category"] != "urgent" {
		t.Errorf("Expected category value 'urgent', got '%s'", query.Values["category"])
	}

	if query.Values["priority"] != "high" {
		t.Errorf("Expected priority value 'high', got '%s'", query.Values["priority"])
	}

	if query.IncludeAllRules {
		t.Error("Expected IncludeAllRules to be false")
	}

	if query.DynamicDimensionConfigs.Count() != 2 {
		t.Errorf("Expected 2 dynamic configs, got %d", query.DynamicDimensionConfigs.Count())
	}
}

func TestCreateQueryWithAllRulesAndDynamicConfigs(t *testing.T) {
	values := map[string]string{
		"service": "user-service",
		"version": "1.2.3",
	}

	dynamicConfigs := NewDimensionConfigs()
	dynamicConfigs.Add(NewDimensionConfig("service", 0, true))

	query := CreateQueryWithAllRulesAndDynamicConfigs(values, dynamicConfigs)

	if query == nil {
		t.Fatal("CreateQueryWithAllRulesAndDynamicConfigs returned nil")
	}

	if query.Values["service"] != "user-service" {
		t.Errorf("Expected service value 'user-service', got '%s'", query.Values["service"])
	}

	if query.Values["version"] != "1.2.3" {
		t.Errorf("Expected version value '1.2.3', got '%s'", query.Values["version"])
	}

	if !query.IncludeAllRules {
		t.Error("Expected IncludeAllRules to be true")
	}

	if query.DynamicDimensionConfigs.Count() != 1 {
		t.Errorf("Expected 1 dynamic config, got %d", query.DynamicDimensionConfigs.Count())
	}
}

func TestCreateQueryWithAllRulesTenantAndDynamicConfigs(t *testing.T) {
	tenantID := "enterprise"
	applicationID := "main-app"
	values := map[string]string{
		"user_type": "admin",
		"action":    "delete",
		"resource":  "user",
	}

	dynamicConfigs := NewDimensionConfigs()
	dynamicConfigs.Add(NewDimensionConfig("user_type", 0, true))
	dynamicConfigs.Add(NewDimensionConfig("action", 1, true))
	dynamicConfigs.Add(NewDimensionConfig("resource", 2, false))

	query := CreateQueryWithAllRulesTenantAndDynamicConfigs(tenantID, applicationID, values, dynamicConfigs)

	if query == nil {
		t.Fatal("CreateQueryWithAllRulesTenantAndDynamicConfigs returned nil")
	}

	if query.TenantID != tenantID {
		t.Errorf("Expected tenant ID '%s', got '%s'", tenantID, query.TenantID)
	}

	if query.ApplicationID != applicationID {
		t.Errorf("Expected application ID '%s', got '%s'", applicationID, query.ApplicationID)
	}

	expectedValues := map[string]string{
		"user_type": "admin",
		"action":    "delete",
		"resource":  "user",
	}

	for key, expectedValue := range expectedValues {
		if query.Values[key] != expectedValue {
			t.Errorf("Expected %s value '%s', got '%s'", key, expectedValue, query.Values[key])
		}
	}

	if !query.IncludeAllRules {
		t.Error("Expected IncludeAllRules to be true")
	}

	if query.DynamicDimensionConfigs.Count() != 3 {
		t.Errorf("Expected 3 dynamic configs, got %d", query.DynamicDimensionConfigs.Count())
	}

	// Verify all dynamic configs using available methods
	expectedConfigs := map[string]bool{
		"user_type": true,  // required
		"action":    true,  // required
		"resource":  false, // not required
	}

	sortedNames := query.DynamicDimensionConfigs.GetSortedNames()
	for _, name := range sortedNames {
		expectedRequired, exists := expectedConfigs[name]
		if !exists {
			t.Errorf("Unexpected dynamic config for %s", name)
			continue
		}

		isRequired := query.DynamicDimensionConfigs.IsRequired(name)
		if isRequired != expectedRequired {
			t.Errorf("Config %s: expected required %v, got %v", name, expectedRequired, isRequired)
		}
	}
}

func TestDynamicConfigsIntegration(t *testing.T) {
	// Create a temporary directory for this test
	tempDir := t.TempDir()

	// Create matcher engine
	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create matcher engine: %v", err)
	}
	defer engine.Close()

	// Add basic dimension configurations
	regionConfig := NewDimensionConfig("region", 0, false)
	regionConfig.SetWeight(MatchTypeEqual, 10.0)
	regionConfig.SetWeight(MatchTypePrefix, 7.0)

	err = engine.AddDimension(regionConfig)
	if err != nil {
		t.Fatalf("Failed to add region dimension: %v", err)
	}

	// Add a rule without tenant (for basic tests)
	rule := NewRule("test-rule").
		Dimension("region", "us-west", MatchTypeEqual).
		Build()

	err = engine.AddRule(rule)
	if err != nil {
		t.Fatalf("Failed to add rule: %v", err)
	}

	// Add a rule with tenant for tenant-specific tests
	tenantRule := NewRuleWithTenant("tenant-rule", "tenant1", "app1").
		Dimension("region", "us-west", MatchTypeEqual).
		Build()

	err = engine.AddRule(tenantRule)
	if err != nil {
		t.Fatalf("Failed to add tenant rule: %v", err)
	}

	// Test all dynamic config API functions with actual matching
	testCases := []struct {
		name        string
		createQuery func() *QueryRule
		expectMatch bool
	}{
		{
			name: "CreateQueryWithDynamicConfigs",
			createQuery: func() *QueryRule {
				dynamicConfig := NewDimensionConfig("region", 0, false)
				dynamicConfig.SetWeight(MatchTypeEqual, 100.0)

				dynamicConfigs := NewDimensionConfigs()
				dynamicConfigs.Add(dynamicConfig)

				return CreateQueryWithDynamicConfigs(
					map[string]string{"region": "us-west"},
					dynamicConfigs,
				)
			},
			expectMatch: true,
		},
		{
			name: "CreateQueryWithTenantAndDynamicConfigs",
			createQuery: func() *QueryRule {
				dynamicConfig := NewDimensionConfig("region", 0, false)
				dynamicConfig.SetWeight(MatchTypeEqual, 150.0)

				dynamicConfigs := NewDimensionConfigs()
				dynamicConfigs.Add(dynamicConfig)

				return CreateQueryWithTenantAndDynamicConfigs(
					"tenant1", "app1",
					map[string]string{"region": "us-west"},
					dynamicConfigs,
				)
			},
			expectMatch: true,
		},
		{
			name: "CreateQueryWithAllRulesAndDynamicConfigs",
			createQuery: func() *QueryRule {
				dynamicConfig := NewDimensionConfig("region", 0, false)
				dynamicConfig.SetWeight(MatchTypeEqual, 60.0)

				dynamicConfigs := NewDimensionConfigs()
				dynamicConfigs.Add(dynamicConfig)

				return CreateQueryWithAllRulesAndDynamicConfigs(
					map[string]string{"region": "us-west"},
					dynamicConfigs,
				)
			},
			expectMatch: true,
		},
		{
			name: "CreateQueryWithAllRulesTenantAndDynamicConfigs",
			createQuery: func() *QueryRule {
				dynamicConfig := NewDimensionConfig("region", 0, false)
				dynamicConfig.SetWeight(MatchTypeEqual, 50.0)

				dynamicConfigs := NewDimensionConfigs()
				dynamicConfigs.Add(dynamicConfig)

				return CreateQueryWithAllRulesTenantAndDynamicConfigs(
					"tenant1", "app1",
					map[string]string{"region": "us-west"},
					dynamicConfigs,
				)
			},
			expectMatch: true,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			query := tc.createQuery()

			matches, err := engine.FindAllMatches(query)
			if err != nil {
				t.Fatalf("FindAllMatches failed for %s: %v", tc.name, err)
			}

			if tc.expectMatch && len(matches) == 0 {
				t.Errorf("%s: expected at least 1 match, got 0", tc.name)
			} else if !tc.expectMatch && len(matches) > 0 {
				t.Errorf("%s: expected 0 matches, got %d", tc.name, len(matches))
			}

			if len(matches) > 0 {
				t.Logf("%s: Found match with weight %.1f", tc.name, matches[0].TotalWeight)
			}
		})
	}
}

// ========================================
// MERGED SIMPLE COVERAGE TESTS (merged from simple_coverage_test.go and delete_dimension_test.go)
// ========================================

func TestDeleteDimensionCoverage(t *testing.T) {
	persistence := NewJSONPersistence("./test_data")
	engine, err := NewMatcherEngine(context.Background(), persistence, nil, "delete-dim-test", nil, 0)
	if err != nil {
		t.Fatalf("Failed to create engine: %v", err)
	}
	defer engine.Close()

	// Add a dimension first
	dimConfig := NewDimensionConfig("test_dim_delete", 0, false)
	err = engine.AddDimension(dimConfig)
	if err != nil {
		t.Fatalf("Failed to add dimension: %v", err)
	}

	// Test by accessing the internal method (this is for coverage, not typical usage)
	// We need to call the internal deleteDimension method indirectly
	// Since it's not exposed, we'll trigger it through other operations

	// The deleteDimension method is typically called during cleanup or updates
	// Let's try to trigger it by rebuilding or other operations
	err = engine.Rebuild()
	if err != nil {
		t.Logf("Rebuild failed (might be expected): %v", err)
	}
}

func TestRuleBuilderMetadataIntegration(t *testing.T) {
	// Integration test for rule builder with metadata functionality
	rule := NewRule("metadata-test").
		Dimension("region", "us-west", MatchTypeEqual).
		Metadata("key1", "value1").
		Metadata("key2", "value2").
		Build()

	if rule.Metadata["key1"] != "value1" {
		t.Errorf("Expected metadata key1=value1, got %s", rule.Metadata["key1"])
	}
	if rule.Metadata["key2"] != "value2" {
		t.Errorf("Expected metadata key2=value2, got %s", rule.Metadata["key2"])
	}
}

func TestMatcherEngineFullAPIIntegration(t *testing.T) {
	// Integration test for complete MatcherEngine API workflow
	tempDir, err := os.MkdirTemp("", "matcher-test-*")
	if err != nil {
		t.Fatalf("Failed to create temp dir: %v", err)
	}
	defer os.RemoveAll(tempDir)

	engine, err := NewMatcherEngineWithDefaults(tempDir)
	if err != nil {
		t.Fatalf("Failed to create engine: %v", err)
	}
	defer engine.Close()

	// Test ListRules
	rules, err := engine.ListRules(0, 10)
	if err != nil {
		t.Errorf("ListRules failed: %v", err)
	}
	if rules == nil {
		t.Error("ListRules returned nil")
	}

	// Test ListDimensions
	_, err = engine.ListDimensions()
	if err != nil {
		t.Errorf("ListDimensions failed: %v", err)
	}
	// ListDimensions can return empty slice, which is valid	// Test Save
	if err := engine.Save(); err != nil {
		t.Errorf("Save failed: %v", err)
	}

	// Test Health
	if err := engine.Health(); err != nil {
		t.Errorf("Health failed: %v", err)
	}

	// Test GetForestStats
	stats := engine.GetForestStats()
	if stats == nil {
		t.Error("GetForestStats returned nil")
	}

	// Test ClearCache
	engine.ClearCache()

	// Test GetCacheStats
	cacheStats := engine.GetCacheStats()
	if cacheStats == nil {
		t.Error("GetCacheStats returned nil")
	}

	// Test AutoSave
	stopChan := engine.AutoSave(100 * time.Millisecond)
	if stopChan == nil {
		t.Error("AutoSave returned nil channel")
	}
	stopChan <- true

	// Add dimension configuration before adding rule
	regionDim := NewDimensionConfig("region", 0, false)
	regionDim.SetWeight(MatchTypeEqual, 10.0)
	if err := engine.AddDimension(regionDim); err != nil {
		t.Errorf("Failed to add dimension: %v", err)
	}

	// Add a rule and test Rebuild
	rule := NewRule("rebuild-test").
		Dimension("region", "us-west", MatchTypeEqual).
		Build()
	if err := engine.AddRule(rule); err != nil {
		t.Errorf("Failed to add rule: %v", err)
	}

	if err := engine.Rebuild(); err != nil {
		t.Errorf("Rebuild failed: %v", err)
	}
}

func TestQueryCacheAPIIntegration(t *testing.T) {
	// Integration test for QueryCache API methods
	cache := NewQueryCache(10, 60*time.Second)

	// Test Size
	size := cache.Size()
	if size != 0 {
		t.Errorf("Expected size 0, got %d", size)
	}

	// Test SetWithTTL
	query := CreateQuery(map[string]string{"test": "value"})
	result := &MatchResult{Rule: &Rule{ID: "test"}, TotalWeight: 1.0}
	cache.SetWithTTL(query, result, 30*time.Second)

	// Test Size again
	size = cache.Size()
	if size != 1 {
		t.Errorf("Expected size 1, got %d", size)
	}

	// Test CleanupExpired
	cleanedCount := cache.CleanupExpired()
	t.Logf("Cleaned %d expired entries", cleanedCount)

	// Test Stats
	stats := cache.Stats()
	if stats == nil {
		t.Error("Stats returned nil")
	}

	// Test StartCleanupWorker
	stopChan := cache.StartCleanupWorker(100 * time.Millisecond)
	if stopChan == nil {
		t.Error("StartCleanupWorker returned nil channel")
	}
	stopChan <- true
}

func TestMultiLevelCacheAPIIntegration(t *testing.T) {
	// Integration test for MultiLevelCache API methods
	mlc := NewMultiLevelCache(10, 60*time.Second, 100, 120*time.Second)
	if mlc == nil {
		t.Error("NewMultiLevelCache returned nil")
	}

	// Test Get on empty cache
	query := CreateQuery(map[string]string{"test": "value"})
	result := mlc.Get(query)
	if result != nil {
		t.Error("Expected nil result for empty cache")
	}

	// Test Set
	matchResult := &MatchResult{Rule: &Rule{ID: "test"}, TotalWeight: 1.0}
	mlc.Set(query, matchResult)

	// Test Get again
	result = mlc.Get(query)
	if result == nil {
		t.Error("Expected result after set")
	}

	// Test Stats
	stats := mlc.Stats()
	if stats == nil {
		t.Error("Stats returned nil")
	}

	// Test Clear
	mlc.Clear()
}

func TestForestAPIIntegration(t *testing.T) {
	// Integration test for Forest API methods
	forest := CreateForestIndexCompat()

	// Test InitializeDimension (compatibility method)
	forest.InitializeDimension("new-dim")

	// Test that forest was created successfully
	if forest == nil {
		t.Error("CreateForestIndexCompat returned nil")
	}

	// Test that we can get stats from the forest
	stats := forest.GetStats()
	if stats == nil {
		t.Error("GetStats returned nil")
	}
}

func TestTypesAPIIntegration(t *testing.T) {
	// Integration test for Types API methods
	rule := NewRule("types-test").
		Dimension("region", "us-west", MatchTypeEqual).
		Build()

	// Test GetDimensionValue
	value := rule.GetDimensionValue("region")
	if value == nil {
		t.Error("Expected dimension value, got nil")
	}
	if value != nil && value.Value != "us-west" {
		t.Errorf("Expected 'us-west', got '%s'", value.Value)
	}

	// Test non-existent dimension
	value = rule.GetDimensionValue("nonexistent")
	if value != nil {
		t.Errorf("Expected nil, got %v", value)
	}

	// Test HasDimension
	if !rule.HasDimension("region") {
		t.Error("Expected rule to have 'region' dimension")
	}

	if rule.HasDimension("nonexistent") {
		t.Error("Expected rule to not have 'nonexistent' dimension")
	}
}

// TestPublicUpdateAndGetRule tests the public UpdateRule and GetRule methods
func TestPublicUpdateAndGetRule(t *testing.T) {
	// Create matcher with mock persistence
	persistence := NewJSONPersistence("./test_data")
	matcher, err := NewMatcherEngine(context.Background(), persistence, nil, "test-node-1", nil, 0)
	if err != nil {
		t.Fatalf("Failed to create matcher: %v", err)
	}
	defer matcher.Close()

	// Add test dimensions
	err = addTestDimensions(matcher)
	if err != nil {
		t.Fatalf("Failed to initialize dimensions: %v", err)
	}

	// Create and add initial rule
	rule := NewRule("test-public-rule").
		Dimension("product", "TestProduct", MatchTypeEqual).
		Dimension("route", "TestRoute", MatchTypeEqual).
		Metadata("action", "allow").
		Metadata("priority", "high").
		Build()

	err = matcher.AddRule(rule)
	if err != nil {
		t.Fatalf("Failed to add rule: %v", err)
	}

	// Test GetRule
	retrieved, err := matcher.GetRule("test-public-rule")
	if err != nil {
		t.Fatalf("Failed to get rule: %v", err)
	}

	if retrieved.ID != "test-public-rule" {
		t.Errorf("Expected rule ID 'test-public-rule', got %s", retrieved.ID)
	}

	if retrieved.Metadata["action"] != "allow" {
		t.Errorf("Expected action 'allow', got %v", retrieved.Metadata["action"])
	}

	// Test UpdateRule with public method
	updatedRule := NewRule("test-public-rule").
		Dimension("product", "TestProduct", MatchTypeEqual).
		Dimension("route", "UpdatedRoute", MatchTypeEqual). // Changed route
		Metadata("action", "block").                        // Changed action
		Metadata("priority", "medium").                     // Changed priority
		Build()

	err = matcher.UpdateRule(updatedRule) // Using public UpdateRule method
	if err != nil {
		t.Fatalf("Failed to update rule: %v", err)
	}

	// Verify update using public GetRule method
	retrievedUpdated, err := matcher.GetRule("test-public-rule") // Using public GetRule method
	if err != nil {
		t.Fatalf("Failed to get updated rule: %v", err)
	}

	// Check that dimensions were updated
	routeDim := retrievedUpdated.GetDimensionValue("route")
	if routeDim == nil {
		t.Fatalf("Route dimension not found")
	}

	if routeDim.Value != "UpdatedRoute" {
		t.Errorf("Expected route 'UpdatedRoute', got %s", routeDim.Value)
	}

	// Check that metadata was updated
	if retrievedUpdated.Metadata["action"] != "block" {
		t.Errorf("Expected action 'block', got %v", retrievedUpdated.Metadata["action"])
	}

	if retrievedUpdated.Metadata["priority"] != "medium" {
		t.Errorf("Expected priority 'medium', got %v", retrievedUpdated.Metadata["priority"])
	}

	// Test GetRule with non-existent rule
	_, err = matcher.GetRule("non-existent-rule")
	if err == nil {
		t.Error("Expected error when getting non-existent rule")
	}
}

// TestPublicAPIImmutability tests that GetRule returns immutable copies
func TestPublicAPIImmutability(t *testing.T) {
	// Create matcher with mock persistence
	persistence := NewJSONPersistence("./test_data")
	matcher, err := NewMatcherEngine(context.Background(), persistence, nil, "test-node-1", nil, 0)
	if err != nil {
		t.Fatalf("Failed to create matcher: %v", err)
	}
	defer matcher.Close()

	// Add test dimensions
	err = addTestDimensions(matcher)
	if err != nil {
		t.Fatalf("Failed to initialize dimensions: %v", err)
	}

	// Create and add rule
	rule := NewRule("immutable-test").
		Dimension("product", "TestProduct", MatchTypeEqual).
		Metadata("action", "allow").
		Build()

	err = matcher.AddRule(rule)
	if err != nil {
		t.Fatalf("Failed to add rule: %v", err)
	}

	// Get rule and modify the returned copy
	retrieved, err := matcher.GetRule("immutable-test")
	if err != nil {
		t.Fatalf("Failed to get rule: %v", err)
	}

	// Modify the returned copy
	retrieved.Metadata["action"] = "modified"
	if dim := retrieved.GetDimensionValue("product"); dim != nil {
		dim.Value = "modified"
	}

	// Get the rule again and verify it wasn't affected
	retrievedAgain, err := matcher.GetRule("immutable-test")
	if err != nil {
		t.Fatalf("Failed to get rule again: %v", err)
	}

	if retrievedAgain.Metadata["action"] != "allow" {
		t.Error("Rule was modified when it should be immutable")
	}

	if dim := retrievedAgain.GetDimensionValue("product"); dim != nil {
		if dim.Value != "TestProduct" {
			t.Error("Dimension was modified when it should be immutable")
		}
	}
}