deploy

var DeployCmd = &cobra.Command{
	Use:   "deploy [deploymentId]",
	Short: "Run a deployment",
	Long: `
Run a deployment by ID, or omit it to deploy the development environment.

If no deploymentId is provided, the CLI will use the current project config to
find the development environment deployment. If it doesn't exist yet, it will
be created automatically.

Usage:
  hyphen deploy [deploymentId] [flags]

Examples:
  hyphen deploy                  # deploys the dev environment (auto-detected)
  hyphen deploy depl_abc123      # deploys a specific deployment by ID

Use 'hyphen deploy --help' for more information about available flags.
`,
	Args: cobra.RangeArgs(0, 1),
	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
		return user.ErrorIfNotAuthenticated()
	},
	RunE: func(cmd *cobra.Command, args []string) error {
		orgId, err := flags.GetOrganizationID()
		if err != nil {
			return err
		}

		printer = cprint.NewCPrinter(flags.VerboseFlag)

		service := Deployment.NewService()

		var selectedDeployment models.Deployment

		if len(args) == 0 {
			cfg, err := config.RestoreLocalConfig()
			if err != nil {
				return fmt.Errorf("failed to restore config: %w", err)
			}

			projectId := projectFlag
			if cfg.ProjectId != nil {
				projectId = *cfg.ProjectId
			}
			if projectId == "" {
				return fmt.Errorf("project id not found in config")
			}

			var envId string
			if envFlag != "" {
				envId = envFlag
			} else {
				envService := env.NewService()
				devEnv, devEnvErr := envService.GetDevelopmentEnvironment(orgId, projectId)
				if errors.Is(devEnvErr, errors.ErrNotFound) {
					return fmt.Errorf("no development environment found for this project")
				}
				if devEnvErr != nil {
					return fmt.Errorf("failed to get development environment: %w", devEnvErr)
				}
				envId = devEnv.ID
			}

			projectService := projects.NewService(orgId)
			deployment, deploymentErr := projectService.GetEnvironmentDeployment(projectId, envId)
			if deploymentErr != nil && !errors.Is(deploymentErr, errors.ErrNotFound) {
				return fmt.Errorf("failed to get deployment for environment: %w", deploymentErr)
			}

			if errors.Is(deploymentErr, errors.ErrNotFound) || deployment.ID == "" {
				project, err := projectService.GetProject(projectId)
				if err != nil {
					return fmt.Errorf("failed to get project: %w", err)
				}
				if cfg.AppId == nil {
					return fmt.Errorf("app id not found in config")
				}

				name := deploymentNamePart(project.AlternateID, 25)

				newDeployment, err := service.CreateEnvironmentDeployment(orgId, projectId, envId, *cfg.AppId, name, name, "")
				if err != nil {
					return fmt.Errorf("failed to create deployment: %w", err)
				}
				selectedDeployment = *newDeployment
			} else {
				selectedDeployment = deployment
			}
		} else {
			deployment, err := service.GetDeployment(orgId, args[0])
			if err != nil {
				return fmt.Errorf("failed to get deployment: %w", err)
			}

			selectedDeployment = *deployment
		}
		if !selectedDeployment.IsReady {
			printer.Print("❌ There are issues blocking this deployment from being run.")
			for _, issue := range selectedDeployment.ReadinessIssues {
				if issue.Cloud != "" {
					printer.Print(fmt.Sprintf("  • %s (%s)", issue.Error, issue.Cloud))
				} else {
					printer.Print(fmt.Sprintf("  • %s", issue.Error))
				}
			}
			return nil
		}

		// Match preview if preview flag is provided
		var previewId string
		if flags.PreviewNameFlag != "" {
			matchedPreviews := []models.DeploymentPreview{}
			for _, p := range selectedDeployment.Previews {
				if p.Name == flags.PreviewNameFlag {

					if flags.PreviewPrefixFlag != "" {
						if p.HostPrefix == flags.PreviewPrefixFlag {
							matchedPreviews = append(matchedPreviews, p)
						}
					} else {
						matchedPreviews = append(matchedPreviews, p)
					}
				}
			}

			if len(matchedPreviews) == 0 {
				if flags.PreviewPrefixFlag == "" {
					return fmt.Errorf("no preview found with name '%s', please specify --prefix flag to create a new preview", flags.PreviewNameFlag)
				}
				newPreview, err := service.CreatePreview(orgId, selectedDeployment, flags.PreviewNameFlag, flags.PreviewPrefixFlag)
				if err != nil {
					return fmt.Errorf("failed to create preview: %w", err)
				}
				previewId = newPreview.ID
			} else if len(matchedPreviews) > 1 {
				return fmt.Errorf("multiple previews found with name '%s', please specify --prefix flag to disambiguate", flags.PreviewNameFlag)
			} else {
				previewId = matchedPreviews[0].ID
			}
		}

		appSources := []Deployment.AppSources{}

		if noBuild {

		} else {

			firstApp := selectedDeployment.Apps[0]

			service := build.NewService()
			result, err := service.RunBuild(cmd, printer, firstApp.DeploymentSettings.ProjectEnvironment.ID, flags.VerboseFlag, flags.DockerfileFlag, flags.PreviewNameFlag)
			if err != nil {
				return err
			}
			appSources = append(appSources, Deployment.AppSources{
				AppId:    result.App.ID,
				Artifact: result.Artifact,
			},
			)
		}

		printer.Print(fmt.Sprintf("Running %s", selectedDeployment.Name))

		run, err := service.CreateRun(orgId, selectedDeployment.ID, appSources, previewId)
		if err != nil {
			return fmt.Errorf("failed to create run: %w", err)
		}

		appUrl := fmt.Sprintf("%s/%s/deploy/%s/runs/%s", apiconf.GetBaseAppUrl(), orgId, selectedDeployment.ID, run.ID)

		if shouldUseTUI() {
			runWithTUI(orgId, selectedDeployment.ID, run, appUrl, service)
		} else {
			runWithoutTUI(orgId, selectedDeployment.ID, run, appUrl, service)
		}

		return nil
	},
}