system_setup_tool/cmd/package_commands.go

package cmd

import (
	"fmt"
	"os"
	"sort"
	"system_setup_tool/utils"

	"github.com/spf13/cobra"
	"github.com/spf13/viper"
)

var packageCmd = &cobra.Command{
	Use:   "package",
	Short: "Manage packages in the configuration",
}

var addCmd = &cobra.Command{
	Use:   "add",
	Short: "Adds a package to the config.toml",
	Run: func(cmd *cobra.Command, args []string) {
		name, _ := cmd.Flags().GetString("name")
		manager, _ := cmd.Flags().GetString("manager")
		isSystem, _ := cmd.Flags().GetBool("system")
		isHeadless, _ := cmd.Flags().GetBool("headless")

		if isSystem {
			var packages []string
			if isHeadless {
				packages = viper.GetStringSlice("packages.headless")
			} else {
				packages = viper.GetStringSlice("packages.non_headless")
			}

			packages = append(packages, name)

			if isHeadless {
				viper.Set("packages.headless", packages)
			} else {
				viper.Set("packages.non_headless", packages)
			}
		} else {
			packages := viper.GetStringSlice(fmt.Sprintf("package_managers.%s.packages", manager))

			for _, pkg := range packages {
				if pkg == name {
					fmt.Printf("Package %s is already present in the configuration for %s\n", name, manager)
					return
				}
			}

			packages = append(packages, name)
			viper.Set(fmt.Sprintf("package_managers.%s.packages", manager), packages)

		}
		if err := viper.WriteConfig(); err != nil {
			fmt.Printf("Error writing configuration: %v\n", err)
			os.Exit(1)
		}

		fmt.Printf("Package %s has been added to the configuration for %s\n", name, manager)
		if err := utils.LogToHistory("added", name, manager); err != nil {
			fmt.Println("error logging action:", err)
		}
	},
}

var deleteCmd = &cobra.Command{
	Use:   "delete",
	Short: "Deletes a package from the config.toml",
	Run: func(cmd *cobra.Command, args []string) {
		name, _ := cmd.Flags().GetString("name")
		manager, _ := cmd.Flags().GetString("manager")
		isSystem, _ := cmd.Flags().GetBool("system")
		isHeadless, _ := cmd.Flags().GetBool("headless")

		if isSystem {
			var packages []string
			var packageType string
			if isHeadless {
				packages = viper.GetStringSlice("packages.headless")
				packageType = "headless"
			} else {
				packages = viper.GetStringSlice("packages.non_headless")
				packageType = "non-headless"
			}

			for i, pkg := range packages {
				if pkg == name {
					packages = append(packages[:i], packages[i+1:]...)
					if isHeadless {
						viper.Set("packages.headless", packages)
					} else {
						viper.Set("packages.non_headless", packages)
					}

					if err := viper.WriteConfig(); err != nil {
						fmt.Printf("Error writing configuration: %v\n", err)
						os.Exit(1)
					}

					fmt.Printf("Package %s has been deleted from the %s system packages\n", name, packageType)
					return
				}
			}

			fmt.Printf("Package %s was not found in the %s system packages\n", name, packageType)
		} else {
			packages := viper.GetStringSlice(fmt.Sprintf("package_managers.%s.packages", manager))

			for i, pkg := range packages {
				if pkg == name {
					packages = append(packages[:i], packages[i+1:]...)
					viper.Set(fmt.Sprintf("package_managers.%s.packages", manager), packages)

					if err := viper.WriteConfig(); err != nil {
						fmt.Printf("Error writing configuration: %v\n", err)
						os.Exit(1)
					}

					fmt.Printf("Package %s has been deleted from the configuration for %s\n", name, manager)
					return
				}
			}

			fmt.Printf("Package %s was not found in the configuration for %s\n", name, manager)
			if err := utils.LogToHistory("removed", name, manager); err != nil {
				fmt.Println("error logging action:", err)
			}
		}
	},
}

var showCmd = &cobra.Command{
	Use:   "show",
	Short: "Shows the current package configuration",
	Run: func(cmd *cobra.Command, args []string) {
		packageManagers := viper.GetStringMap("package_managers")

		if len(packageManagers) == 0 {
			fmt.Println("No package managers configured.")
			return
		}

		var managers []string
		for manager := range packageManagers {
			managers = append(managers, manager)
		}
		sort.Strings(managers)

		for _, manager := range managers {
			fmt.Printf("Package Manager: %s\n", manager)
			packages := viper.GetStringSlice(fmt.Sprintf("package_managers.%s.packages", manager))
			sort.Strings(packages)
			for _, pkg := range packages {
				fmt.Printf("  - %s\n", pkg)
			}
			fmt.Println()
		}
		fmt.Println("System Packages:")
		headless := viper.GetStringSlice("packages.headless")
		nonHeadless := viper.GetStringSlice("packages.non_headless")

		fmt.Println("  Headless:")
		for _, pkg := range headless {
			fmt.Printf("    - %s\n", pkg)
		}

		fmt.Println("  Non-Headless:")
		for _, pkg := range nonHeadless {
			fmt.Printf("    - %s\n", pkg)
		}
	},
}

var enableCmd = &cobra.Command{
	Use:   "enable [package_manager]",
	Short: "Enable or disable a package manager (Options: homebrew|go|cargo|pipx|flatpak)",
	Args:  cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		manager := args[0]
		enable, _ := cmd.Flags().GetBool("value")

		if !viper.IsSet(fmt.Sprintf("package_managers.%s", manager)) {
			fmt.Printf("Package manager %s not found in configuration\n", manager)
			return
		}

		viper.Set(fmt.Sprintf("package_managers.%s.enable", manager), enable)

		if err := viper.WriteConfig(); err != nil {
			fmt.Printf("Error writing configuration: %v\n", err)
			os.Exit(1)
		}

		fmt.Printf("Package manager %s has been %s\n", manager, map[bool]string{true: "enabled", false: "disabled"}[enable])
		if err := utils.LogToHistory("enabled", "", manager); err != nil {
			fmt.Println("error logging action:", err)
		}
	},
}