package validation

import (
	resourcequotaapi "k8s.io/apiserver/pkg/admission/plugin/resourcequota/apis/resourcequota"

	"k8s.io/apimachinery/pkg/util/validation/field"
)

// ValidateConfiguration validates the configuration.
func ValidateConfiguration(config *resourcequotaapi.Configuration) field.ErrorList {
	allErrs := field.ErrorList{}
	fldPath := field.NewPath("limitedResources")
	for i, limitedResource := range config.LimitedResources {

			Resource:      "persistentvolumeclaims",
			MatchContains: []string{"requests.storage"},
		}},
	},
	}
	for i := range successCases {
		configuration := successCases[i]
		if errs := ValidateConfiguration(&configuration); len(errs) != 0 {
			t.Errorf("expected success: %v", errs)
		}
	}
	errorCases := map[string]resourcequotaapi.Configuration{

	"k8s.io/kubernetes/pkg/apis/core/validation"
	internalapi "k8s.io/kubernetes/plugin/pkg/admission/podtolerationrestriction/apis/podtolerationrestriction"
)

// ValidateConfiguration validates the configuration.
func ValidateConfiguration(config *internalapi.Configuration) error {
	allErrs := field.ErrorList{}
	fldpath := field.NewPath("podtolerationrestriction")

	eventratelimitapi.NamespaceLimitType:       true,
	eventratelimitapi.UserLimitType:            true,
	eventratelimitapi.SourceAndObjectLimitType: true,
}

// ValidateConfiguration validates the configuration.
func ValidateConfiguration(config *eventratelimitapi.Configuration) field.ErrorList {
	allErrs := field.ErrorList{}
	limitsPath := field.NewPath("limits")
	if len(config.Limits) == 0 {

			Default: []api.Toleration{{Operator: "Equal", Value: "bar", Effect: "NoSchedule"}},
		},
		testName:   "Invalid case",
		testStatus: false,
	}}

	for i := range tests {
		errs := ValidateConfiguration(&tests[i].config)
		if tests[i].testStatus && errs != nil {
			t.Errorf("Test: %s, expected success: %v", tests[i].testName, errs)
		}
		if !tests[i].testStatus && errs == nil {

	if err != nil {
		return nil, err
	}
	externalConfig, ok := decodedObj.(*internalapi.Configuration)
	if !ok {
		return nil, fmt.Errorf("unexpected type: %T", decodedObj)
	}

	if err := validation.ValidateConfiguration(externalConfig); err != nil {
		return nil, err
	}

	return externalConfig, nil

				Type:      "Namespace",
				Burst:     10,
				QPS:       2,
				CacheSize: -1,
			}},
		},
		expectedResult: false,
	}}
	for _, tc := range cases {
		errs := ValidateConfiguration(&tc.config)
		if e, a := tc.expectedResult, len(errs) == 0; e != a {
			if e {
				t.Errorf("%v: expected success: %v", tc.name, errs)
			} else {
				t.Errorf("%v: expected failure", tc.name)
			}
		}

			configuration, err := LoadConfiguration(config)
			if err != nil {
				return nil, err
			}
			// validate the configuration (if any)
			if configuration != nil {
				if errs := validation.ValidateConfiguration(configuration); len(errs) != 0 {
					return nil, errs.ToAggregate()
				}
			}
			return newEventRateLimit(configuration, clock.RealClock{})
		})
}

			configuration, err := LoadConfiguration(config)
			if err != nil {
				return nil, err
			}
			// validate the configuration (if any)
			if configuration != nil {
				if errs := validation.ValidateConfiguration(configuration); len(errs) != 0 {
					return nil, errs.ToAggregate()
				}
			}
			return NewResourceQuota(configuration, 5)
		})
}

	}
	if err := p.delegate.CompleteConfiguration(); err != nil {
		return fmt.Errorf("%s configuration error: %w", PluginName, err)
	}
	if err := p.delegate.ValidateConfiguration(); err != nil {
		return fmt.Errorf("%s invalid: %w", PluginName, err)
	}
	return nil
}

var (
	applicableResources = map[schema.GroupResource]bool{
		corev1.Resource("pods"):       true,