placementgroup

var CreateCmd = base.CreateCmd[*hcloud.PlacementGroup]{
	BaseCobraCommand: func(hcapi2.Client) *cobra.Command {
		cmd := &cobra.Command{
			Use:   "create [options] --name <name> --type <type>",
			Short: "Create a Placement Group",
		}
		cmd.Flags().String("name", "", "Name")
		_ = cmd.MarkFlagRequired("name")

		cmd.Flags().StringToString("label", nil, "User-defined labels ('key=value') (can be specified multiple times)")

		cmd.Flags().String("type", "", "Type of the Placement Group")
		_ = cmd.MarkFlagRequired("type")
		return cmd
	},
	Run: func(s state.State, cmd *cobra.Command, _ []string) (*hcloud.PlacementGroup, any, error) {
		name, _ := cmd.Flags().GetString("name")
		labels, _ := cmd.Flags().GetStringToString("label")
		placementGroupType, _ := cmd.Flags().GetString("type")

		opts := hcloud.PlacementGroupCreateOpts{
			Name:   name,
			Labels: labels,
			Type:   hcloud.PlacementGroupType(placementGroupType),
		}

		result, _, err := s.Client().PlacementGroup().Create(s, opts)
		if err != nil {
			return nil, nil, err
		}

		if result.Action != nil {
			if err := s.WaitForActions(s, cmd, result.Action); err != nil {
				return nil, nil, err
			}
		}

		cmd.Printf("Placement Group %d created\n", result.PlacementGroup.ID)

		return result.PlacementGroup, util.Wrap("placement_group", hcloud.SchemaFromPlacementGroup(result.PlacementGroup)), nil
	},
}

var DeleteCmd = base.DeleteCmd{
	ResourceNameSingular: "Placement Group",
	ResourceNamePlural:   "Placement Groups",
	ShortDescription:     "Delete a Placement Group",
	NameSuggestions:      func(c hcapi2.Client) func() []string { return c.PlacementGroup().Names },
	Fetch: func(s state.State, _ *cobra.Command, idOrName string) (interface{}, *hcloud.Response, error) {
		return s.Client().PlacementGroup().Get(s, idOrName)
	},
	Delete: func(s state.State, _ *cobra.Command, resource interface{}) (*hcloud.Action, error) {
		placementGroup := resource.(*hcloud.PlacementGroup)
		_, err := s.Client().PlacementGroup().Delete(s, placementGroup)
		return nil, err
	},
}

var DescribeCmd = base.DescribeCmd[*hcloud.PlacementGroup]{
	ResourceNameSingular: "Placement Group",
	ShortDescription:     "Describe a Placement Group",
	NameSuggestions:      func(c hcapi2.Client) func() []string { return c.PlacementGroup().Names },
	Fetch: func(s state.State, _ *cobra.Command, idOrName string) (*hcloud.PlacementGroup, any, error) {
		pg, _, err := s.Client().PlacementGroup().Get(s, idOrName)
		if err != nil {
			return nil, nil, err
		}
		return pg, hcloud.SchemaFromPlacementGroup(pg), nil
	},
	PrintText: func(s state.State, _ *cobra.Command, out io.Writer, placementGroup *hcloud.PlacementGroup) error {
		fmt.Fprintf(out, "%s", DescribePlacementGroup(s.Client(), placementGroup))
		return nil
	},
}

var LabelCmds = base.LabelCmds[*hcloud.PlacementGroup]{
	ResourceNameSingular:   "Placement Group",
	ShortDescriptionAdd:    "Add a label to a Placement Group",
	ShortDescriptionRemove: "Remove a label from a Placement Group",
	NameSuggestions:        func(c hcapi2.Client) func() []string { return c.PlacementGroup().Names },
	LabelKeySuggestions:    func(c hcapi2.Client) func(idOrName string) []string { return c.PlacementGroup().LabelKeys },
	Fetch: func(s state.State, idOrName string) (*hcloud.PlacementGroup, error) {
		placementGroup, _, err := s.Client().PlacementGroup().Get(s, idOrName)
		if err != nil {
			return nil, err
		}
		if placementGroup == nil {
			return nil, fmt.Errorf("Placement Group not found: %s", idOrName)
		}
		return placementGroup, nil
	},
	SetLabels: func(s state.State, placementGroup *hcloud.PlacementGroup, labels map[string]string) error {
		opts := hcloud.PlacementGroupUpdateOpts{
			Labels: labels,
		}
		_, _, err := s.Client().PlacementGroup().Update(s, placementGroup, opts)
		return err
	},
	GetLabels: func(placementGroup *hcloud.PlacementGroup) map[string]string {
		return placementGroup.Labels
	},
	GetIDOrName: func(placementGroup *hcloud.PlacementGroup) string {
		return strconv.FormatInt(placementGroup.ID, 10)
	},
}

var ListCmd = &base.ListCmd[*hcloud.PlacementGroup, schema.PlacementGroup]{
	ResourceNamePlural: "Placement Groups",
	JSONKeyGetByName:   "placement_groups",
	DefaultColumns:     []string{"id", "name", "servers", "type", "age"},
	SortOption:         config.OptionSortPlacementGroup,

	Fetch: func(s state.State, _ *pflag.FlagSet, listOpts hcloud.ListOpts, sorts []string) ([]*hcloud.PlacementGroup, error) {
		opts := hcloud.PlacementGroupListOpts{ListOpts: listOpts}
		if len(sorts) > 0 {
			opts.Sort = sorts
		}
		return s.Client().PlacementGroup().AllWithOpts(s, opts)
	},

	OutputTable: func(t *output.Table[*hcloud.PlacementGroup], _ hcapi2.Client) {
		t.
			AddAllowedFields(&hcloud.PlacementGroup{}).
			AddFieldFn("servers", func(placementGroup *hcloud.PlacementGroup) string {
				count := len(placementGroup.Servers)
				if count == 1 {
					return fmt.Sprintf("%d server", count)
				}
				return fmt.Sprintf("%d servers", count)
			}).
			AddFieldFn("created", func(placementGroup *hcloud.PlacementGroup) string {
				return util.Datetime(placementGroup.Created)
			}).
			AddFieldFn("age", func(placementGroup *hcloud.PlacementGroup) string {
				return util.Age(placementGroup.Created, time.Now())
			})
	},

	Schema: hcloud.SchemaFromPlacementGroup,
}

var UpdateCmd = base.UpdateCmd{
	ResourceNameSingular: "Placement Group",
	ShortDescription:     "Update a Placement Group",
	NameSuggestions:      func(c hcapi2.Client) func() []string { return c.PlacementGroup().Names },
	Fetch: func(s state.State, _ *cobra.Command, idOrName string) (interface{}, *hcloud.Response, error) {
		return s.Client().PlacementGroup().Get(s, idOrName)
	},
	DefineFlags: func(cmd *cobra.Command) {
		cmd.Flags().String("name", "", "Placement Group name")
	},
	Update: func(s state.State, _ *cobra.Command, resource interface{}, flags map[string]pflag.Value) error {
		placementGroup := resource.(*hcloud.PlacementGroup)
		updOpts := hcloud.PlacementGroupUpdateOpts{
			Name: flags["name"].String(),
		}
		_, _, err := s.Client().PlacementGroup().Update(s, placementGroup, updOpts)
		if err != nil {
			return err
		}
		return nil
	},
}