upload

var CancelCmd = &cobra.Command{
	Use:   "cancel <manifestId>",
	Short: "Cancel upload session.",
	Long:  `Cancel upload session.`,
	Args:  cobra.MinimumNArgs(1),
	Run: func(cmd *cobra.Command, args []string) {

		i, err := strconv.ParseInt(args[0], 10, 32)
		if err != nil {
			fmt.Printf("Error: <manifestId> should be an integer.")
			return
		}
		selectedManifest := int32(i)

		cancelAll := false

		req := api.CancelUploadRequest{
			ManifestId: selectedManifest,
			CancelAll:  cancelAll,
		}

		port := viper.GetString("agent.port")

		conn, err := grpc.Dial(":"+port, grpc.WithTransportCredentials(insecure.NewCredentials()))
		if err != nil {
			fmt.Println("Error connecting to GRPC Server: ", err)
		}
		defer conn.Close()

		client := api.NewAgentClient(conn)
		uploadResponse, err := client.CancelUpload(context.Background(), &req)
		if err != nil {
			shared.HandleAgentError(err, fmt.Sprintf("Error uploading file: %v", err))
		}
		fmt.Println(uploadResponse)

	},
}

var ManifestCmd = &cobra.Command{
	Use:   "manifest <manifestId>",
	Short: "Upload files to the Pennsieve platform.",
	Long:  `Upload files to the Pennsieve platform.`,
	Args:  cobra.MinimumNArgs(1),
	Run: func(cmd *cobra.Command, args []string) {

		port := viper.GetString("agent.port")
		conn, err := grpc.Dial(":"+port, grpc.WithTransportCredentials(insecure.NewCredentials()))

		if err != nil {
			log.Println("Error connecting to GRPC Server: ", err)
			return
		}
		client := api.NewAgentClient(conn)

		i, err := strconv.ParseInt(args[0], 10, 32)
		if err != nil {
			log.Printf("Error: <manifestId> should be an integer.")
			return
		}

		manifestId := int32(i)
		workflowPath, err := cmd.Flags().GetString("workflow")
		_, err = cmd.Flags().GetString("workflowOpts")

		if err != nil {
			log.Println("Workflow error: ", err)
		}
		WrkFlwReq := api.StartWorkflowRequest{
			ManifestId:   manifestId,
			WorkflowFlag: workflowPath,
		}
		if workflowPath != "" {
			log.Println("STARTING WORKFLOW")
			workflowResponse, err := client.StartWorkflow(context.Background(), &WrkFlwReq)
			log.Println("Workflow Response")
			log.Println(workflowResponse)

			if workflowResponse.Success == false || err != nil {
				log.Println("Workflow failed. Stopping upload", err)
				return
			}
		}

		req := api.UploadManifestRequest{ManifestId: manifestId}

		defer conn.Close()

		_, err = client.UploadManifest(context.Background(), &req)
		if err != nil {
			shared.HandleAgentError(err, fmt.Sprintln("Error uploading manifest: ", err))
		}

		log.Println(fmt.Sprintf("\nUpload initiated for manifest: %d.\n You can safely Ctr-C as uploading process will continue to run in the background."+
			"\n\n  Use \"pennsieve agent subscribe\" to track progress of the uploaded files.\n\n"+
			"  Use \"pennsieve upload cancel %d\" to cancel the current upload session.", manifestId, manifestId))

		log.Println("\n------------")

		r1 := rand.New(rand.NewSource(time.Now().UnixNano()))
		SubscribeClient, err := subscriber.NewSubscriberClient(int32(r1.Intn(100)))
		if err != nil {
			log.Println("Unable to track uploads. Please check logs to verify files are uploaded.")
		}
		SubscribeClient.Start([]api.SubscribeResponse_MessageType{
			api.SubscribeResponse_UPLOAD_STATUS, api.SubscribeResponse_EVENT}, subscriber.StopOnStatus{
			Enable: true,
			OnType: []api.SubscribeResponse_MessageType{api.SubscribeResponse_UPLOAD_STATUS},
		})
	},
}

var UploadCmd = &cobra.Command{
	Use:   "upload [flags] [PATH] [...PATH]",
	Short: "Upload files to the Pennsieve platform.",
	Long:  `Upload files to the Pennsieve platform.`,
}