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)
		detach, _ := cmd.Flags().GetBool(runc_flags.DetachFlag.Full)
		noPivot, _ := cmd.Flags().GetBool(runc_flags.NoPivotFlag.Full)
		noNewKeyring, _ := cmd.Flags().GetBool(runc_flags.NoNewKeyringFlag.Full)
		consoleSocket, _ := cmd.Flags().GetString(runc_flags.ConsoleSocketFlag.Full)
		logFile, _ := cmd.Flags().GetString(runc_flags.LogFlag.Full)
		logFormat, _ := cmd.Flags().GetString(runc_flags.LogFormatFlag.Full)
		rootless, _ := cmd.Flags().GetString(runc_flags.RootlessFlag.Full)
		systemdCgroup, _ := cmd.Flags().GetBool(runc_flags.SystemdCgroupFlag.Full)
		noSubreaper, _ := cmd.Flags().GetBool(runc_flags.NoSubreaperFlag.Full)
		wd, err := os.Getwd()
		if err != nil {
			return fmt.Errorf("Error getting working directory: %v", err)
		}

		daemonless, _ := cmd.Context().Value(keys.DAEMONLESS_CONTEXT_KEY).(bool)
		if daemonless && logFile != "" {
			file, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
			if err != nil {
				return fmt.Errorf("failed to open log file %s: %v", logFile, err)
			}
			logging.SetLogger(zerolog.New(runc_logging.Writer(file, logFormat)).Level(logging.Level))
		} else if !daemonless {
			if detach {
				fmt.Println(
					style.WarningColors.Sprintf(
						"Flag `%s` is ignored when restoring with daemon, as it always detaches.",
						runc_flags.DetachFlag.Full,
					))
			}
			if noSubreaper {
				fmt.Println(
					style.WarningColors.Sprintf(
						"Flag `%s` is ignored when restoring with daemon, as it always detaches and reaps.",
						runc_flags.NoSubreaperFlag.Full,
					))
			}
		}

		req.Type = "runc"
		req.Details = &daemon.Details{
			Runc: &runc.Runc{
				ID:            id,
				Root:          root,
				Bundle:        bundle,
				WorkingDir:    wd,
				Detach:        detach,
				NoPivot:       noPivot,
				NoNewKeyring:  noNewKeyring,
				ConsoleSocket: consoleSocket,
				Rootless:      rootless,
				SystemdCgroup: systemdCgroup,
				NoSubreaper:   noSubreaper,
			},
		}

		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)
		detach, _ := cmd.Flags().GetBool(runc_flags.DetachFlag.Full)
		noPivot, _ := cmd.Flags().GetBool(runc_flags.NoPivotFlag.Full)
		noNewKeyring, _ := cmd.Flags().GetBool(runc_flags.NoNewKeyringFlag.Full)
		consoleSocket, _ := cmd.Flags().GetString(runc_flags.ConsoleSocketFlag.Full)
		logFile, _ := cmd.Flags().GetString(runc_flags.LogFlag.Full)
		logFormat, _ := cmd.Flags().GetString(runc_flags.LogFormatFlag.Full)
		rootless, _ := cmd.Flags().GetString(runc_flags.RootlessFlag.Full)
		systemdCgroup, _ := cmd.Flags().GetBool(runc_flags.SystemdCgroupFlag.Full)
		noSubreaper, _ := cmd.Flags().GetBool(runc_flags.NoSubreaperFlag.Full)
		preserveFds, _ := cmd.Flags().GetInt32(runc_flags.PreserveFdsFlag.Full)
		wd, err := os.Getwd()
		if err != nil {
			return fmt.Errorf("Error getting working directory: %v", err)
		}

		daemonless, _ := cmd.Context().Value(keys.DAEMONLESS_CONTEXT_KEY).(bool)
		if daemonless && logFile != "" {
			file, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
			if err != nil {
				return fmt.Errorf("failed to open log file %s: %v", logFile, err)
			}
			logging.SetLogger(zerolog.New(runc_logging.Writer(file, logFormat)).Level(logging.Level))
		} else if !daemonless {
			if detach {
				fmt.Println(
					style.WarningColors.Sprintf(
						"Flag `%s` is ignored when running with daemon, as it always detaches.",
						runc_flags.DetachFlag.Full,
					))
			}
			if noSubreaper {
				fmt.Println(
					style.WarningColors.Sprintf(
						"Flag `%s` is ignored when running with daemon, as it always detaches and reaps.",
						runc_flags.NoSubreaperFlag.Full,
					))
			}
		}

		req.Type = "runc"
		req.Details = &daemon.Details{Runc: &runc.Runc{
			Root:          root,
			Bundle:        bundle,
			Detach:        detach,
			ID:            id,
			NoPivot:       noPivot,
			NoNewKeyring:  noNewKeyring,
			WorkingDir:    wd,
			ConsoleSocket: consoleSocket,
			Rootless:      rootless,
			SystemdCgroup: systemdCgroup,
			PreserveFDs:   preserveFds,
		}}

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

		return nil
	},
}