create

var CreateCmd = &cobra.Command{
	Use:     "create [REPOSITORY_URL | WORKSPACE_CONFIG_NAME]...",
	Short:   "Create a workspace",
	GroupID: util.TARGET_GROUP,
	Aliases: cmd_common.GetAliases("create"),
	RunE: func(cmd *cobra.Command, args []string) error {
		ctx := context.Background()
		var createWorkspaceDtos []apiclient.CreateWorkspaceDTO
		var existingWorkspaceTemplateNames []string
		var targetId string
		promptUsingTUI := len(args) == 0

		apiClient, err := apiclient_util.GetApiClient(nil)
		if err != nil {
			return err
		}

		c, err := config.GetConfig()
		if err != nil {
			return err
		}

		activeProfile, err := c.GetActiveProfile()
		if err != nil {
			return err
		}

		target, createTargetDto, err := GetTarget(ctx, GetTargetConfigParams{
			ApiClient:         apiClient,
			ActiveProfileName: activeProfile.Name,
			TargetNameFlag:    targetNameFlag,
			PromptUsingTUI:    promptUsingTUI,
		})
		if err != nil {
			if common.IsCtrlCAbort(err) {
				return nil
			}
			return err
		}

		targetName := ""
		if target != nil {
			targetName = target.Name
		} else if createTargetDto != nil {
			targetName = createTargetDto.Name
		}

		existingWorkspaces, res, err := apiClient.WorkspaceAPI.ListWorkspaces(context.Background()).Execute()
		if err != nil {
			return apiclient_util.HandleErrorResponse(res, err)
		}

		if promptUsingTUI {
			err = ProcessPrompting(ctx, ProcessPromptingParams{
				ApiClient:                   apiClient,
				CreateWorkspaceDtos:         &createWorkspaceDtos,
				ExistingWorkspaces:          &existingWorkspaces,
				WorkspaceConfigurationFlags: workspaceConfigurationFlags,
				MultiWorkspaceFlag:          multiWorkspaceFlag,
				BlankFlag:                   blankFlag,
				TargetName:                  targetName,
			})
			if err != nil {
				if common.IsCtrlCAbort(err) {
					return nil
				} else {
					return err
				}
			}
		} else {
			existingWorkspaceTemplateNames, err = ProcessCmdArguments(ctx, ProcessCmdArgumentsParams{
				ApiClient:                   apiClient,
				RepoUrls:                    args,
				CreateWorkspaceDtos:         &createWorkspaceDtos,
				ExistingWorkspaces:          &existingWorkspaces,
				WorkspaceConfigurationFlags: workspaceConfigurationFlags,
				BlankFlag:                   blankFlag,
			})
			if err != nil {
				return err
			}
		}

		workspaceNames := []string{}
		for i := range createWorkspaceDtos {
			workspaceNames = append(workspaceNames, createWorkspaceDtos[i].Name)
		}

		names := append(workspaceNames, targetName)

		logs_view.SetupLongestPrefixLength(names)

		requestLogEntry := logs.LogEntry{
			Msg: views.GetPrettyLogLine("Request submitted"),
		}

		if target != nil {
			requestLogEntry.Label = target.Name
		} else if createTargetDto != nil {
			requestLogEntry.Label = createTargetDto.Name
		}

		logs_view.DisplayLogEntry(requestLogEntry, logs_view.STATIC_INDEX)

		for i, workspaceTemplateName := range existingWorkspaceTemplateNames {
			if workspaceTemplateName == "" {
				continue
			}
			logs_view.DisplayLogEntry(logs.LogEntry{
				Label: createWorkspaceDtos[i].Name,
				Msg:   fmt.Sprintf("Using detected workspace template '%s'\n", workspaceTemplateName),
			}, i)
		}

		activeProfile, err = c.GetActiveProfile()
		if err != nil {
			return err
		}

		if target != nil {
			targetId = target.Id
		} else if createTargetDto != nil {
			targetId = createTargetDto.Id
		}

		logsContext, stopLogs := context.WithCancel(context.Background())
		defer stopLogs()

		if createTargetDto != nil {
			go cmd_common.ReadTargetLogs(logsContext, cmd_common.ReadLogParams{
				Id:                    targetId,
				Label:                 &createTargetDto.Name,
				ServerUrl:             activeProfile.Api.Url,
				ApiKey:                activeProfile.Api.Key,
				Follow:                util.Pointer(true),
				SkipPrefixLengthSetup: true,
			})

			t, res, err := apiClient.TargetAPI.CreateTarget(ctx).Target(*createTargetDto).Execute()
			if err != nil {
				return apiclient_util.HandleErrorResponse(res, err)
			}

			err = cmd_common.AwaitTargetState(t.Id, apiclient.ResourceStateNameStarted)
			if err != nil {
				return err
			}

			target = &apiclient.TargetDTO{
				Id:             t.Id,
				Name:           t.Name,
				TargetConfig:   t.TargetConfig,
				TargetConfigId: t.TargetConfigId,
				Default:        t.Default,
			}
		}

		var tsConn *tsnet.Server
		if !common.IsLocalDockerTarget(target.TargetConfig.ProviderInfo.Name, target.TargetConfig.Options, target.TargetConfig.ProviderInfo.RunnerId) || activeProfile.Id != "default" {
			tsConn, err = tailscale.GetConnection(&activeProfile)
			if err != nil {
				return err
			}
		}

		for i := range createWorkspaceDtos {
			createWorkspaceDtos[i].TargetId = targetId
			go cmd_common.ReadWorkspaceLogs(logsContext, cmd_common.ReadLogParams{
				Id:                    createWorkspaceDtos[i].Id,
				Label:                 &createWorkspaceDtos[i].Name,
				ServerUrl:             activeProfile.Api.Url,
				ApiKey:                activeProfile.Api.Key,
				Index:                 util.Pointer(i),
				Follow:                util.Pointer(true),
				SkipPrefixLengthSetup: true,
			})

			_, res, err := apiClient.WorkspaceAPI.CreateWorkspace(ctx).Workspace(createWorkspaceDtos[i]).Execute()
			if err != nil {
				return apiclient_util.HandleErrorResponse(res, err)
			}

			err = cmd_common.AwaitWorkspaceState(createWorkspaceDtos[i].Id, apiclient.ResourceStateNameStarted)
			if err != nil {
				return err
			}
		}

		gpgKey, err := cmd_common.GetGitProviderGpgKey(apiClient, ctx, createWorkspaceDtos[0].GitProviderConfigId)
		if err != nil {
			log.Warn(err)
		}

		err = waitForDial(target, createWorkspaceDtos[0].Id, &activeProfile, tsConn, gpgKey)
		if err != nil {
			return err
		}

		stopLogs()

		fmt.Print("\033[?25h")

		chosenIdeId := c.DefaultIdeId
		if IdeFlag != "" {
			chosenIdeId = IdeFlag
		}

		ideList := config.GetIdeList()
		var chosenIde config.Ide

		for _, ide := range ideList {
			if ide.Id == chosenIdeId {
				chosenIde = ide
			}
		}

		fmt.Println()

		createdWorkspaces := []apiclient.WorkspaceDTO{}
		for _, createWorkspaceDto := range createWorkspaceDtos {
			ws, _, err := apiclient_util.GetWorkspace(createWorkspaceDto.Id)
			if err != nil {
				return err
			}
			createdWorkspaces = append(createdWorkspaces, *ws)
		}

		if len(createdWorkspaces) > 1 {
			info.RenderMulti(createdWorkspaces, chosenIde.Name, false)
		} else {
			info.Render(&createdWorkspaces[0], chosenIde.Name, false)
		}

		if noIdeFlag {
			views.RenderCreationInfoMessage("Run 'daytona code' when you're ready to start developing")
			return nil
		}

		views.RenderCreationInfoMessage(fmt.Sprintf("Opening the workspace in %s ...", chosenIde.Name))

		return cmd_common.OpenIDE(chosenIdeId, activeProfile, createWorkspaceDtos[0].Name, *createdWorkspaces[0].ProviderMetadata, YesFlag, gpgKey)
	},
}

var IdeFlag string

var YesFlag bool