cmd

var DumpCmd = &cobra.Command{
	Use:   "runc <container-id>",
	Short: "Dump a runc container",
	Args:  cobra.ArbitraryArgs,
	RunE: func(cmd *cobra.Command, args []string) error {
		req, ok := cmd.Context().Value(keys.DUMP_REQ_CONTEXT_KEY).(*daemon.DumpReq)
		if !ok {
			return fmt.Errorf("invalid dump request in context")
		}

		var id string
		if len(args) > 0 {
			id = args[0]
		}

		root, _ := cmd.Flags().GetString(runc_flags.RootFlag.Full)

		req.Type = "runc"
		req.Details = &daemon.Details{Runc: &runc.Runc{
			ID:   id,
			Root: root,
		}}

		ctx := context.WithValue(cmd.Context(), keys.DUMP_REQ_CONTEXT_KEY, req)
		cmd.SetContext(ctx)

		return nil
	},
}

var ManageCmd = &cobra.Command{
	Use:   "runc <container-id>",
	Short: "manage an existing runc container",
	Args:  cobra.ExactArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		req, ok := cmd.Context().Value(keys.RUN_REQ_CONTEXT_KEY).(*daemon.RunReq)
		if !ok {
			return fmt.Errorf("invalid run request in context")
		}

		id := args[0]

		root, _ := cmd.Flags().GetString(runc_flags.RootFlag.Full)
		bundle, _ := cmd.Flags().GetString(runc_flags.BundleFlag.Full)

		req.Type = "runc"
		req.Details = &daemon.Details{Runc: &runc.Runc{
			Root:   root,
			Bundle: bundle,
			ID:     id,
		}}

		ctx := context.WithValue(cmd.Context(), keys.DUMP_REQ_CONTEXT_KEY, req)
		cmd.SetContext(ctx)

		return nil
	},
}

var QueryCmd = &cobra.Command{
	Use:   "runc",
	Short: "Query runc containers. Can provide multiple IDs or names.",
	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)
		ids, _ := cmd.Flags().GetStringSlice(runc_flags.IdFlag.Full)

		req := &daemon.QueryReq{
			Type: "runc",
			Runc: &runc.QueryReq{
				Root: root,
				IDs:  ids,
			},
		}

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

		result := resp.Runc

		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{
			"ID",
			"Bundle",
			"Root",
		})

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

		for _, container := range result.Containers {
			tableWriter.AppendRow(table.Row{
				container.ID,
				container.Bundle,
				container.Root,
			})
		}

		tableWriter.Render()

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

		return nil
	},
}

var RestoreCmd = &cobra.Command{
	Use:   "runc",
	Short: "Restore a runc container",
	Args:  cobra.NoArgs,
	RunE: func(cmd *cobra.Command, args []string) error {
		req, ok := cmd.Context().Value(keys.RESTORE_REQ_CONTEXT_KEY).(*daemon.RestoreReq)
		if !ok {
			return fmt.Errorf("invalid restore request in context")
		}

		id, _ := cmd.Flags().GetString(runc_flags.IdFlag.Full)
		root, _ := cmd.Flags().GetString(runc_flags.RootFlag.Full)
		bundle, _ := cmd.Flags().GetString(runc_flags.BundleFlag.Full)
		wd, err := os.Getwd()
		if err != nil {
			return fmt.Errorf("Error getting working directory: %v", err)
		}

		req.Type = "runc"
		req.Details = &daemon.Details{Runc: &runc.Runc{
			ID:         id,
			Root:       root,
			Bundle:     bundle,
			WorkingDir: wd,
		}}

		ctx := context.WithValue(cmd.Context(), keys.RESTORE_REQ_CONTEXT_KEY, req)
		cmd.SetContext(ctx)

		return nil
	},
}

var RunCmd = &cobra.Command{
	Use:   "runc [optional-id]",
	Short: "run a runc container",
	Args:  cobra.ArbitraryArgs,
	RunE: func(cmd *cobra.Command, args []string) error {
		req, ok := cmd.Context().Value(keys.RUN_REQ_CONTEXT_KEY).(*daemon.RunReq)
		if !ok {
			return fmt.Errorf("invalid run request in context")
		}

		var id string
		if len(args) >= 1 {
			id = args[0]
		}

		root, _ := cmd.Flags().GetString(runc_flags.RootFlag.Full)
		bundle, _ := cmd.Flags().GetString(runc_flags.BundleFlag.Full)
		noPivot, _ := cmd.Flags().GetBool(runc_flags.NoPivotFlag.Full)
		noNewKeyring, _ := cmd.Flags().GetBool(runc_flags.NoNewKeyringFlag.Full)
		wd, err := os.Getwd()
		if err != nil {
			return fmt.Errorf("Error getting working directory: %v", err)
		}

		req.Type = "runc"
		req.Details = &daemon.Details{Runc: &runc.Runc{
			Root:         root,
			Bundle:       bundle,
			ID:           id,
			NoPivot:      noPivot,
			NoNewKeyring: noNewKeyring,
			WorkingDir:   wd,
		}}

		ctx := context.WithValue(cmd.Context(), keys.DUMP_REQ_CONTEXT_KEY, req)
		cmd.SetContext(ctx)

		return nil
	},
}