cmd

var (
	InfrastructureCells = []cell.Cell{

		cell.ProvidePrivate(func(cfg operatorPprofConfig) pprof.Config {
			return cfg.Config()
		}),
		pprof.Cell(defaultOperatorPprofConfig),

		gops.Cell(defaults.EnableGops, defaults.GopsPortOperator),

		client.Cell,
		cell.ProvidePrivate(func(clientParams operatorClientParams) k8sClient.ClientParams {
			return k8sClient.ClientParams{
				K8sClientQPS:   clientParams.OperatorK8sClientQPS,
				K8sClientBurst: clientParams.OperatorK8sClientBurst,
			}
		}),
		cell.Config(operatorClientParams{
			OperatorK8sClientQPS:   100.0,
			OperatorK8sClientBurst: 200,
		}),

		cell.Provide(k8s.ServiceResource),
		dial.ResourceServiceResolverCell,

		cell.Provide(kvstoreExtraOptions),
		kvstore.Cell(kvstore.DisabledBackendName),

		operatorMetrics.Cell,
		cell.Provide(func(
			operatorCfg *operatorOption.OperatorConfig,
		) operatorMetrics.SharedConfig {
			return operatorMetrics.SharedConfig{

				EnableMetrics: operatorCfg.EnableMetrics,
			}
		}),

		shell.ServerCell(defaults.ShellSockPath),
	}

	ControlPlaneCells = []cell.Cell{
		cell.Config(cmtypes.DefaultClusterInfo),
		cell.Config(cmtypes.DefaultPolicyConfig),
		cell.Invoke(cmtypes.ClusterInfo.InitClusterIDMax),
		cell.Invoke(cmtypes.ClusterInfo.Validate),

		cell.Provide(func() *option.DaemonConfig {
			return option.Config
		}),

		cell.Provide(func() *operatorOption.OperatorConfig {
			return operatorOption.Config
		}),

		ipsec.OperatorCell,
		wgAgent.OperatorCell,

		cell.Provide(func(
			daemonCfg *option.DaemonConfig,
			operatorCfg *operatorOption.OperatorConfig,
		) identitygc.SharedConfig {
			return identitygc.SharedConfig{
				IdentityAllocationMode: daemonCfg.IdentityAllocationMode,
			}
		}),

		cell.Provide(func(
			daemonCfg *option.DaemonConfig,
		) ciliumendpointslice.SharedConfig {
			return ciliumendpointslice.SharedConfig{
				EnableCiliumEndpointSlice: daemonCfg.EnableCiliumEndpointSlice,
			}
		}),

		cell.Provide(func(
			operatorCfg *operatorOption.OperatorConfig,
			daemonCfg *option.DaemonConfig,
		) endpointgc.SharedConfig {
			return endpointgc.SharedConfig{
				Interval:                 operatorCfg.EndpointGCInterval,
				DisableCiliumEndpointCRD: daemonCfg.DisableCiliumEndpointCRD,
			}
		}),

		cell.Provide(func(
			operatorCfg *operatorOption.OperatorConfig,
			daemonCfg *option.DaemonConfig,
			clientset k8sClient.Clientset,
		) unmanagedpods.SharedConfig {
			return unmanagedpods.SharedConfig{
				DisableCiliumEndpointCRD: daemonCfg.DisableCiliumEndpointCRD,
				K8sEnabled:               clientset.IsEnabled(),
			}
		}),

		cell.Provide(func(
			daemonCfg *option.DaemonConfig,
			clientset k8sClient.Clientset,
		) policyderivative.SharedConfig {
			return policyderivative.SharedConfig{
				EnableCiliumNetworkPolicy:            daemonCfg.EnableCiliumNetworkPolicy,
				EnableCiliumClusterwideNetworkPolicy: daemonCfg.EnableCiliumClusterwideNetworkPolicy,
				ClusterName:                          daemonCfg.ClusterName,
				K8sEnabled:                           clientset.IsEnabled(),
			}
		}),

		cell.Provide(func(
			daemonCfg *option.DaemonConfig,
		) ciliumidentity.SharedConfig {
			return ciliumidentity.SharedConfig{
				EnableCiliumEndpointSlice: daemonCfg.EnableCiliumEndpointSlice,
				DisableNetworkPolicy:      !option.NetworkPolicyEnabled(daemonCfg),
			}
		}),

		api.HealthHandlerCell(
			isLeader.Load,
		),
		api.MetricsHandlerCell,
		controller.Cell,
		operatorApi.SpecCell,
		api.ServerCell,
	}

	// These cells are started only after the operator is elected leader.
	ControlPlaneLeaderCells = []cell.Cell{

		apis.RegisterCRDsCell,
		operatorK8s.ResourcesCell,

		heartbeat.Enabled,
		heartbeat.Cell,

		clustercfgcell.WithSyncedCanaries(false),
		clustercfgcell.Cell,

		bgp.Cell,
		lbipam.Cell,
		nodeipam.Cell,
		auth.Cell,
		store.Cell,
		cmoperator.Cell,
		endpointslicesync.Cell,
		mcsapi.Cell,
		locksweeper.Cell,
		legacyCell,

		identitygc.Cell,

		ciliumidentity.Cell,

		doublewrite.Cell,

		ciliumendpointslice.Cell,

		endpointgc.Cell,

		unmanagedpods.Cell,

		policyderivative.Cell,

		endpointslicegc.Cell,

		controllerruntime.Cell,

		gatewayapi.Cell,

		ingress.Cell,

		secretsync.Cell,

		cmnamespace.Cell,

		cell.Provide(func(cfg *operatorOption.OperatorConfig, dcfg *option.DaemonConfig) operatorWatchers.ServiceSyncConfig {
			return operatorWatchers.ServiceSyncConfig{
				Enabled: cfg.SyncK8sServices,
			}
		}),
		operatorWatchers.ServiceSyncCell,

		mcsapi.ServiceExportSyncCell,

		ciliumenvoyconfig.Cell,

		networkpolicy.Cell,

		networkpolicy.SecretSyncCell,

		features.Cell,

		nodesgc.Cell,

		ztunnel.Cell,
	}
)

var MetricsCmd = &cobra.Command{
	Use:   "metrics",
	Short: "Access metric status of the operator",
}

var MetricsListCmd = &cobra.Command{
	Use:   "list",
	Short: "List all metrics for the operator",
	Run: func(cmd *cobra.Command, args []string) {

		logger := logging.DefaultSlogLogger

		c := client.NewHTTPClientWithConfig(
			strfmt.Default, client.DefaultTransportConfig().WithHost(operatorAddr))

		res, err := c.Metrics.GetMetrics(nil)
		if err != nil {
			logging.Fatal(logger, fmt.Sprintf("Cannot get metrics list: %s", err))
		}

		re, err := regexp.Compile(matchPattern)
		if err != nil {
			logging.Fatal(logger, fmt.Sprintf("Cannot compile regex: %s", err))
		}

		metrics := make([]*models.Metric, 0, len(res.Payload))
		for _, metric := range res.Payload {
			if re.MatchString(metric.Name) {
				metrics = append(metrics, metric)
			}
		}

		if command.OutputOption() {
			if err := command.PrintOutput(metrics); err != nil {
				os.Exit(1)
			}
			return
		}

		w := tabwriter.NewWriter(os.Stdout, 5, 0, 3, ' ', 0)

		fmt.Fprintln(w, "Metric\tLabels\tValue")
		for _, metric := range metrics {
			label := ""
			if len(metric.Labels) > 0 {
				labelArray := []string{}
				for key, value := range metric.Labels {
					labelArray = append(labelArray, fmt.Sprintf(`%s="%s"`, key, value))
				}
				label = strings.Join(labelArray, " ")
			}
			fmt.Fprintf(w, "%s\t%s\t%f\n", metric.Name, label, metric.Value)
		}
		w.Flush()
	},
}

var StatusClusterMesh = func() *cobra.Command {
	var host string
	var verbose bool

	cmd := &cobra.Command{
		Use:   "clustermesh",
		Short: "Display status of remote clusters",
		Run:   func(cmd *cobra.Command, args []string) { status(cmd.Context(), host, cmd.OutOrStdout(), verbose) },

		PersistentPreRun: func(cmd *cobra.Command, args []string) {
			ctx, _ := signal.NotifyContext(context.Background(), os.Interrupt)
			cmd.SetContext(ctx)
		},
	}

	StatusCmd.AddCommand(cmd)
	command.AddOutputOption(cmd)

	cmd.Flags().StringVarP(&host, "server-address", "s", api.OperatorAPIServeAddrDefault, "Address of the operator API server")
	cmd.Flags().BoolVar(&verbose, "verbose", false, "Output verbose status information for ready clusters as well")

	return cmd
}()

var StatusCmd = &cobra.Command{
	Use:   "status",
	Short: "Display status of operator",
}