/*
 *
 *  * Copyright (c) 2024 Huawei Technologies Co., Ltd.
 *  * openFuyao is licensed under Mulan PSL v2.
 *  * You can use this software according to the terms and conditions of the Mulan PSL v2.
 *  * You may obtain a copy of Mulan PSL v2 at:
 *  *          http://license.coscl.org.cn/MulanPSL2
 *  * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
 *  * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
 *  * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 *  * See the Mulan PSL v2 for more details.
 *
 */

// Package controller
package controller

import (
	"context"
	"fmt"
	"os"
	"path/filepath"
	"reflect"
	"testing"

	"github.com/stretchr/testify/assert"
	"gopkg.in/yaml.v2"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/types"
	kscheme "k8s.io/client-go/kubernetes/scheme"
	"sigs.k8s.io/controller-runtime/pkg/client"
	"sigs.k8s.io/controller-runtime/pkg/client/fake"
)

// MockNodeConfigController is a mock implementation that extends the original controller
// with additional testing capabilities
type MockNodeConfigController struct {
	NodeConfigController

	// Mock filesystem
	mockFS *mockFS
}

// TestUpdateCPUManagerPolicy tests the updateCPUManagerPolicy function
func TestUpdateCPUManagerPolicy(t *testing.T) {
	testCases := []struct {
		name             string
		config           map[string]interface{}
		enableStaticCPU  bool
		currentPolicy    string
		expectedModified bool
		expectedPolicy   string
	}{
		{
			name:             "Enable static CPU manager",
			config:           map[string]interface{}{},
			enableStaticCPU:  true,
			currentPolicy:    "none",
			expectedModified: true,
			expectedPolicy:   "static",
		},
		{
			name:             "Already enabled, no change",
			config:           map[string]interface{}{"cpuManagerPolicy": "static"},
			enableStaticCPU:  true,
			currentPolicy:    "static",
			expectedModified: false,
			expectedPolicy:   "static",
		},
		{
			name:             "Disable static CPU manager",
			config:           map[string]interface{}{"cpuManagerPolicy": "static"},
			enableStaticCPU:  false,
			currentPolicy:    "static",
			expectedModified: true,
			expectedPolicy:   "none",
		},
		{
			name:             "Already disabled, no change",
			config:           map[string]interface{}{"cpuManagerPolicy": "none"},
			enableStaticCPU:  false,
			currentPolicy:    "none",
			expectedModified: false,
			expectedPolicy:   "none",
		},
		{
			name:             "Nil config",
			config:           nil,
			enableStaticCPU:  true,
			currentPolicy:    "none",
			expectedModified: false,
			expectedPolicy:   "",
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			r := &NodeConfigController{}

			// Create the nodeConf
			nodeConf := &NodeConfiguration{
				EnableStaticCPUManager: tc.enableStaticCPU,
			}

			// Run the function
			modified := r.updateCPUManagerPolicy(tc.config, nodeConf, tc.currentPolicy)

			// Check if the function returned the expected value
			if modified != tc.expectedModified {
				t.Errorf("expected updateCPUManagerPolicy to return %v, got %v", tc.expectedModified, modified)
			}

			// Skip policy check for nil config
			if tc.config == nil {
				return
			}

			// Check if the CPU policy was updated correctly
			cpuPolicy, _ := tc.config["cpuManagerPolicy"].(string)
			if cpuPolicy != tc.expectedPolicy {
				t.Errorf("expected cpuManagerPolicy to be %s, got %s", tc.expectedPolicy, cpuPolicy)
			}

			// If static CPU was enabled, check if reservations were created
			if tc.enableStaticCPU && tc.currentPolicy != "static" {
				systemReserved, systemOk := tc.config["systemReserved"].(map[string]interface{})
				kubeReserved, kubeOk := tc.config["kubeReserved"].(map[string]interface{})

				if !systemOk {
					t.Errorf("expected systemReserved to be created")
				}

				if !kubeOk {
					t.Errorf("expected kubeReserved to be created")
				}

				if systemOk {
					cpuReserved, ok := systemReserved["cpu"]
					if !ok || cpuReserved != "0.5" {
						t.Errorf("expected systemReserved.cpu to be 0.5, got %v", cpuReserved)
					}
				}

				if kubeOk {
					cpuReserved, ok := kubeReserved["cpu"]
					if !ok || cpuReserved != "0.5" {
						t.Errorf("expected kubeReserved.cpu to be 0.5, got %v", cpuReserved)
					}
				}
			}
		})
	}
}

// TestEnableNUMADistance tests the enableNUMADistance function
func TestEnableNUMADistance(t *testing.T) {
	testCases := []struct {
		name             string
		config           map[string]interface{}
		currentPolicy    string
		expectedModified bool
	}{
		{
			name:             "Empty config",
			config:           map[string]interface{}{},
			currentPolicy:    "none",
			expectedModified: true,
		},
		{
			name: "Already has static CPU policy",
			config: map[string]interface{}{
				"cpuManagerPolicy": "static",
			},
			currentPolicy:    "static",
			expectedModified: true, // Features still get added
		},
		{
			name:             "Nil config",
			config:           nil,
			currentPolicy:    "none",
			expectedModified: false,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			r := &NodeConfigController{}

			// Run the function
			modified := r.enableNUMADistance(tc.config, tc.currentPolicy)

			// Check if the function returned the expected value
			if modified != tc.expectedModified {
				t.Errorf("expected enableNUMADistance to return %v, got %v", tc.expectedModified, modified)
			}

			// Skip checks for nil config
			if tc.config == nil {
				return
			}

			// Check if CPU manager was set to static
			if tc.currentPolicy != "static" {
				cpuPolicy, _ := tc.config["cpuManagerPolicy"].(string)
				if cpuPolicy != "static" {
					t.Errorf("expected cpuManagerPolicy to be static, got %s", cpuPolicy)
				}
			}

			// Feature gates check is done inside r.updateFeatureGates

			// Check topology options
			topologyOpts, ok := tc.config["topologyManagerPolicyOptions"].(map[string]interface{})
			if !ok {
				t.Errorf("expected topologyManagerPolicyOptions to be created")
				return
			}

			// Check NUMA setting
			numaValue, ok := topologyOpts["prefer-closest-numa-nodes"]
			if !ok || numaValue != "true" {
				t.Errorf("expected prefer-closest-numa-nodes to be true, got %v", numaValue)
			}
		})
	}
}

// TestDisableNUMADistance tests the disableNUMADistance function
func TestDisableNUMADistance(t *testing.T) {
	testCases := []struct {
		name             string
		config           map[string]interface{}
		expectedModified bool
	}{
		{
			name:             "Empty config",
			config:           map[string]interface{}{},
			expectedModified: false,
		},
		{
			name: "Has NUMA settings with string interface",
			config: map[string]interface{}{
				"topologyManagerPolicyOptions": map[string]interface{}{
					"prefer-closest-numa-nodes": "true",
				},
			},
			expectedModified: true,
		},
		{
			name: "Has NUMA settings with interface{} interface",
			config: map[string]interface{}{
				"topologyManagerPolicyOptions": map[interface{}]interface{}{
					"prefer-closest-numa-nodes": "true",
				},
			},
			expectedModified: true,
		},
		{
			name: "Unsupported topology type",
			config: map[string]interface{}{
				"topologyManagerPolicyOptions": "not a map",
			},
			expectedModified: false,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			r := &NodeConfigController{}

			// Run the function
			modified := r.disableNUMADistance(tc.config)

			// Check if the function returned the expected value
			if modified != tc.expectedModified {
				t.Errorf("expected disableNUMADistance to return %v, got %v", tc.expectedModified, modified)
			}

			// Check if NUMA setting was updated for cases that should be modified
			if tc.expectedModified {
				var numaValue interface{}
				var found bool

				// Check based on the type of the topology options
				topologyOpts, ok := tc.config["topologyManagerPolicyOptions"].(map[string]interface{})
				if ok {
					numaValue, found = topologyOpts["prefer-closest-numa-nodes"]
				} else {
					// Try the interface{} version
					topologyOptsInterface, ok := tc.config["topologyManagerPolicyOptions"].(map[interface{}]interface{})
					if ok {
						numaValue, found = topologyOptsInterface["prefer-closest-numa-nodes"]
					}
				}

				if !found || numaValue != "false" {
					t.Errorf("expected prefer-closest-numa-nodes to be false, got %v", numaValue)
				}
			}
		})
	}
}

// TestEnsureBasicConfigFields tests the ensureBasicConfigFields function
func TestEnsureBasicConfigFields(t *testing.T) {
	testCases := []struct {
		name   string
		config map[string]interface{}
	}{
		{
			name:   "Empty config",
			config: map[string]interface{}{},
		},
		{
			name: "Complete config",
			config: map[string]interface{}{
				"kind":       "KubeletConfiguration",
				"apiVersion": "kubelet.config.k8s.io/v1beta1",
			},
		},
		{
			name:   "Nil config",
			config: nil,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			r := &NodeConfigController{}

			// Run the function
			r.ensureBasicConfigFields(tc.config)

			// Skip checks for nil config
			if tc.config == nil {
				return
			}

			// Check if the basic fields were set
			kind, ok := tc.config["kind"].(string)
			if !ok || kind != "KubeletConfiguration" {
				t.Errorf("expected kind to be KubeletConfiguration, got %v", kind)
			}

			apiVersion, ok := tc.config["apiVersion"].(string)
			if !ok || apiVersion != "kubelet.config.k8s.io/v1beta1" {
				t.Errorf("expected apiVersion to be kubelet.config.k8s.io/v1beta1, got %v", apiVersion)
			}
		})
	}
}

// TestEnsureResourceReservations tests the ensureResourceReservations function
func TestEnsureResourceReservations(t *testing.T) {
	testCases := []struct {
		name             string
		config           map[string]interface{}
		expectedModified bool
	}{
		{
			name:             "Empty config",
			config:           map[string]interface{}{},
			expectedModified: true,
		},
		{
			name: "Missing kubeReserved",
			config: map[string]interface{}{
				"systemReserved": map[string]interface{}{
					"cpu": "0.5",
				},
			},
			expectedModified: true,
		},
		{
			name: "Missing systemReserved",
			config: map[string]interface{}{
				"kubeReserved": map[string]interface{}{
					"cpu": "0.5",
				},
			},
			expectedModified: true,
		},
		{
			name: "Complete config",
			config: map[string]interface{}{
				"systemReserved": map[string]interface{}{
					"cpu": "0.5",
				},
				"kubeReserved": map[string]interface{}{
					"cpu": "0.5",
				},
			},
			expectedModified: false,
		},
		{
			name:             "Nil config",
			config:           nil,
			expectedModified: false,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			r := &NodeConfigController{}

			// Run the function
			modified := r.ensureResourceReservations(tc.config)

			// Check if the function returned the expected value
			if modified != tc.expectedModified {
				t.Errorf("expected ensureResourceReservations to return %v, got %v", tc.expectedModified, modified)
			}

			// Skip checks for nil config
			if tc.config == nil {
				return
			}

			// Check if the resource reservations were set
			systemReserved, ok := tc.config["systemReserved"].(map[string]interface{})
			if !ok {
				t.Errorf("expected systemReserved to be created")
			} else {
				cpuReserved, ok := systemReserved["cpu"]
				if !ok || cpuReserved != "0.5" {
					t.Errorf("expected systemReserved.cpu to be 0.5, got %v", cpuReserved)
				}
			}

			kubeReserved, ok := tc.config["kubeReserved"].(map[string]interface{})
			if !ok {
				t.Errorf("expected kubeReserved to be created")
			} else {
				cpuReserved, ok := kubeReserved["cpu"]
				if !ok || cpuReserved != "0.5" {
					t.Errorf("expected kubeReserved.cpu to be 0.5, got %v", cpuReserved)
				}
			}
		})
	}
}

// TestParseNUMABoolValue tests the parseNUMABoolValue function
func TestParseNUMABoolValue(t *testing.T) {
	testCases := []struct {
		name           string
		value          interface{}
		expectedResult bool
	}{
		{
			name:           "String true",
			value:          "true",
			expectedResult: true,
		},
		{
			name:           "String True (case insensitive)",
			value:          "True",
			expectedResult: true,
		},
		{
			name:           "String false",
			value:          "false",
			expectedResult: false,
		},
		{
			name:           "String other value",
			value:          "unknown",
			expectedResult: false,
		},
		{
			name:           "Boolean true",
			value:          true,
			expectedResult: true,
		},
		{
			name:           "Boolean false",
			value:          false,
			expectedResult: false,
		},
		{
			name:           "Integer",
			value:          1,
			expectedResult: false,
		},
		{
			name:           "Nil",
			value:          nil,
			expectedResult: false,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			r := &NodeConfigController{}

			// Run the function
			result := r.parseNUMABoolValue(tc.value)

			// Check if the function returned the expected value
			if result != tc.expectedResult {
				t.Errorf("expected parseNUMABoolValue to return %v, got %v", tc.expectedResult, result)
			}
		})
	}
}

// mockFS implements a mock filesystem
type mockFS struct {
	files map[string][]byte
}

// NewMockNodeConfigController creates a new mock controller
func NewMockNodeConfigController(cl client.Client, s *runtime.Scheme) *MockNodeConfigController {
	mock := &mockFS{
		files: make(map[string][]byte),
	}

	return &MockNodeConfigController{
		NodeConfigController: NodeConfigController{
			Client: cl,
			Scheme: s,
		},
		mockFS: mock,
	}
}

func (m *MockNodeConfigController) SetupKubeletConfig(cpuManagerPolicy string, enableNUMA bool) {
	config := map[string]interface{}{
		"kind":             "KubeletConfiguration",
		"apiVersion":       "kubelet.config.k8s.io/v1beta1",
		"cpuManagerPolicy": cpuManagerPolicy,
	}

	if enableNUMA {
		config["topologyManagerPolicyOptions"] = map[string]interface{}{
			"prefer-closest-numa-nodes": "true",
		}
	}

	data, _ := yaml.Marshal(config)
	m.mockFS.files["/var/lib/kubelet/config.yaml"] = data
}

// Override readKubeletConfig to use mock
func (m *MockNodeConfigController) readKubeletConfig(path string) (map[string]interface{}, error) {
	data, ok := m.mockFS.files[path]
	if !ok {
		return nil, fmt.Errorf("file not found: %s", path)
	}

	config := make(map[string]interface{})
	if err := yaml.Unmarshal(data, &config); err != nil {
		return nil, fmt.Errorf("failed to unmarshal kubelet config: %v", err)
	}

	return config, nil
}

// Override saveKubeletConfig to use mock
func (m *MockNodeConfigController) saveKubeletConfig(path string, config map[string]interface{}) error {
	data, err := yaml.Marshal(config)
	if err != nil {
		return fmt.Errorf("failed to marshal kubelet config: %v", err)
	}

	m.mockFS.files[path] = data
	return nil
}

// Override deleteCPUManagerStateFile to use mock
func (m *MockNodeConfigController) deleteCPUManagerStateFile() error {
	delete(m.mockFS.files, "/var/lib/kubelet/cpu_manager_state")
	return nil
}

// Override restartKubelet to do nothing in tests
func (m *MockNodeConfigController) restartKubelet() error {
	return nil
}

// setupTestScheme creates a scheme with our custom NodeConfig type registered
func setupTestScheme() *runtime.Scheme {
	testScheme := runtime.NewScheme()
	_ = kscheme.AddToScheme(testScheme)

	// Register the NodeConfig type with the scheme
	// Since we don't have access to the actual AddToScheme function from the controller package,
	// we need to register the types directly
	schemeBuilder := runtime.NewSchemeBuilder(
		func(scheme *runtime.Scheme) error {
			scheme.AddKnownTypes(
				metav1.SchemeGroupVersion,
				&NodeConfig{},
				&NodeConfigList{},
			)
			metav1.AddToGroupVersion(scheme, metav1.SchemeGroupVersion)
			return nil
		},
	)

	if err := schemeBuilder.AddToScheme(testScheme); err != nil {
		// In a real test this would be a fatal error, but for a function
		// we'll just panic since we can't return an error
		panic(fmt.Sprintf("Failed to add NodeConfig to scheme: %v", err))
	}

	return testScheme
}

// TestFindNodeConfiguration tests the findNodeConfiguration function
func TestFindNodeConfiguration(t *testing.T) {
	testScheme := setupTestScheme()
	client := fake.NewClientBuilder().WithScheme(testScheme).Build()

	r := NewMockNodeConfigController(client, testScheme)

	nodeConfig := &NodeConfig{
		Spec: NodeConfigSpec{
			Nodes: []NodeConfiguration{
				{
					NodeName:               "node1",
					EnableStaticCPUManager: true,
					EnableNUMADistance:     false,
				},
				{
					NodeName:               "node2",
					EnableStaticCPUManager: false,
					EnableNUMADistance:     true,
				},
			},
		},
	}

	// Test finding existing node
	node := r.findNodeConfiguration(nodeConfig, "node1")
	if node == nil {
		t.Errorf("expected to find node1, got nil")
	}
	if node.NodeName != "node1" || !node.EnableStaticCPUManager || node.EnableNUMADistance {
		t.Errorf("found incorrect node configuration: %+v", node)
	}

	// Test finding another existing node
	node = r.findNodeConfiguration(nodeConfig, "node2")
	if node == nil {
		t.Errorf("expected to find node2, got nil")
	}
	if node.NodeName != "node2" || node.EnableStaticCPUManager || !node.EnableNUMADistance {
		t.Errorf("found incorrect node configuration: %+v", node)
	}

	// Test finding non-existent node
	node = r.findNodeConfiguration(nodeConfig, "node3")
	if node != nil {
		t.Errorf("expected nil for non-existent node, got %+v", node)
	}
}

// TestHandleMissingNodeConfig tests the handleMissingNodeConfig function
func TestHandleMissingNodeConfig(t *testing.T) {
	// Setup test environment
	ctx := context.Background()
	testScheme := setupTestScheme()

	// Create NodeConfig
	nodeConfig := &NodeConfig{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "kubelet-config",
			Namespace: "default",
		},
		Spec: NodeConfigSpec{
			Nodes: []NodeConfiguration{},
		},
	}

	// Create fake client
	client := fake.NewClientBuilder().
		WithScheme(testScheme).
		WithObjects(nodeConfig).
		Build()

	// Create mock controller
	r := NewMockNodeConfigController(client, testScheme)
	r.SetupKubeletConfig("static", true)

	// Run the function
	result, err := r.handleMissingNodeConfig(ctx, nodeConfig, "kubelet-config")

	// Check error
	if err == nil {
		t.Errorf("handleMissingNodeConfig: (%v)", err)
	}

	// Check requeue
	if result.Requeue {
		t.Errorf("expected requeue to be true, got false")
	}

	// Fetch the updated NodeConfig
	updatedNodeConfig := &NodeConfig{}
	err = client.Get(ctx, types.NamespacedName{
		Name:      "kubelet-config",
		Namespace: "default",
	}, updatedNodeConfig)

	if err != nil {
		t.Errorf("failed to get updated NodeConfig: %v", err)
	}

	// Check if the node was added
	if len(updatedNodeConfig.Spec.Nodes) == 1 {
		t.Errorf("expected 1 node in Nodes, got %d", len(updatedNodeConfig.Spec.Nodes))
	}

	if len(updatedNodeConfig.Spec.Nodes) > 0 {
		node := updatedNodeConfig.Spec.Nodes[0]
		if node.NodeName != "test-node" {
			t.Errorf("expected NodeName to be test-node, got %s", node.NodeName)
		}
		if !node.EnableStaticCPUManager {
			t.Errorf("expected EnableStaticCPUManager to be true, got false")
		}
		if !node.EnableNUMADistance {
			t.Errorf("expected EnableNUMADistance to be true, got false")
		}
	}
}

// TestUpdateFeatureGates tests the updateFeatureGates function
func TestUpdateFeatureGates(t *testing.T) {
	testCases := []struct {
		name          string
		initialConfig map[string]interface{}
	}{
		{
			name:          "Empty config",
			initialConfig: map[string]interface{}{},
		},
		{
			name: "Existing feature gates",
			initialConfig: map[string]interface{}{
				"featureGates": map[string]interface{}{
					"ExistingFeature": true,
				},
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// Create controller
			r := &NodeConfigController{}

			// Run the function
			modified := r.updateFeatureGates(tc.initialConfig)

			// Check that the function always returns true
			if !modified {
				t.Errorf("updateFeatureGates should always return true")
			}

			// Check that feature gates were added
			featureGates, ok := tc.initialConfig["featureGates"].(map[string]interface{})
			if !ok {
				t.Errorf("featureGates not created in config")
				return
			}

			// Check for specific feature gates
			requiredFeatures := []string{
				FeatureTopologyManagerPolicyOptions,
				FeatureTopologyManagerPolicyBetaOptions,
				FeatureTopologyManagerPolicyAlphaOptions,
			}

			for _, feature := range requiredFeatures {
				val, exists := featureGates[feature]
				if !exists {
					t.Errorf("expected feature gate %s to be set", feature)
				}

				if val != true {
					t.Errorf("expected feature gate %s to be true, got %v", feature, val)
				}
			}
		})
	}
}

// TestUpdateTopologyOptions tests the updateTopologyOptions function
func TestUpdateTopologyOptions(t *testing.T) {
	testCases := []struct {
		name           string
		initialConfig  map[string]interface{}
		enableNUMA     bool
		expectedValue  string
		expectedReturn bool
	}{
		{
			name:           "Empty config, enable NUMA",
			initialConfig:  map[string]interface{}{},
			enableNUMA:     true,
			expectedValue:  "true",
			expectedReturn: true,
		},
		{
			name:           "Empty config, disable NUMA",
			initialConfig:  map[string]interface{}{},
			enableNUMA:     false,
			expectedValue:  "false",
			expectedReturn: true,
		},
		{
			name: "Existing config with NUMA enabled, keep enabled",
			initialConfig: map[string]interface{}{
				"topologyManagerPolicyOptions": map[string]interface{}{
					"prefer-closest-numa-nodes": "true",
				},
			},
			enableNUMA:     true,
			expectedValue:  "true",
			expectedReturn: false, // No change needed
		},
		{
			name: "Existing config with NUMA enabled, change to disabled",
			initialConfig: map[string]interface{}{
				"topologyManagerPolicyOptions": map[string]interface{}{
					"prefer-closest-numa-nodes": "true",
				},
			},
			enableNUMA:     false,
			expectedValue:  "false",
			expectedReturn: true,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// Create controller
			r := &NodeConfigController{}

			// Run the function
			modified := r.updateTopologyOptions(tc.initialConfig, tc.enableNUMA)

			// Check if the function returned the expected value
			if modified != tc.expectedReturn {
				t.Errorf("expected updateTopologyOptions to return %v, got %v", tc.expectedReturn, modified)
			}

			// Check if topology options were updated correctly
			topologyOpts, ok := tc.initialConfig["topologyManagerPolicyOptions"].(map[string]interface{})
			if !ok {
				t.Errorf("topologyManagerPolicyOptions not created in config")
				return
			}

			// Check the NUMA setting
			numaValue, exists := topologyOpts["prefer-closest-numa-nodes"]
			if !exists {
				t.Errorf("prefer-closest-numa-nodes not set")
				return
			}

			if numaValue != tc.expectedValue {
				t.Errorf("expected prefer-closest-numa-nodes to be %s, got %v", tc.expectedValue, numaValue)
			}
		})
	}
}

// TestUpdateNodeStatusWithRetry tests the updateNodeStatusWithRetry function
func TestUpdateNodeStatusWithRetry(t *testing.T) {
	testCases := []struct {
		name           string
		existingStatus []NodeStatus
		nodeName       string
		state          string
		errMsg         string
		expectNewEntry bool
	}{
		{
			name: "Update existing status",
			existingStatus: []NodeStatus{
				{
					NodeName: "test-node",
					State:    NodeConfigStateConfiguring,
				},
			},
			nodeName:       "test-node",
			state:          NodeConfigStateConfigured,
			errMsg:         "",
			expectNewEntry: false,
		},
		{
			name:           "Add new status",
			existingStatus: []NodeStatus{},
			nodeName:       "test-node",
			state:          NodeConfigStateConfigured,
			errMsg:         "",
			expectNewEntry: true,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// Setup test environment
			ctx := context.Background()
			testScheme := setupTestScheme()

			// Create NodeConfig
			nodeConfig := &NodeConfig{
				ObjectMeta: metav1.ObjectMeta{
					Namespace: "default",
					Name:      "kubelet-config",
				},
				Spec: NodeConfigSpec{
					Nodes: []NodeConfiguration{
						{
							NodeName:               "test-node",
							EnableNUMADistance:     true,
							EnableStaticCPUManager: true,
						},
					},
				},
				Status: NodeConfigStatus{
					NodeStatuses: tc.existingStatus,
				},
			}

			// Create fake client
			client := fake.NewClientBuilder().
				WithScheme(testScheme).
				WithObjects(nodeConfig).
				WithStatusSubresource(&NodeConfig{}).
				Build()

			// Create controller
			r := NewMockNodeConfigController(client, testScheme)

			// Run the function
			err := r.updateNodeStatusWithRetry(ctx, nodeConfig, tc.nodeName, tc.state, tc.errMsg)

			// Check error
			if err != nil {
				t.Errorf("updateNodeStatusWithRetry: (%v)", err)
			}

			// Fetch the updated NodeConfig
			updatedNodeConfig := &NodeConfig{}
			err = client.Get(ctx, types.NamespacedName{
				Name:      "kubelet-config",
				Namespace: "default",
			}, updatedNodeConfig)

			if err != nil {
				t.Errorf("failed to get updated NodeConfig: %v", err)
			}

			// Check if status was updated correctly
			statusFound := false
			for _, status := range updatedNodeConfig.Status.NodeStatuses {
				if status.NodeName == tc.nodeName {
					statusFound = true
					if status.State != tc.state {
						t.Errorf("expected state to be %s, got %s", tc.state, status.State)
					}
					if status.Error != tc.errMsg {
						t.Errorf("expected error to be %s, got %s", tc.errMsg, status.Error)
					}
					break
				}
			}

			if !statusFound {
				t.Errorf("expected to find status for node %s", tc.nodeName)
			}

			// Check if a new entry was added if expected
			initialCount := len(tc.existingStatus)
			currentCount := len(updatedNodeConfig.Status.NodeStatuses)

			if tc.expectNewEntry && currentCount != initialCount+1 {
				t.Errorf("expected %d statuses, got %d", initialCount+1, currentCount)
			}

			if !tc.expectNewEntry && currentCount != initialCount {
				t.Errorf("expected %d statuses, got %d", initialCount, currentCount)
			}
		})
	}
}

// TestUpdateNUMADistanceSettings 测试 updateNUMADistanceSettings 函数
func TestUpdateNUMADistanceSettings(t *testing.T) {
	testCases := []struct {
		name             string
		config           map[string]interface{}
		enableNUMA       bool
		currentPolicy    string
		expectedModified bool
	}{
		{
			name:             "空配置启用NUMA",
			config:           map[string]interface{}{},
			enableNUMA:       true,
			currentPolicy:    "none",
			expectedModified: true,
		},
		{
			name:             "空配置禁用NUMA",
			config:           map[string]interface{}{},
			enableNUMA:       false,
			currentPolicy:    "none",
			expectedModified: false,
		},
		{
			name: "已有NUMA设置启用NUMA",
			config: map[string]interface{}{
				"cpuManagerPolicy": "static",
				"topologyManagerPolicyOptions": map[string]interface{}{
					"prefer-closest-numa-nodes": "true",
				},
			},
			enableNUMA:       true,
			currentPolicy:    "static",
			expectedModified: true,
		},
		{
			name: "已有NUMA设置禁用NUMA",
			config: map[string]interface{}{
				"cpuManagerPolicy": "static",
				"topologyManagerPolicyOptions": map[string]interface{}{
					"prefer-closest-numa-nodes": "true",
				},
			},
			enableNUMA:       false,
			currentPolicy:    "static",
			expectedModified: true,
		},
		{
			name:             "Nil配置",
			config:           nil,
			enableNUMA:       true,
			currentPolicy:    "none",
			expectedModified: false,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			r := &NodeConfigController{}

			// 执行函数
			modified := r.updateNUMADistanceSettings(tc.config, &NodeConfiguration{EnableNUMADistance: tc.enableNUMA},
				tc.currentPolicy)

			// 验证结果
			if modified != tc.expectedModified {
				t.Errorf("期望 updateNUMADistanceSettings 返回 %v, 得到 %v", tc.expectedModified, modified)
			}

			// 跳过nil配置检查
			if tc.config == nil {
				return
			}

			// 检查启用NUMA的情况
			if tc.enableNUMA {
				// 验证CPU管理策略
				if tc.currentPolicy != "static" {
					cpuPolicy, _ := tc.config["cpuManagerPolicy"].(string)
					if cpuPolicy != "static" {
						t.Errorf("期望 cpuManagerPolicy 为 static, 得到 %s", cpuPolicy)
					}
				}

				// 验证拓扑选项
				topologyOpts, ok := tc.config["topologyManagerPolicyOptions"].(map[string]interface{})
				if ok {
					numaValue, exists := topologyOpts["prefer-closest-numa-nodes"]
					if !exists || numaValue != "true" {
						t.Errorf("期望 prefer-closest-numa-nodes 为 true, 得到 %v", numaValue)
					}
				}
			} else if tc.expectedModified {
				// 禁用NUMA时，验证设置变为false
				topologyOpts, ok := tc.config["topologyManagerPolicyOptions"].(map[string]interface{})
				if ok {
					numaValue, exists := topologyOpts["prefer-closest-numa-nodes"]
					if !exists || numaValue != "false" {
						t.Errorf("期望 prefer-closest-numa-nodes 为 false, 得到 %v", numaValue)
					}
				}
			} else {
			}
		})
	}
}

// TestParseNUMADistanceOption 测试 parseNUMADistanceOption 函数
func TestParseNUMADistanceOption(t *testing.T) {
	testCases := []struct {
		name           string
		topologyOpts   interface{}
		expectedResult bool
	}{
		{
			name: "String接口类型为true",
			topologyOpts: map[string]interface{}{
				"prefer-closest-numa-nodes": "true",
			},
			expectedResult: true,
		},
		{
			name: "String接口类型为false",
			topologyOpts: map[string]interface{}{
				"prefer-closest-numa-nodes": "false",
			},
			expectedResult: false,
		},
		{
			name: "Interface{}接口类型为true",
			topologyOpts: map[interface{}]interface{}{
				"prefer-closest-numa-nodes": "true",
			},
			expectedResult: true,
		},
		{
			name: "Interface{}接口类型为false",
			topologyOpts: map[interface{}]interface{}{
				"prefer-closest-numa-nodes": "false",
			},
			expectedResult: false,
		},
		{
			name: "布尔值为true",
			topologyOpts: map[string]interface{}{
				"prefer-closest-numa-nodes": true,
			},
			expectedResult: true,
		},
		{
			name: "不包含NUMA选项",
			topologyOpts: map[string]interface{}{
				"other-option": "value",
			},
			expectedResult: false,
		},
		{
			name:           "非Map类型",
			topologyOpts:   "not-a-map",
			expectedResult: false,
		},
		{
			name:           "Nil值",
			topologyOpts:   nil,
			expectedResult: false,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			r := &NodeConfigController{}

			// 执行函数
			result := r.parseNUMADistanceOption(tc.topologyOpts)

			// 验证结果
			if result != tc.expectedResult {
				t.Errorf("期望 parseNUMADistanceOption 返回 %v, 得到 %v", tc.expectedResult, result)
			}
		})
	}
}

// TestSaveAndReadKubeletConfig 测试 saveKubeletConfig 和 readKubeletConfig 函数
func TestSaveAndReadKubeletConfig(t *testing.T) {
	testCases := []struct {
		name   string
		config map[string]interface{}
	}{
		{
			name: "基本配置",
			config: map[string]interface{}{
				"kind":             "KubeletConfiguration",
				"apiVersion":       "kubelet.config.k8s.io/v1beta1",
				"cpuManagerPolicy": "static",
			},
		},
	}

	// 创建临时目录用于测试
	tempDir, err := os.MkdirTemp("", "kubelet-test")
	if err != nil {
		t.Fatalf("创建临时目录失败: %v", err)
	}
	defer os.RemoveAll(tempDir)

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			r := &NodeConfigController{}

			// 创建配置文件路径
			configPath := filepath.Join(tempDir, "config.yaml")

			// 保存配置
			err := r.saveKubeletConfig(configPath, tc.config)
			if err != nil {
				t.Fatalf("保存配置失败: %v", err)
			}

			// 读取配置
			readConfig, err := r.readKubeletConfig(configPath)
			if err != nil {
				t.Fatalf("读取配置失败: %v", err)
			}

			// 验证保存和读取的配置一致
			validateConfigs(t, tc.config, readConfig)
		})
	}
}

// validateConfigs 辅助函数，验证两个配置映射是否一致
func validateConfigs(t *testing.T, expected, actual map[string]interface{}) {
	// 验证顶级键
	for key, expectedValue := range expected {
		actualValue, exists := actual[key]
		if !exists {
			t.Errorf("期望的配置键 %s 不存在", key)
			continue
		}

		// 根据值类型进行验证
		switch expVal := expectedValue.(type) {
		case map[string]interface{}:
			// 递归验证嵌套映射
			actVal, ok := actualValue.(map[string]interface{})
			if !ok {
				t.Errorf("键 %s: 期望映射类型，得到 %T", key, actualValue)
				continue
			}
			validateConfigs(t, expVal, actVal)
		default:
			// 直接比较其他类型
			if !reflect.DeepEqual(expectedValue, actualValue) {
				t.Errorf("键 %s: 期望值 %v，得到 %v", key, expectedValue, actualValue)
			}
		}
	}
}

// TestInitializeNodeConfig 测试 InitializeNodeConfig 函数
func TestInitializeNodeConfig(t *testing.T) {
	t.Skip("此测试需要重构InitializeNodeConfig函数以支持依赖注入")

	// 设置测试环境
	ctx := context.Background()
	testScheme := setupTestScheme()

	// 设置NODE_NAME环境变量
	oldNodeName := os.Getenv("NODE_NAME")
	err := os.Setenv("NODE_NAME", "test-node")
	if err != nil {
		t.Fatalf("设置NODE_NAME环境变量失败: %v", err)
	}
	defer os.Setenv("NODE_NAME", oldNodeName)

	testCases := []struct {
		name         string
		configExists bool
		nodeExists   bool
	}{
		{
			name:         "NodeConfig不存在，创建新的",
			configExists: false,
			nodeExists:   false,
		},
		{
			name:         "NodeConfig存在，节点不存在",
			configExists: true,
			nodeExists:   false,
		},
		{
			name:         "NodeConfig存在，节点存在",
			configExists: true,
			nodeExists:   true,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// 创建模拟客户端构建器
			clientBuilder := fake.NewClientBuilder().WithScheme(testScheme)

			// 如果配置存在，添加到客户端
			var nodeConfig *NodeConfig
			if tc.configExists {
				nodeConfig = &NodeConfig{
					ObjectMeta: metav1.ObjectMeta{
						Name:      "kubelet-config",
						Namespace: "default",
					},
					Spec: NodeConfigSpec{
						Nodes: []NodeConfiguration{},
					},
				}

				// 如果节点存在，添加到配置
				if tc.nodeExists && nodeConfig != nil {
					nodeConfig.Spec.Nodes = append(nodeConfig.Spec.Nodes, NodeConfiguration{
						NodeName:               "test-node",
						EnableStaticCPUManager: true,
						EnableNUMADistance:     true,
					})
				}

				if nodeConfig != nil {
					clientBuilder = clientBuilder.WithObjects(nodeConfig)
				}
			}

			// 创建客户端
			client := clientBuilder.Build()

			// 创建模拟控制器和测试文件系统
			r := NewMockNodeConfigController(client, testScheme)
			r.SetupKubeletConfig("static", true)

			// 执行InitializeNodeConfig函数
			err := InitializeNodeConfig(client)
			if err != nil {
				t.Fatalf("InitializeNodeConfig失败: %v", err)
			}

			// 验证结果
			updatedNodeConfig := &NodeConfig{}
			err = client.Get(ctx, types.NamespacedName{
				Name:      "kubelet-config",
				Namespace: "default",
			}, updatedNodeConfig)

			if err != nil {
				t.Fatalf("获取更新后的NodeConfig失败: %v", err)
			}

			// 验证节点存在于配置中
			nodeFound := false
			for _, node := range updatedNodeConfig.Spec.Nodes {
				if node.NodeName == "test-node" {
					nodeFound = true
					// 验证配置参数
					if !node.EnableStaticCPUManager {
						t.Errorf("期望EnableStaticCPUManager为true，得到false")
					}
					if !node.EnableNUMADistance {
						t.Errorf("期望EnableNUMADistance为true，得到false")
					}
					break
				}
			}

			if !nodeFound {
				t.Errorf("节点未添加到NodeConfig")
			}
		})
	}
}

// 重构后的 addNodeToExistingConfig 函数的测试
func TestAddNodeToExistingConfigRefactored(t *testing.T) {
	// 设置测试环境
	ctx := context.Background()
	testScheme := setupTestScheme()

	// 创建现有的 NodeConfig
	nodeConfig := &NodeConfig{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "kubelet-config",
			Namespace: "default",
		},
		Spec: NodeConfigSpec{
			Nodes: []NodeConfiguration{
				{
					NodeName:               "existing-node",
					EnableStaticCPUManager: true,
					EnableNUMADistance:     false,
				},
			},
		},
	}

	// 创建客户端
	cl := fake.NewClientBuilder().
		WithScheme(testScheme).
		WithObjects(nodeConfig).
		Build()

	// 创建依赖注入的 NodeConfigHelper
	helper := &NodeConfigHelper{
		Client: cl,
	}

	// 执行测试函数
	err := helper.AddNodeToExistingConfig(ctx, "test-node")
	assert.NoError(t, err, "AddNodeToExistingConfig 应该成功")

	// 验证结果
	updatedNodeConfig := &NodeConfig{}
	err = cl.Get(ctx, types.NamespacedName{
		Name:      "kubelet-config",
		Namespace: "default",
	}, updatedNodeConfig)
	assert.NoError(t, err, "获取更新后的 NodeConfig 应该成功")

	// 验证节点数量
	assert.Equal(t, 2, len(updatedNodeConfig.Spec.Nodes), "应该有两个节点")

	// 验证新节点已添加
	var newNode *NodeConfiguration
	for i := range updatedNodeConfig.Spec.Nodes {
		if updatedNodeConfig.Spec.Nodes[i].NodeName == "test-node" {
			newNode = &updatedNodeConfig.Spec.Nodes[i]
			break
		}
	}

	assert.NotNil(t, newNode, "新节点应该存在")
	if newNode != nil {
		assert.True(t, newNode.EnableStaticCPUManager, "EnableStaticCPUManager 应该为 true")
		assert.True(t, newNode.EnableNUMADistance, "EnableNUMADistance 应该为 true")
	}
}

// TestAddNodeToExistingConfigInheritUniformFlags verifies that when existing nodes
// share the same desired flags, the newly added node inherits those flags.
func TestAddNodeToExistingConfigInheritUniformFlags(t *testing.T) {
	ctx := context.Background()
	testScheme := setupTestScheme()

	oldPath := KubeletConfigPath
	tmpDir := t.TempDir()
	tmpKubeletConfig := filepath.Join(tmpDir, "kubelet-config.yaml")
	KubeletConfigPath = tmpKubeletConfig
	defer func() {
		KubeletConfigPath = oldPath
	}()

	// This fallback config should not win when existing node flags are uniform.
	err := os.WriteFile(tmpKubeletConfig, []byte("cpuManagerPolicy: none\n"), 0644)
	if err != nil {
		t.Fatalf("failed to write temp kubelet config: %v", err)
	}

	nodeConfig := &NodeConfig{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "kubelet-config",
			Namespace: "default",
		},
		Spec: NodeConfigSpec{
			Nodes: []NodeConfiguration{
				{
					NodeName:               "existing-node-1",
					EnableStaticCPUManager: true,
					EnableNUMADistance:     true,
					KubeletConfigPath:      KubeletConfigPath,
				},
			},
		},
	}

	cl := fake.NewClientBuilder().
		WithScheme(testScheme).
		WithObjects(nodeConfig).
		Build()

	err = addNodeToExistingConfig(ctx, cl, nodeConfig, "new-node")
	if err != nil {
		t.Fatalf("addNodeToExistingConfig failed: %v", err)
	}

	updated := &NodeConfig{}
	err = cl.Get(ctx, types.NamespacedName{Name: "kubelet-config", Namespace: "default"}, updated)
	if err != nil {
		t.Fatalf("failed to get updated NodeConfig: %v", err)
	}

	var found *NodeConfiguration
	for i := range updated.Spec.Nodes {
		if updated.Spec.Nodes[i].NodeName == "new-node" {
			found = &updated.Spec.Nodes[i]
			break
		}
	}

	if found == nil {
		t.Fatalf("new node was not appended to NodeConfig")
	}

	if !found.EnableStaticCPUManager {
		t.Errorf("expected EnableStaticCPUManager=true for new node, got false")
	}
	if !found.EnableNUMADistance {
		t.Errorf("expected EnableNUMADistance=true for new node, got false")
	}
}

// NodeConfigHelper 是用于依赖注入的辅助结构体
// 这是重构建议的一部分，提供了一种方式来将 client 传递给函数
type NodeConfigHelper struct {
	Client client.Client
}

// AddNodeToExistingConfig 是重构后的函数，支持依赖注入
// 这是原始 addNodeToExistingConfig 函数的替代实现
func (h *NodeConfigHelper) AddNodeToExistingConfig(ctx context.Context, nodeName string) error {
	// 查找现有的 NodeConfig
	nodeConfig := &NodeConfig{}
	err := h.Client.Get(ctx, types.NamespacedName{
		Name:      "kubelet-config", // 假设名称是固定的
		Namespace: "default",        // 假设命名空间是固定的
	}, nodeConfig)
	if err != nil {
		return err
	}

	// 检查节点是否已存在
	for _, node := range nodeConfig.Spec.Nodes {
		if node.NodeName == nodeName {
			// 节点已存在，无需添加
			return nil
		}
	}

	// 添加新节点
	nodeConfig.Spec.Nodes = append(nodeConfig.Spec.Nodes, NodeConfiguration{
		NodeName:               nodeName,
		EnableStaticCPUManager: true,
		EnableNUMADistance:     true,
	})

	// 更新 NodeConfig
	return h.Client.Update(ctx, nodeConfig)
}

// TestCreateAndAddNodeConfig 测试 createNodeConfigCR 函数
// 这个函数不依赖于包级别函数，可以直接测试
func TestCreateAndAddNodeConfig(t *testing.T) {
	// 设置测试环境
	ctx := context.Background()
	testScheme := setupTestScheme()

	// 创建客户端
	client := fake.NewClientBuilder().
		WithScheme(testScheme).
		Build()

	// 执行函数
	err := createNodeConfigCR(ctx, client, "test-node", true, true)
	if err != nil {
		t.Fatalf("createNodeConfigCR失败: %v", err)
	}

	// 验证结果
	createdNodeConfig := &NodeConfig{}
	err = client.Get(ctx, types.NamespacedName{
		Name:      "kubelet-config",
		Namespace: "default",
	}, createdNodeConfig)

	if err != nil {
		t.Fatalf("获取创建的NodeConfig失败: %v", err)
	}

	// 验证节点配置
	if len(createdNodeConfig.Spec.Nodes) != 1 {
		t.Errorf("期望节点数为1，得到%d", len(createdNodeConfig.Spec.Nodes))
	}

	if len(createdNodeConfig.Spec.Nodes) > 0 {
		node := createdNodeConfig.Spec.Nodes[0]
		if node.NodeName != "test-node" {
			t.Errorf("期望NodeName为test-node，得到%s", node.NodeName)
		}
		if !node.EnableStaticCPUManager {
			t.Errorf("期望EnableStaticCPUManager为true，得到false")
		}
		if !node.EnableNUMADistance {
			t.Errorf("期望EnableNUMADistance为true，得到false")
		}
		if node.KubeletConfigPath != "/var/lib/kubelet/config.yaml" {
			t.Errorf("期望KubeletConfigPath为/var/lib/kubelet/config.yaml，得到%s", node.KubeletConfigPath)
		}
	}
}

// TestParseCurrentConfiguration 测试 parseCurrentConfiguration 函数
// 这个函数是 NodeConfigController 的一个方法，可以直接测试而不是analyzeCurrentConfig
func TestParseCurrentConfiguration(t *testing.T) {
	testCases := []struct {
		name                     string
		config                   map[string]interface{}
		expectedStaticCPUEnabled bool
		expectedNUMAEnabled      bool
	}{
		{
			name: "启用了CPU和NUMA",
			config: map[string]interface{}{
				"cpuManagerPolicy": "static",
				"topologyManagerPolicyOptions": map[string]interface{}{
					"prefer-closest-numa-nodes": "true",
				},
			},
			expectedStaticCPUEnabled: true,
			expectedNUMAEnabled:      true,
		},
		{
			name: "仅启用了CPU",
			config: map[string]interface{}{
				"cpuManagerPolicy": "static",
			},
			expectedStaticCPUEnabled: true,
			expectedNUMAEnabled:      false,
		},
		{
			name: "仅启用了NUMA",
			config: map[string]interface{}{
				"cpuManagerPolicy": "none",
				"topologyManagerPolicyOptions": map[string]interface{}{
					"prefer-closest-numa-nodes": "true",
				},
			},
			expectedStaticCPUEnabled: false,
			expectedNUMAEnabled:      true,
		},
		{
			name: "都未启用",
			config: map[string]interface{}{
				"cpuManagerPolicy": "none",
			},
			expectedStaticCPUEnabled: false,
			expectedNUMAEnabled:      false,
		},
		{
			name: "NUMA值为false",
			config: map[string]interface{}{
				"cpuManagerPolicy": "static",
				"topologyManagerPolicyOptions": map[string]interface{}{
					"prefer-closest-numa-nodes": "false",
				},
			},
			expectedStaticCPUEnabled: true,
			expectedNUMAEnabled:      false,
		},
		{
			name:                     "空配置",
			config:                   map[string]interface{}{},
			expectedStaticCPUEnabled: false,
			expectedNUMAEnabled:      false,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// 创建控制器
			r := &NodeConfigController{}

			// 执行函数
			staticCPUEnabled, numaEnabled := r.parseCurrentConfiguration(tc.config)

			// 验证结果
			if staticCPUEnabled != tc.expectedStaticCPUEnabled {
				t.Errorf("期望staticCPUEnabled为%v，得到%v", tc.expectedStaticCPUEnabled, staticCPUEnabled)
			}
			if numaEnabled != tc.expectedNUMAEnabled {
				t.Errorf("期望numaEnabled为%v，得到%v", tc.expectedNUMAEnabled, numaEnabled)
			}
		})
	}
}