import (
	"istio.io/istio/pilot/pkg/features"
	"istio.io/istio/pkg/config/schema/collection"
)

var Istio = Pilot.Add(MeshNetworks).Add(MeshConfig)

func PilotGatewayAPI() collection.Schemas {
	if features.EnableAlphaGatewayAPI {
		return pilotGatewayAPI
	}
	return pilotStableGatewayAPI

	{{- range .Entries }}
		{{- if (contains .Resource.Group "istio.io") }}
		MustAdd({{ .Resource.Identifier }}).
		{{- end}}
	{{- end }}
		Build()

	// pilotGatewayAPI contains only collections used by Pilot, including the full Gateway API.
	pilotGatewayAPI = collection.NewSchemasBuilder().
	{{- range .Entries }}
		{{- if or (contains .Resource.Group "istio.io") (contains .Resource.Group "gateway.networking.k8s.io") }}

	if s.kubeClient == nil {
		return nil
	}

	log.Info("initializing config validator")
	// always start the validation server
	params := server.Options{
		Schemas:      collections.PilotGatewayAPI(),
		DomainSuffix: args.RegistryOptions.KubeOptions.DomainSuffix,
		Mux:          s.httpsMux,
	}
	_, err := server.New(params)
	if err != nil {
		return err
	}

		MustAdd(Telemetry).
		MustAdd(VirtualService).
		MustAdd(WasmPlugin).
		MustAdd(WorkloadEntry).
		MustAdd(WorkloadGroup).
		Build()

	// pilotGatewayAPI contains only collections used by Pilot, including the full Gateway API.
	pilotGatewayAPI = collection.NewSchemasBuilder().
			MustAdd(AuthorizationPolicy).
			MustAdd(DestinationRule).
			MustAdd(Gateway).
			MustAdd(PeerAuthentication).

func TestClient(t *testing.T) {
	store, _ := makeClient(t, collections.PilotGatewayAPI().Union(collections.Kube), nil)
	configName := "test"
	configNamespace := "test-ns"
	timeout := retry.Timeout(time.Millisecond * 200)
	for _, r := range collections.PilotGatewayAPI().All() {
		name := r.Kind()
		t.Run(name, func(t *testing.T) {
			configMeta := config.Meta{

			return nil, nil, fmt.Errorf("cannot parse proto message: %v", err)
		}
		if reflect.DeepEqual(obj, empty) {
			continue
		}

		gvk := obj.GroupVersionKind()
		s, exists := collections.PilotGatewayAPI().FindByGroupVersionAliasesKind(resource.FromKubernetesGVK(&gvk))
		if !exists {
			log.Debugf("unrecognized type %v", obj.Kind)
			others = append(others, obj)
			continue
		}

	}
	mc := multicluster.NewFakeController()
	creds := kubesecrets.NewMulticluster(opts.DefaultClusterName, mc)

	configController := memory.NewSyncController(memory.MakeSkipValidation(collections.PilotGatewayAPI()))
	clientBuilder := opts.KubeClientBuilder
	if clientBuilder == nil {
		clientBuilder = func(objects ...runtime.Object) kubelib.Client {
			return kubelib.NewFakeClientWithVersion(opts.KubernetesVersion, objects...)

	t.Helper()
	configs := getConfigs(t, opts)
	cc := opts.ConfigController
	if cc == nil {
		cc = memory.NewSyncController(memory.MakeSkipValidation(collections.PilotGatewayAPI()))
	}
	controllers := []model.ConfigStoreController{cc}
	if opts.CreateConfigStore != nil {
		controllers = append(controllers, opts.CreateConfigStore(cc))
	}

		MustAdd(Telemetry).
		MustAdd(VirtualService).
		MustAdd(WasmPlugin).
		MustAdd(WorkloadEntry).
		MustAdd(WorkloadGroup).
		Build()

	// pilotGatewayAPI contains only collections used by Pilot, including the full Gateway API.
	pilotGatewayAPI = collection.NewSchemasBuilder().
			MustAdd(AuthorizationPolicy).
			MustAdd(DestinationRule).
			MustAdd(EnvoyFilter).
			MustAdd(GRPCRoute).
			MustAdd(Gateway).

}

var _ model.ConfigStoreController = &Client{}

func New(client kube.Client, opts Option) *Client {
	schemas := collections.Pilot
	if features.EnableGatewayAPI {
		schemas = collections.PilotGatewayAPI()
	}
	return NewForSchemas(client, opts, schemas)
}

func NewForSchemas(client kube.Client, opts Option, schemas collection.Schemas) *Client {
	schemasByCRDName := map[string]resource.Schema{}