cmd

var HelperCmd = &cobra.Command{
	Use:   "k8s-helper",
	Short: "Helper for running in Kubernetes",
	RunE: func(cmd *cobra.Command, args []string) error {
		ctx := cmd.Context()

		restart, _ := cmd.Flags().GetBool("restart")
		if restart {
			if err := runScript(ctx, restartScript, true); err != nil {
				return fmt.Errorf("error restarting: %w", err)
			}
		}

		setupHost, _ := cmd.Flags().GetBool("setup-host")
		if setupHost {
			if err := runScript(ctx, setupHostScript, true); err != nil {
				return fmt.Errorf("error setting up host: %w", err)
			}
		}

		startChroot, _ := cmd.Flags().GetBool("start-chroot")
		startChroot = startChroot || setupHost

		return startHelper(ctx, config.Global.Address, config.Global.Protocol)
	},
}

var QueryCmd = &cobra.Command{
	Use:   "k8s",
	Short: "Query k8s containers",
	Args:  cobra.ArbitraryArgs,
	RunE: func(cmd *cobra.Command, args []string) error {
		client, ok := cmd.Context().Value(keys.CLIENT_CONTEXT_KEY).(*client.Client)
		if !ok {
			return fmt.Errorf("invalid client in context")
		}

		root, _ := cmd.Flags().GetString(runc_flags.RootFlag.Full)
		namespace, _ := cmd.Flags().GetString(containerd_flags.NamespaceFlag.Full)
		names, _ := cmd.Flags().GetStringSlice(k8s_flags.NameFlag.Full)
		sandboxes, _ := cmd.Flags().GetStringSlice(k8s_flags.SandboxFlag.Full)

		req := &daemon.QueryReq{
			Type: "k8s",
			K8S: &k8s.QueryReq{
				Root:           root,
				Namespace:      namespace,
				ContainerNames: names,
				SandboxNames:   sandboxes,
			},
		}

		resp, err := client.Query(cmd.Context(), req)
		if err != nil {
			return err
		}

		result := resp.K8S

		if len(result.Containers) == 0 {
			fmt.Println("No containers found")
			return nil
		}

		tableWriter := table.NewWriter()
		tableWriter.SetStyle(style.TableStyle)
		tableWriter.SetOutputMirror(os.Stdout)

		tableWriter.AppendHeader(table.Row{
			"Sandbox ID",
			"Sandbox Name",
			"Sandbox Namespace",
			"Sandbox UID",
			"Image",
			"Container ID",
			"Bundle",
			"Root",
		})

		tableWriter.SortBy([]table.SortBy{
			{Name: "Sandbox ID", Mode: table.Asc},
		})

		for _, container := range result.Containers {
			tableWriter.AppendRow(table.Row{
				container.SandboxID,
				container.SandboxName,
				container.SandboxNamespace,
				container.SandboxUID,
				container.Image,
				container.Runc.ID,
				container.Runc.Bundle,
				container.Runc.Root,
			})
		}

		tableWriter.Render()

		if len(resp.Messages) > 0 {
			fmt.Println()
		}
		for _, msg := range resp.Messages {
			fmt.Println(msg)
		}

		return nil
	},
}