upload

var Cmd = &cobra.Command{
	Use:   "upload",
	Short: "Upload a file and register/update its DRS record",
	RunE: func(cmd *cobra.Command, args []string) error {
		ctx := cmd.Context()
		if strings.TrimSpace(uploadFile) == "" {
			return fmt.Errorf("--file is required")
		}

		srcPath := strings.TrimSpace(uploadFile)
		info, err := os.Stat(srcPath)
		if err != nil {
			return fmt.Errorf("stat source file: %w", err)
		}
		if info.IsDir() {
			return fmt.Errorf("--file must be a regular file")
		}

		authz := strings.TrimSpace(uploadAuthz)
		if authz == "" {
			return fmt.Errorf("--authz is required")
		}

		serverURL, err := cmd.Flags().GetString("server")
		if err != nil {
			return fmt.Errorf("get server flag: %w", err)
		}
		c, err := syclient.New(serverURL)
		if err != nil {
			return err
		}

		bucketName := ""
		if buckets, listErr := c.Buckets().List(ctx); listErr == nil {
			names := make([]string, 0, len(buckets.S3BUCKETS))
			for name := range buckets.S3BUCKETS {
				names = append(names, name)
			}
			sort.Strings(names)
			if len(names) > 0 {
				bucketName = names[0]
			}
		}

		fileBytes, err := os.ReadFile(srcPath)
		if err != nil {
			return fmt.Errorf("read file for hashing: %w", err)
		}
		hash := sha256.Sum256(fileBytes)
		checksum := hex.EncodeToString(hash[:])

		did := strings.TrimSpace(uploadDID)
		if did == "" {
			did = checksum
		}

		name := filepath.Base(srcPath)
		issuers := []string{authz}
		drsObj := &drsapi.DrsObject{
			Id:   did,
			Name: &name,
			Size: info.Size(),
			Checksums: []drsapi.Checksum{
				{
					Type:     "sha256",
					Checksum: checksum,
				},
			},
			AccessMethods: &[]drsapi.AccessMethod{
				{
					Type: "s3",
					Authorizations: &struct {
						BearerAuthIssuers   *[]string                                          `json:"bearer_auth_issuers,omitempty"`
						DrsObjectId         *string                                            `json:"drs_object_id,omitempty"`
						PassportAuthIssuers *[]string                                          `json:"passport_auth_issuers,omitempty"`
						SupportedTypes      *[]drsapi.AccessMethodAuthorizationsSupportedTypes `json:"supported_types,omitempty"`
					}{
						BearerAuthIssuers: &issuers,
					},
				},
			},
		}

		fmt.Fprintf(cmd.OutOrStdout(), "Uploading %s (%s)...\n", srcPath, upload.FormatSize(info.Size()))
		fmt.Fprintf(cmd.OutOrStdout(), "DID: %s\n", did)

		registered, err := upload.RegisterFile(ctx, c.Data(), c.DRS(), drsObj, srcPath, bucketName)
		if err != nil {
			return fmt.Errorf("upload failed: %w", err)
		}

		finalID := did
		if registered != nil && strings.TrimSpace(registered.Id) != "" {
			finalID = strings.TrimSpace(registered.Id)
		}
		if registered != nil && registered.AccessMethods != nil && len(*registered.AccessMethods) > 0 {
			objectURL := ""
			for _, am := range *registered.AccessMethods {
				if am.AccessUrl != nil && strings.TrimSpace(am.AccessUrl.Url) != "" {
					objectURL = strings.TrimSpace(am.AccessUrl.Url)
					break
				}
			}
			if objectURL != "" {
				if err := c.Index().Upsert(ctx, finalID, objectURL, name, info.Size(), checksum, []string{authz}); err != nil {
					return fmt.Errorf("sync index record: %w", err)
				}
			}
		}
		fmt.Fprintf(cmd.OutOrStdout(), "\nsuccessfully uploaded %s\n", finalID)
		fmt.Fprintf(cmd.OutOrStdout(), "requested DID: %s\n", did)
		return nil
	},
}