"istio.io/istio/pkg/config/mesh"
	"istio.io/istio/pkg/config/schema/gvk"
	"istio.io/istio/pkg/kube"
	"istio.io/istio/pkg/kube/kclient/clienttest"
	"istio.io/istio/pkg/util/sets"
)

func newFakeController() (model.ConfigStoreController, kube.Client) {
	meshHolder := mesh.NewTestWatcher(&meshconfig.MeshConfig{
		IngressControllerMode: meshconfig.MeshConfig_DEFAULT,
	})
	fakeClient := kube.NewFakeClient()

			kubeConfigSha: [32]byte{},
			stop:          stop,
		})
	}
}

func (f *Fake) Delete(id cluster.ID) {
	for _, handler := range f.handlers {
		handler.clusterDeleted(id)
	}
}

func NewFakeController() *Fake {
	return &Fake{}

	stop := test.NewStop(t)
	localClient := kube.NewFakeClient()
	localClient.RunAndWait(stop)
	remoteClient := kube.NewFakeClient()
	remoteClient.RunAndWait(stop)
	mc := multicluster.NewFakeController()
	sc := NewMulticluster("local", mc)
	mc.Add("local", localClient, stop)
	mc.Add("remote", remoteClient, stop)
	mc.Add("remote2", remoteClient, stop)
	cases := []struct {
		cluster cluster2.ID

	primaryClient := kube.NewFakeClient(primaryClusterPods...)

	remoteClient := kube.NewFakeClient(remoteClusterPods...)

	remote2Client := kube.NewFakeClient(remoteCluster2Pods...)

	mc := multicluster.NewFakeController()
	mNa := NewMulticlusterNodeAuthenticator(allowZtunnel, mc)
	stop := test.NewStop(t)
	mc.Add("primary", primaryClient, stop)
	mc.Add("remote", remoteClient, stop)
	mc.Add("remote2", remote2Client, stop)

		},
	}

	for _, c := range testCases {
		t.Run(c.name, func(t *testing.T) {
			test.SetForTest(t, &features.CATrustedNodeAccounts, c.trustedNodeAccounts)

			multiClusterController := multicluster.NewFakeController()
			server, _ := New(c.ca, time.Duration(1), c.authenticators, multiClusterController)

			var pods []runtime.Object
			for _, p := range c.pods {

			})
		})
	}
	var xdsUpdater model.XDSUpdater = s
	if opts.EnableFakeXDSUpdater {
		xdsUpdater = xdsfake.NewWithDelegate(s)
	}
	mc := multicluster.NewFakeController()
	creds := kubesecrets.NewMulticluster(opts.DefaultClusterName, mc)

	configController := memory.NewSyncController(memory.MakeSkipValidation(collections.PilotGatewayAPI()))
	clientBuilder := opts.KubeClientBuilder

		informerFactory.Core().V1().Pods().Informer().GetStore(),
		informerFactory.Core().V1().Services().Informer().GetStore(),
		informerFactory.Core().V1().Endpoints().Informer().GetStore(),
	}
}

func newFakeController(ctx context.Context, batchPeriod time.Duration) (*fake.Clientset, *endpointController) {
	client := fake.NewSimpleClientset()
	informerFactory := informers.NewSharedInformerFactory(client, controllerpkg.NoResyncPeriodFunc())

			t.Run("webhook", func(t *testing.T) {
				env := &model.Environment{}
				env.SetPushContext(&model.PushContext{
					ProxyConfigs: &model.ProxyConfigs{},
				})

				multi := multicluster.NewFakeController()
				client := kube.NewFakeClient(
					&corev1.Namespace{
						ObjectMeta: metav1.ObjectMeta{
							Name: "test-ns",
							Annotations: map[string]string{