cmd

var DownloadCmd = &cobra.Command{
	Use: "download package",
	Run: func(c *cobra.Command, args []string) {
		log.Infof("OS family: %s\n", target.Distro.Family)
		log.Infof("Distribution: %s\n", target.Distro.Display)
		log.Infof("Release: %s\n", target.Distro.Release)
		log.Infof("Kernel: %s\n", target.Uname.Kernel)
		log.Infof("Machine: %s\n", target.Uname.Machine)
		log.Debugf("OSRelease: %s\n", target.OSRelease)

		var (
			backend types.Backend
			err     error
		)

		logger := log.New()
		if verbose {
			logger.SetLevel(log.DebugLevel)
		}
		switch target.Distro.Family {
		case "fedora", "rhel":
			switch target.Distro.Display {
			case "fedora":
				backend, err = rpm.NewFedoraBackend(&target, rpmReposDir, logger)
			case "rhel", "redhat":
				backend, err = rpm.NewRedHatBackend(&target, rpmReposDir, logger)
			case "centos":
				backend, err = rpm.NewCentOSBackend(&target, rpmReposDir, logger)
			case "oracle", "ol":
				backend, err = rpm.NewOracleBackend(&target, rpmReposDir, logger)
			case "amazon":
				if target.Distro.Release == "2022" {
					backend, err = rpm.NewAmazonLinux2022Backend(&target, rpmReposDir, logger)
				} else {
					backend, err = rpm.NewRedHatBackend(&target, rpmReposDir, logger)
				}
			default:
				err = fmt.Errorf("unsupported RedHat based distribution '%s'", target.Distro.Display)
			}
		case "suse":
			switch target.Distro.Display {
			case "suse", "sles", "sled", "caasp":
				backend, err = rpm.NewSLESBackend(&target, zypperReposDir, logger)
			case "opensuse", "opensuse-leap", "opensuse-tumbleweed", "opensuse-tumbleweed-kubic":
				backend, err = rpm.NewOpenSUSEBackend(&target, zypperReposDir, logger)
			default:
				err = fmt.Errorf("unsupported Debian based distribution '%s'", target.Distro.Display)
			}
		case "debian":
			backend, err = apt.NewBackend(&target, aptConfigDir, logger)
		case "cos":
			backend, err = cos.NewBackend(&target, logger)
		case "wsl":
			backend, err = wsl.NewBackend(&target, logger)
		default:
			err = fmt.Errorf("unsupported distribution '%s'", target.Distro.Display)
		}
		if err != nil {
			log.Fatal(err)
		}

		if err = os.MkdirAll(outputDir, 0755); err != nil {
			log.Fatal(err)
		}

		if err = backend.GetKernelHeaders(outputDir); err != nil {
			log.Fatalf("failed to download kernel headers: %s", err)
		}
	},
}

var RootCmd = &cobra.Command{
	Use:          "nikos [sub]",
	SilenceUsage: true,
	PersistentPreRun: func(c *cobra.Command, args []string) {
		if osReleaseFile != "" {
			var err error
			if target.OSRelease, err = osrelease.ReadFile(osReleaseFile); err != nil {
				log.Fatalf("failed to read %s", osReleaseFile)
			}
		}

		if verbose {
			log.SetLevel(log.DebugLevel)
			log.Debugf("Set log level to debug")
		}
	},
}