appstore

var ASBundleCapabilityAddCmd = &cobra.Command{
	Use:           "add",
	Short:         "🚧 Enable a capability for a bundle ID",
	Args:          cobra.NoArgs,
	SilenceUsage:  true,
	SilenceErrors: true,
	Hidden:        true,
	RunE: func(cmd *cobra.Command, args []string) error {

		if viper.GetBool("verbose") {
			log.SetLevel(log.DebugLevel)
		}

		viper.BindPFlag("appstore.p8", cmd.Flags().Lookup("p8"))
		viper.BindPFlag("appstore.iss", cmd.Flags().Lookup("iss"))
		viper.BindPFlag("appstore.kid", cmd.Flags().Lookup("kid"))
		viper.BindPFlag("appstore.jwt", cmd.Flags().Lookup("jwt"))

		bid := viper.GetString("appstore.bundle.cap.add.id")
		ctype := viper.GetString("appstore.bundle.cap.add.type")

		if (viper.GetString("appstore.p8") == "" || viper.GetString("appstore.iss") == "" || viper.GetString("appstore.kid") == "") && viper.GetString("appstore.jwt") == "" {
			return fmt.Errorf("you must provide (--p8, --iss and --kid) OR --jwt")
		}

		as := appstore.NewAppStore(
			viper.GetString("appstore.p8"),
			viper.GetString("appstore.iss"),
			viper.GetString("appstore.kid"),
			viper.GetString("appstore.jwt"),
		)

		if len(bid) == 0 {
			bids, err := as.GetBundleIDs()
			if err != nil {
				return err
			}

			var choices []string
			for _, b := range bids {
				choices = append(choices, fmt.Sprintf("%s (%s)", b.Attributes.ID, b.Attributes.Name))
			}

			var choice string
			prompt := &survey.Select{
				Message:  "Select buildID to use:",
				Options:  choices,
				PageSize: 10,
			}
			if err := survey.AskOne(prompt, &choice); err == terminal.InterruptErr {
				log.Warn("Exiting...")
				return nil
			}

			for _, b := range bids {
				if strings.HasPrefix(choice, b.Attributes.ID+" (") {
					bid = b.ID
					break
				}
			}
		}

		caps, err := as.EnableCapability(bid, ctype)
		if err != nil {
			return err
		}

		log.Info("Added Capability:")
		log.Infof("%s: %s", caps.ID, caps.Attributes.CapabilityType)

		return nil
	},
}

var ASBundleCapabilityCmd = &cobra.Command{
	Use:     "cap",
	Aliases: []string{"c"},
	Short:   "Manage the app capabilities for a bundle ID",
	Args:    cobra.NoArgs,
	Run: func(cmd *cobra.Command, args []string) {
		cmd.Help()
	},
}

var ASBundleCmd = &cobra.Command{
	Use:     "bundle",
	Aliases: []string{"b"},
	Short:   "Manage the bundle IDs that uniquely identify your apps",
	Args:    cobra.NoArgs,
	Run: func(cmd *cobra.Command, args []string) {
		cmd.Help()
	},
}

var ASBundleListCmd = &cobra.Command{
	Use:           "ls",
	Short:         "List bundle IDs that are registered to your team",
	Args:          cobra.NoArgs,
	SilenceUsage:  true,
	SilenceErrors: true,
	RunE: func(cmd *cobra.Command, args []string) error {

		if viper.GetBool("verbose") {
			log.SetLevel(log.DebugLevel)
		}

		viper.BindPFlag("appstore.p8", cmd.Flags().Lookup("p8"))
		viper.BindPFlag("appstore.iss", cmd.Flags().Lookup("iss"))
		viper.BindPFlag("appstore.kid", cmd.Flags().Lookup("kid"))
		viper.BindPFlag("appstore.jwt", cmd.Flags().Lookup("jwt"))

		if (viper.GetString("appstore.p8") == "" || viper.GetString("appstore.iss") == "" || viper.GetString("appstore.kid") == "") && viper.GetString("appstore.jwt") == "" {
			return fmt.Errorf("you must provide (--p8, --iss and --kid) OR --jwt")
		}

		as := appstore.NewAppStore(
			viper.GetString("appstore.p8"),
			viper.GetString("appstore.iss"),
			viper.GetString("appstore.kid"),
			viper.GetString("appstore.jwt"),
		)

		bIDs, err := as.GetBundleIDs()
		if err != nil {
			return err
		}

		log.Info("Bundle IDs:")
		for _, bID := range bIDs {
			utils.Indent(log.Info, 2)(fmt.Sprintf("%s: [%s]\t%s\t(%s)", bID.ID, bID.Attributes.Platform, bID.Attributes.ID, bID.Attributes.Name))
		}

		return nil
	},
}

var ASCertAddCmd = &cobra.Command{
	Use:           "add",
	Short:         "Create a new certificate using a certificate signing request",
	Args:          cobra.NoArgs,
	SilenceUsage:  true,
	SilenceErrors: true,
	RunE: func(cmd *cobra.Command, args []string) error {

		if viper.GetBool("verbose") {
			log.SetLevel(log.DebugLevel)
		}

		viper.BindPFlag("appstore.p8", cmd.Flags().Lookup("p8"))
		viper.BindPFlag("appstore.iss", cmd.Flags().Lookup("iss"))
		viper.BindPFlag("appstore.kid", cmd.Flags().Lookup("kid"))
		viper.BindPFlag("appstore.jwt", cmd.Flags().Lookup("jwt"))

		ctype := viper.GetString("appstore.cert.add.type")
		csr := viper.GetString("appstore.cert.add.csr")
		output := viper.GetString("appstore.cert.add.output")

		if (viper.GetString("appstore.p8") == "" || viper.GetString("appstore.iss") == "" || viper.GetString("appstore.kid") == "") && viper.GetString("appstore.jwt") == "" {
			return fmt.Errorf("you must provide (--p8, --iss and --kid) OR --jwt")
		}
		if ctype == "" || csr == "" {
			return fmt.Errorf("you must provide --type and --csr")
		}

		as := appstore.NewAppStore(
			viper.GetString("appstore.p8"),
			viper.GetString("appstore.iss"),
			viper.GetString("appstore.kid"),
			viper.GetString("appstore.jwt"),
		)

		cert, err := as.CreateCertificate(ctype, csr)
		if err != nil {
			return err
		}

		log.Info("Certificate:")
		log.Infof("%s: %s (%s), Expires: %s", cert.ID, cert.Attributes.Name, cert.Attributes.CertificateType, cert.Attributes.ExpirationDate.Format("02Jan2006 15:04:05"))
		fname := fmt.Sprintf("%s_%s.cer", cert.Attributes.Name, cert.Attributes.ExpirationDate.Format("2006-01-02"))
		if output != "" {
			if err := os.MkdirAll(output, os.ModePerm); err != nil {
				return fmt.Errorf("failed to create output directory: %v", err)
			}
			fname = filepath.Join(output, fname)
		}
		log.Infof("Downloading certificate to: %s", fname)
		return os.WriteFile(fname, cert.Attributes.CertificateContent, 0644)
	},
}

var ASCertCmd = &cobra.Command{
	Use:     "cert",
	Aliases: []string{"c"},
	Short:   "Create, download, and revoke signing certificates for app development and distribution",
	Args:    cobra.NoArgs,
	Run: func(cmd *cobra.Command, args []string) {
		cmd.Help()
	},
}

var ASCertListCmd = &cobra.Command{
	Use:           "ls",
	Short:         "List certificates",
	Args:          cobra.NoArgs,
	SilenceUsage:  true,
	SilenceErrors: true,
	RunE: func(cmd *cobra.Command, args []string) error {

		if viper.GetBool("verbose") {
			log.SetLevel(log.DebugLevel)
		}

		viper.BindPFlag("appstore.p8", cmd.Flags().Lookup("p8"))
		viper.BindPFlag("appstore.iss", cmd.Flags().Lookup("iss"))
		viper.BindPFlag("appstore.kid", cmd.Flags().Lookup("kid"))
		viper.BindPFlag("appstore.jwt", cmd.Flags().Lookup("jwt"))

		if (viper.GetString("appstore.p8") == "" || viper.GetString("appstore.iss") == "" || viper.GetString("appstore.kid") == "") && viper.GetString("appstore.jwt") == "" {
			return fmt.Errorf("you must provide (--p8, --iss and --kid) OR --jwt")
		}

		as := appstore.NewAppStore(
			viper.GetString("appstore.p8"),
			viper.GetString("appstore.iss"),
			viper.GetString("appstore.kid"),
			viper.GetString("appstore.jwt"),
		)

		certs, err := as.GetCertificates()
		if err != nil {
			return err
		}

		log.Info("Certificates:")
		for _, cert := range certs {
			utils.Indent(log.Info, 2)(fmt.Sprintf("%s: %s (%s), Expires: %s", cert.ID, cert.Attributes.Name, cert.Attributes.CertificateType, cert.Attributes.ExpirationDate.Format("02Jan2006 15:04:05")))
		}

		return nil
	},
}

var ASCertRevokeCmd = &cobra.Command{
	Use:           "rm",
	Short:         "Revoke a lost, stolen, compromised, or expiring signing certificate",
	Args:          cobra.NoArgs,
	SilenceUsage:  true,
	SilenceErrors: true,
	RunE: func(cmd *cobra.Command, args []string) error {

		if viper.GetBool("verbose") {
			log.SetLevel(log.DebugLevel)
		}

		viper.BindPFlag("appstore.p8", cmd.Flags().Lookup("p8"))
		viper.BindPFlag("appstore.iss", cmd.Flags().Lookup("iss"))
		viper.BindPFlag("appstore.kid", cmd.Flags().Lookup("kid"))
		viper.BindPFlag("appstore.jwt", cmd.Flags().Lookup("jwt"))

		id := viper.GetString("appstore.cert.rm.id")

		if (viper.GetString("appstore.p8") == "" || viper.GetString("appstore.iss") == "" || viper.GetString("appstore.kid") == "") && viper.GetString("appstore.jwt") == "" {
			return fmt.Errorf("you must provide (--p8, --iss and --kid) OR --jwt")
		}

		as := appstore.NewAppStore(
			viper.GetString("appstore.p8"),
			viper.GetString("appstore.iss"),
			viper.GetString("appstore.kid"),
			viper.GetString("appstore.jwt"),
		)

		if id == "" {
			cs, err := as.GetCertificates()
			if err != nil {
				return err
			}

			var choices []string
			for _, c := range cs {
				choices = append(choices, fmt.Sprintf("%s: %s", c.ID, c.Attributes.Name))
			}

			var choice string
			prompt := &survey.Select{
				Message:  "Select cert to revoke:",
				Options:  choices,
				PageSize: 10,
			}
			if err := survey.AskOne(prompt, &choice); err == terminal.InterruptErr {
				log.Warn("Exiting...")
				return nil
			}

			for _, c := range cs {
				if strings.HasPrefix(choice, c.ID+": ") {
					id = c.ID
					break
				}
			}
		}

		log.Info("Revoking certificate...")
		return as.RevokeCertificate(id)
	},
}

var ASDeviceCmd = &cobra.Command{
	Use:     "device",
	Aliases: []string{"d"},
	Short:   "Register devices for development and testing",
	Args:    cobra.NoArgs,
	Run: func(cmd *cobra.Command, args []string) {
		cmd.Help()
	},
}

var ASDeviceListCmd = &cobra.Command{
	Use:           "ls",
	Short:         "List devices registered to your team",
	Args:          cobra.NoArgs,
	SilenceUsage:  true,
	SilenceErrors: true,
	RunE: func(cmd *cobra.Command, args []string) error {

		if viper.GetBool("verbose") {
			log.SetLevel(log.DebugLevel)
		}

		viper.BindPFlag("appstore.p8", cmd.Flags().Lookup("p8"))
		viper.BindPFlag("appstore.iss", cmd.Flags().Lookup("iss"))
		viper.BindPFlag("appstore.kid", cmd.Flags().Lookup("kid"))
		viper.BindPFlag("appstore.jwt", cmd.Flags().Lookup("jwt"))

		if (viper.GetString("appstore.p8") == "" || viper.GetString("appstore.iss") == "" || viper.GetString("appstore.kid") == "") && viper.GetString("appstore.jwt") == "" {
			return fmt.Errorf("you must provide (--p8, --iss and --kid) OR --jwt")
		}

		as := appstore.NewAppStore(
			viper.GetString("appstore.p8"),
			viper.GetString("appstore.iss"),
			viper.GetString("appstore.kid"),
			viper.GetString("appstore.jwt"),
		)

		devs, err := as.GetDevices()
		if err != nil {
			return err
		}

		log.Info("Devices:")
		for _, dev := range devs {
			model := dev.Attributes.DeviceClass
			if dev.Attributes.Model != "" {
				model = dev.Attributes.Model
			}
			utils.Indent(log.Info, 2)(fmt.Sprintf("%s: [%s] Added: %s - %s (%s)", dev.ID, dev.Attributes.Status, dev.Attributes.AddedDate.Format("02Jan2006 15:04:05"), dev.Attributes.Name, model))
		}

		return nil
	},
}

var ASDeviceModifyCmd = &cobra.Command{
	Use:           "mod",
	Aliases:       []string{"m"},
	Short:         "Register a new device for app development",
	Args:          cobra.NoArgs,
	SilenceUsage:  true,
	SilenceErrors: true,
	RunE: func(cmd *cobra.Command, args []string) error {

		if viper.GetBool("verbose") {
			log.SetLevel(log.DebugLevel)
		}

		viper.BindPFlag("appstore.p8", cmd.Flags().Lookup("p8"))
		viper.BindPFlag("appstore.iss", cmd.Flags().Lookup("iss"))
		viper.BindPFlag("appstore.kid", cmd.Flags().Lookup("kid"))
		viper.BindPFlag("appstore.jwt", cmd.Flags().Lookup("jwt"))

		id := viper.GetString("appstore.device.mod.id")
		name := viper.GetString("appstore.device.mod.name")
		status := viper.GetString("appstore.device.mod.status")

		if (viper.GetString("appstore.p8") == "" || viper.GetString("appstore.iss") == "" || viper.GetString("appstore.kid") == "") && viper.GetString("appstore.jwt") == "" {
			return fmt.Errorf("you must provide (--p8, --iss and --kid) OR --jwt")
		}
		if name == "" || status == "" {
			return fmt.Errorf("you must provide --name AND --status")
		}

		as := appstore.NewAppStore(
			viper.GetString("appstore.p8"),
			viper.GetString("appstore.iss"),
			viper.GetString("appstore.kid"),
			viper.GetString("appstore.jwt"),
		)

		if id == "" {
			devs, err := as.GetDevices()
			if err != nil {
				return err
			}

			var choices []string
			for _, d := range devs {
				choices = append(choices, fmt.Sprintf("%s: %s", d.ID, d.Attributes.Name))
			}

			var choice string
			prompt := &survey.Select{
				Message:  "Select device to modify:",
				Options:  choices,
				PageSize: 10,
			}
			if err := survey.AskOne(prompt, &choice); err == terminal.InterruptErr {
				log.Warn("Exiting...")
				return nil
			}

			for _, d := range devs {
				if strings.HasPrefix(choice, d.ID+": ") {
					id = d.ID
					break
				}
			}
		}

		dev, err := as.ModifyDevice(id, name, status)
		if err != nil {
			return err
		}

		log.Info("Modified device:")
		model := dev.Attributes.DeviceClass
		if dev.Attributes.Model != "" {
			model = dev.Attributes.Model
		}
		utils.Indent(log.Info, 2)(fmt.Sprintf("%s: [%s] Added: %s - %s (%s)", dev.ID, dev.Attributes.Status, dev.Attributes.AddedDate.Format("02Jan2006 15:04:05"), dev.Attributes.Name, model))

		return nil
	},
}

var ASDeviceRegisterCmd = &cobra.Command{
	Use:           "reg",
	Aliases:       []string{"r"},
	Short:         "Register a new device for app development",
	Args:          cobra.NoArgs,
	SilenceUsage:  true,
	SilenceErrors: true,
	RunE: func(cmd *cobra.Command, args []string) error {

		if viper.GetBool("verbose") {
			log.SetLevel(log.DebugLevel)
		}

		viper.BindPFlag("appstore.p8", cmd.Flags().Lookup("p8"))
		viper.BindPFlag("appstore.iss", cmd.Flags().Lookup("iss"))
		viper.BindPFlag("appstore.kid", cmd.Flags().Lookup("kid"))
		viper.BindPFlag("appstore.jwt", cmd.Flags().Lookup("jwt"))

		name := viper.GetString("appstore.device.reg.name")
		platform := viper.GetString("appstore.device.reg.platform")
		udid := viper.GetString("appstore.device.reg.udid")

		if (viper.GetString("appstore.p8") == "" || viper.GetString("appstore.iss") == "" || viper.GetString("appstore.kid") == "") && viper.GetString("appstore.jwt") == "" {
			return fmt.Errorf("you must provide (--p8, --iss and --kid) OR --jwt")
		}
		if name == "" || platform == "" || udid == "" {
			return fmt.Errorf("you must provide --name, --platform AND --udid")
		}
		as := appstore.NewAppStore(
			viper.GetString("appstore.p8"),
			viper.GetString("appstore.iss"),
			viper.GetString("appstore.kid"),
			viper.GetString("appstore.jwt"),
		)

		dev, err := as.RegisterDevice(name, platform, udid)
		if err != nil {
			return err
		}

		log.Info("Registered NEW device:")
		model := dev.Attributes.DeviceClass
		if dev.Attributes.Model != "" {
			model = dev.Attributes.Model
		}
		utils.Indent(log.Info, 2)(fmt.Sprintf("%s: [%s] Added: %s - %s (%s)", dev.ID, dev.Attributes.Status, dev.Attributes.AddedDate.Format("02Jan2006 15:04:05"), dev.Attributes.Name, model))

		return nil
	},
}

var ASProfileCmd = &cobra.Command{
	Use:     "profile",
	Aliases: []string{"p"},
	Short:   "Create, delete, and download provisioning profiles that enable app installations for development and distribution",
	Args:    cobra.NoArgs,
	Run: func(cmd *cobra.Command, args []string) {
		cmd.Help()
	},
}

var ASProfileCreateCmd = &cobra.Command{
	Use:           "create <NAME>",
	Aliases:       []string{"c"},
	Short:         "Create a new provisioning profile",
	Args:          cobra.ExactArgs(1),
	SilenceUsage:  true,
	SilenceErrors: true,
	RunE: func(cmd *cobra.Command, args []string) error {

		if viper.GetBool("verbose") {
			log.SetLevel(log.DebugLevel)
		}

		viper.BindPFlag("appstore.p8", cmd.Flags().Lookup("p8"))
		viper.BindPFlag("appstore.iss", cmd.Flags().Lookup("iss"))
		viper.BindPFlag("appstore.kid", cmd.Flags().Lookup("kid"))
		viper.BindPFlag("appstore.jwt", cmd.Flags().Lookup("jwt"))

		bid := viper.GetString("appstore.profile.create.bundle-id")
		certs := viper.GetStringSlice("appstore.profile.create.certs")
		devices := viper.GetStringSlice("appstore.profile.create.devices")

		if (viper.GetString("appstore.p8") == "" || viper.GetString("appstore.iss") == "" || viper.GetString("appstore.kid") == "") && viper.GetString("appstore.jwt") == "" {
			return fmt.Errorf("you must provide (--p8, --iss and --kid) OR --jwt")
		}

		as := appstore.NewAppStore(
			viper.GetString("appstore.p8"),
			viper.GetString("appstore.iss"),
			viper.GetString("appstore.kid"),
			viper.GetString("appstore.jwt"),
		)

		if len(bid) == 0 {
			bids, err := as.GetBundleIDs()
			if err != nil {
				return err
			}

			var choices []string
			for _, b := range bids {
				choices = append(choices, fmt.Sprintf("%s (%s)", b.Attributes.ID, b.Attributes.Name))
			}

			var choice string
			prompt := &survey.Select{
				Message:  "Select buildID to use:",
				Options:  choices,
				PageSize: 10,
			}
			if err := survey.AskOne(prompt, &choice); err == terminal.InterruptErr {
				log.Warn("Exiting...")
				return nil
			}

			for _, b := range bids {
				if strings.HasPrefix(choice, b.Attributes.ID+" (") {
					bid = b.ID
					break
				}
			}
		}

		if len(certs) == 0 {
			cs, err := as.GetCertificates()
			if err != nil {
				return err
			}

			var choices []string
			for _, c := range cs {
				choices = append(choices, c.Attributes.Name)
			}

			var choose []int
			prompt := &survey.MultiSelect{
				Message:  "Select certificates to use:",
				Options:  choices,
				PageSize: 10,
			}
			if err := survey.AskOne(prompt, &choose); err == terminal.InterruptErr {
				log.Warn("Exiting...")
				return nil
			}

			for _, idx := range choose {
				certs = append(certs, cs[idx].ID)
			}
		}

		if len(devices) == 0 {
			ds, err := as.GetDevices()
			if err != nil {
				return err
			}

			var choices []string
			for _, d := range ds {
				choices = append(choices, d.Attributes.Name)
			}

			var choose []int
			prompt := &survey.MultiSelect{
				Message:  "Select devices to use:",
				Options:  choices,
				PageSize: 10,
			}
			if err := survey.AskOne(prompt, &choose); err == terminal.InterruptErr {
				log.Warn("Exiting...")
				return nil
			}

			for _, idx := range choose {
				devices = append(devices, ds[idx].ID)
			}
		}

		log.WithFields(log.Fields{
			"bundle-id": bid,
			"certs":     certs,
			"devices":   devices,
		}).Debug("Creating profile")

		resp, err := as.CreateProfile(args[0], viper.GetString("appstore.profile.create.type"), bid, certs, devices)
		if err != nil {
			return fmt.Errorf("failed to create profile: %v", err)
		}

		log.Info("Created Profile:")
		prof := resp.Data
		utils.Indent(log.Info, 2)(fmt.Sprintf("%s: %s (%s), Expires: %s", prof.ID, prof.Attributes.Name, prof.Attributes.ProfileState, prof.Attributes.ExpirationDate.Format("02Jan2006 15:04:05")))
		cs, err := as.GetProfileCerts(prof.ID)
		if err != nil {
			return err
		}
		if len(certs) > 0 {
			utils.Indent(log.Info, 3)("Certificates:")
		}
		for _, cert := range cs {
			utils.Indent(log.Info, 4)(fmt.Sprintf("%s: %s (%s), Expires: %s", cert.ID, cert.Attributes.Name, cert.Attributes.CertificateType, cert.Attributes.ExpirationDate.Format("02Jan2006 15:04:05")))
		}
		devs, err := as.GetProfileDevices(prof.ID)
		if err != nil {
			return err
		}
		if len(devs) > 0 {
			utils.Indent(log.Info, 3)("Devices:")
		}
		for _, dev := range devs {
			utils.Indent(log.Info, 4)(fmt.Sprintf("%s: %s (%s)", dev.ID, dev.Attributes.Name, dev.Attributes.DeviceClass))
		}

		fname := prof.Attributes.Name + ".mobileprovision"
		if viper.GetString("appstore.profile.create.output") != "" {
			if err := os.MkdirAll(viper.GetString("appstore.profile.create.output"), os.ModePerm); err != nil {
				return fmt.Errorf("failed to create output directory: %v", err)
			}
			fname = filepath.Join(viper.GetString("appstore.profile.create.output"), fname)
		}
		log.Infof("Downloading profile to %s", fname)
		if err := os.WriteFile(fname, resp.Data.Attributes.ProfileContent, 0644); err != nil {
			return fmt.Errorf("failed to write profile to '%s': %v", fname, err)
		}

		return nil
	},
}

var ASProfileListCmd = &cobra.Command{
	Use:           "ls",
	Short:         "List provisioning profiles and download their data",
	Args:          cobra.NoArgs,
	SilenceUsage:  true,
	SilenceErrors: true,
	RunE: func(cmd *cobra.Command, args []string) error {

		if viper.GetBool("verbose") {
			log.SetLevel(log.DebugLevel)
		}

		viper.BindPFlag("appstore.p8", cmd.Flags().Lookup("p8"))
		viper.BindPFlag("appstore.iss", cmd.Flags().Lookup("iss"))
		viper.BindPFlag("appstore.kid", cmd.Flags().Lookup("kid"))
		viper.BindPFlag("appstore.jwt", cmd.Flags().Lookup("jwt"))

		if (viper.GetString("appstore.p8") == "" || viper.GetString("appstore.iss") == "" || viper.GetString("appstore.kid") == "") && viper.GetString("appstore.jwt") == "" {
			return fmt.Errorf("you must provide (--p8, --iss and --kid) OR --jwt")
		}

		as := appstore.NewAppStore(
			viper.GetString("appstore.p8"),
			viper.GetString("appstore.iss"),
			viper.GetString("appstore.kid"),
			viper.GetString("appstore.jwt"),
		)

		profs, err := as.GetProfiles()
		if err != nil {
			return err
		}

		log.Info("Provisioning Profiles:")
		for _, prof := range profs {
			if prof.IsExpired() || prof.IsInvalid() {
				utils.Indent(log.Error, 2)(fmt.Sprintf("%s: %s (%s), Expires: %s", prof.ID, prof.Attributes.Name, prof.Attributes.ProfileState, prof.Attributes.ExpirationDate.Format("02Jan2006 15:04:05")))
			} else {
				utils.Indent(log.Info, 2)(fmt.Sprintf("%s: %s (%s), Expires: %s", prof.ID, prof.Attributes.Name, prof.Attributes.ProfileState, prof.Attributes.ExpirationDate.Format("02Jan2006 15:04:05")))
			}
			certs, err := as.GetProfileCerts(prof.ID)
			if err != nil {
				return err
			}
			if len(certs) > 0 {
				utils.Indent(log.Info, 3)("Certificates:")
			}
			for _, cert := range certs {
				utils.Indent(log.Info, 4)(fmt.Sprintf("%s: %s (%s), Expires: %s", cert.ID, cert.Attributes.Name, cert.Attributes.CertificateType, cert.Attributes.ExpirationDate.Format("02Jan2006 15:04:05")))
			}
			devs, err := as.GetProfileDevices(prof.ID)
			if err != nil {
				return err
			}
			if len(devs) > 0 {
				utils.Indent(log.Info, 3)("Devices:")
			}
			for _, dev := range devs {
				utils.Indent(log.Info, 4)(fmt.Sprintf("%s: %s (%s)", dev.ID, dev.Attributes.Name, dev.Attributes.DeviceClass))
			}
		}

		return nil
	},
}

var ASProfileRemoveCmd = &cobra.Command{
	Use:           "rm",
	Short:         "Delete a provisioning profile that is used for app development or distribution",
	Args:          cobra.NoArgs,
	SilenceUsage:  true,
	SilenceErrors: true,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		var profile *appstore.Profile

		if viper.GetBool("verbose") {
			log.SetLevel(log.DebugLevel)
		}

		viper.BindPFlag("appstore.p8", cmd.Flags().Lookup("p8"))
		viper.BindPFlag("appstore.iss", cmd.Flags().Lookup("iss"))
		viper.BindPFlag("appstore.kid", cmd.Flags().Lookup("kid"))
		viper.BindPFlag("appstore.jwt", cmd.Flags().Lookup("jwt"))

		id := viper.GetString("appstore.profile.rm.id")
		name := viper.GetString("appstore.profile.rm.name")

		if (viper.GetString("appstore.p8") == "" || viper.GetString("appstore.iss") == "" || viper.GetString("appstore.kid") == "") && viper.GetString("appstore.jwt") == "" {
			return fmt.Errorf("you must provide (--p8, --iss and --kid) OR --jwt")
		}
		if id != "" && name != "" {
			return fmt.Errorf("cannot use both --id and --name")
		}

		as := appstore.NewAppStore(
			viper.GetString("appstore.p8"),
			viper.GetString("appstore.iss"),
			viper.GetString("appstore.kid"),
			viper.GetString("appstore.jwt"),
		)

		if id != "" || name != "" {
			if id != "" {
				profile, err = as.GetProfile(id)
				if err != nil {
					return err
				}
			} else {
				profs, err := as.GetProfiles()
				if err != nil {
					return err
				}
				for _, prof := range profs {
					if prof.Attributes.Name == name {
						profile = &prof
						break
					}
				}
				if profile == nil {
					return fmt.Errorf("failed to find profile with name '%s'", name)
				}
			}
		} else {
			profs, err := as.GetProfiles()
			if err != nil {
				return err
			}

			var choices []string
			for _, prof := range profs {
				choices = append(choices, fmt.Sprintf("%s: %s (%s), Expires: %s", prof.ID, prof.Attributes.Name, prof.Attributes.ProfileState, prof.Attributes.ExpirationDate.Format("02Jan2006 15:04:05")))
			}

			var choice string
			prompt := &survey.Select{
				Message:  "Select provisioning profile to renew:",
				Options:  choices,
				PageSize: 10,
			}
			if err := survey.AskOne(prompt, &choice); err == terminal.InterruptErr {
				log.Warn("Exiting...")
				return nil
			}

			for _, prof := range profs {
				if strings.HasPrefix(choice, prof.ID+":") {
					profile = &prof
					break
				}
			}
		}

		log.Infof("Deleting Profile %s", profile.Attributes.Name)
		return as.DeleteProfile(profile.ID)
	},
}

var ASProfileRenewCmd = &cobra.Command{
	Use:           "renew <NAME>",
	Aliases:       []string{"r"},
	Short:         "Renew and expired or invalide provisioning profile",
	Args:          cobra.NoArgs,
	SilenceUsage:  true,
	SilenceErrors: true,
	RunE: func(cmd *cobra.Command, args []string) (err error) {
		var profile *appstore.Profile

		if viper.GetBool("verbose") {
			log.SetLevel(log.DebugLevel)
		}

		viper.BindPFlag("appstore.p8", cmd.Flags().Lookup("p8"))
		viper.BindPFlag("appstore.iss", cmd.Flags().Lookup("iss"))
		viper.BindPFlag("appstore.kid", cmd.Flags().Lookup("kid"))
		viper.BindPFlag("appstore.jwt", cmd.Flags().Lookup("jwt"))

		id := viper.GetString("appstore.profile.renew.id")
		name := viper.GetString("appstore.profile.renew.name")
		output := viper.GetString("appstore.profile.renew.output")

		if (viper.GetString("appstore.p8") == "" || viper.GetString("appstore.iss") == "" || viper.GetString("appstore.kid") == "") && viper.GetString("appstore.jwt") == "" {
			return fmt.Errorf("you must provide (--p8, --iss and --kid) OR --jwt")
		}
		if id != "" && name != "" {
			return fmt.Errorf("cannot use both --id and --name")
		}

		as := appstore.NewAppStore(
			viper.GetString("appstore.p8"),
			viper.GetString("appstore.iss"),
			viper.GetString("appstore.kid"),
			viper.GetString("appstore.jwt"),
		)

		if id != "" || name != "" {
			if id != "" {
				profile, err = as.GetProfile(id)
				if err != nil {
					return err
				}
			} else {
				profs, err := as.GetProfiles()
				if err != nil {
					return err
				}
				for _, prof := range profs {
					if prof.Attributes.Name == name {
						profile = &prof
						break
					}
				}
				if profile == nil {
					return fmt.Errorf("failed to find profile with name '%s'", name)
				}
			}
		} else {
			profs, err := as.GetProfiles()
			if err != nil {
				return err
			}

			var choices []string
			for _, prof := range profs {
				choices = append(choices, fmt.Sprintf("%s: %s (%s), Expires: %s", prof.ID, prof.Attributes.Name, prof.Attributes.ProfileState, prof.Attributes.ExpirationDate.Format("02Jan2006 15:04:05")))
			}

			var choice string
			prompt := &survey.Select{
				Message:  "Select provisioning profile to renew:",
				Options:  choices,
				PageSize: 10,
			}
			if err := survey.AskOne(prompt, &choice); err == terminal.InterruptErr {
				log.Warn("Exiting...")
				return nil
			}

			for _, prof := range profs {
				if strings.HasPrefix(choice, prof.ID+":") {
					profile = &prof
					break
				}
			}
		}

		var bid string
		var certs []string
		var devices []string

		bundleID, err := as.GetProfileBundleID(profile.ID)
		if err != nil {
			return err
		}
		bid = bundleID.ID

		pCerts, err := as.GetProfileCerts(profile.ID)
		if err != nil {
			return err
		}
		for _, cert := range pCerts {
			certs = append(certs, cert.ID)
		}
		pDevs, err := as.GetProfileDevices(profile.ID)
		for _, dev := range pDevs {
			devices = append(devices, dev.ID)
		}

		log.Info("Removing old profile")
		if err := as.DeleteProfile(profile.ID); err != nil {
			return fmt.Errorf("failed to delete profile: %v", err)
		}

		log.WithFields(log.Fields{
			"bundle-id": bid,
			"certs":     certs,
			"devices":   devices,
		}).Debug("Creating profile")

		resp, err := as.CreateProfile(profile.Attributes.Name, profile.Attributes.ProfileType, bid, certs, devices)
		if err != nil {
			return fmt.Errorf("failed to create profile: %v", err)
		}

		log.Info("Renewed Profile:")
		prof := resp.Data
		utils.Indent(log.Info, 2)(fmt.Sprintf("%s: %s (%s), Expires: %s", prof.ID, prof.Attributes.Name, prof.Attributes.ProfileState, prof.Attributes.ExpirationDate.Format("02Jan2006 15:04:05")))
		cs, err := as.GetProfileCerts(prof.ID)
		if err != nil {
			return err
		}
		if len(certs) > 0 {
			utils.Indent(log.Info, 3)("Certificates:")
		}
		for _, cert := range cs {
			utils.Indent(log.Info, 4)(fmt.Sprintf("%s: %s (%s), Expires: %s", cert.ID, cert.Attributes.Name, cert.Attributes.CertificateType, cert.Attributes.ExpirationDate.Format("02Jan2006 15:04:05")))
		}
		devs, err := as.GetProfileDevices(prof.ID)
		if err != nil {
			return err
		}
		if len(devs) > 0 {
			utils.Indent(log.Info, 3)("Devices:")
		}
		for _, dev := range devs {
			utils.Indent(log.Info, 4)(fmt.Sprintf("%s: %s (%s)", dev.ID, dev.Attributes.Name, dev.Attributes.DeviceClass))
		}

		fname := prof.Attributes.Name + ".mobileprovision"
		if output != "" {
			if err := os.MkdirAll(output, os.ModePerm); err != nil {
				return fmt.Errorf("failed to renew output directory: %v", err)
			}
			fname = filepath.Join(output, fname)
		}
		log.Infof("Downloading renewed profile to %s", fname)
		if err := os.WriteFile(fname, resp.Data.Attributes.ProfileContent, 0644); err != nil {
			return fmt.Errorf("failed to write profile to '%s': %v", fname, err)
		}

		return nil
	},
}

var ASTokenCmd = &cobra.Command{
	Use:           "token",
	Short:         "Generate JWT for AppStore Connect API",
	Args:          cobra.NoArgs,
	SilenceUsage:  true,
	SilenceErrors: true,
	RunE: func(cmd *cobra.Command, args []string) error {

		if viper.GetBool("verbose") {
			log.SetLevel(log.DebugLevel)
		}

		lifetime := viper.GetDuration("appstore.token.lifetime")

		viper.BindPFlag("appstore.p8", cmd.Flags().Lookup("p8"))
		viper.BindPFlag("appstore.iss", cmd.Flags().Lookup("iss"))
		viper.BindPFlag("appstore.kid", cmd.Flags().Lookup("kid"))

		if viper.GetString("appstore.p8") == "" || viper.GetString("appstore.iss") == "" || viper.GetString("appstore.kid") == "" {
			return fmt.Errorf("you must provide --p8, --iss and --kid")
		}
		if lifetime > 20*time.Minute {
			return fmt.Errorf("lifetime cannot be more than 20m")
		}

		as := appstore.NewAppStore(
			viper.GetString("appstore.p8"),
			viper.GetString("appstore.iss"),
			viper.GetString("appstore.kid"),
			"",
		)

		jwt, err := as.GenerateToken(lifetime)
		if err != nil {
			return fmt.Errorf("failed to generate token: %v", err)
		}

		fmt.Println(jwt)

		return nil
	},
}

var AppstoreCmd = &cobra.Command{
	Use:     "appstore",
	Aliases: []string{"as"},
	Short:   "Interact with the App Store Connect API",
	Args:    cobra.NoArgs,
	PersistentPreRun: func(cmd *cobra.Command, args []string) {
		viper.BindPFlag("color", cmd.Flags().Lookup("color"))
		viper.BindPFlag("verbose", cmd.Flags().Lookup("verbose"))
	},
	Run: func(cmd *cobra.Command, args []string) {
		cmd.Help()
	},
}