export async function uploadFileCommand()

in packages/core/src/awsService/s3/commands/uploadFile.ts [51:181]
105 lines of code
15 McCabe index (conditional complexity)

export async function uploadFileCommand(
    s3Client: S3Client,
    nodeOrDocument: S3BucketNode | S3FolderNode | vscode.Uri | undefined,
    fileSizeBytes: FileSizeBytes = statFile,
    getBucket = promptUserForBucket,
    getFile = getFilesToUpload,
    outputChannel = globals.outputChannel
): Promise<void> {
    let node: S3BucketNode | S3FolderNode | undefined
    let document: vscode.Uri | undefined
    const uploadRequests: UploadRequest[] = []

    if (nodeOrDocument) {
        if (nodeOrDocument instanceof S3BucketNode || nodeOrDocument instanceof S3FolderNode) {
            node = nodeOrDocument as S3BucketNode | S3FolderNode
            document = undefined
        } else {
            node = undefined
            document = nodeOrDocument as vscode.Uri
        }
    } else {
        node = undefined
        document = undefined
    }

    const fileToUploadRequest = (bucketName: string, key: string, file: vscode.Uri) => ({
        bucketName,
        key: key,
        fileLocation: file,
        fileSizeBytes: fileSizeBytes(file),
        s3Client,
    })

    if (node) {
        const filesToUpload = await getFile(undefined)

        if (!filesToUpload) {
            showOutputMessage(
                localize('AWS.message.error.uploadFileCommand.noFileSelected', 'No file selected, cancelling upload'),
                outputChannel
            )
            getLogger().info('UploadFile cancelled')
            telemetry.s3_uploadObject.emit({ result: 'Cancelled' })
            return
        }

        uploadRequests.push(
            ...filesToUpload.map((file) => {
                const key = node!.path + path.basename(file.fsPath)
                return fileToUploadRequest(node!.bucket.Name, key, file)
            })
        )
        if (node instanceof S3FolderNode) {
            globals.globalState.tryUpdate('aws.lastUploadedToS3Folder', {
                bucket: node.bucket,
                folder: node.folder,
            })
        }
    } else {
        while (true) {
            const filesToUpload = await getFile(document)

            if (!filesToUpload || filesToUpload.length === 0) {
                // if file is undefined, means the back button was pressed(there is no step before) or no file was selected
                // thus break the loop of the 'wizard'
                showOutputMessage(
                    localize(
                        'AWS.message.error.uploadFileCommand.noFileSelected',
                        'No file selected, cancelling upload'
                    ),
                    outputChannel
                )
                getLogger().info('UploadFile cancelled')
                telemetry.s3_uploadObject.emit({ result: 'Cancelled' })
                return
            }

            const bucketResponse = await getBucket(s3Client).catch((e) => {})

            if (!bucketResponse) {
                telemetry.s3_uploadObject.emit({ result: 'Failed' })
                return
            }

            if (typeof bucketResponse === 'string') {
                if (bucketResponse === 'back') {
                    continue
                }

                showOutputMessage(
                    localize(
                        'AWS.message.error.uploadFileCommand.noBucketSelected',
                        'No bucket selected, cancelling upload'
                    ),
                    outputChannel
                )
                getLogger().info('No bucket selected, cancelling upload')
                telemetry.s3_uploadObject.emit({ result: 'Cancelled' })
                return
            }

            const bucketName = bucketResponse.bucket!.Name
            if (!bucketName) {
                throw Error(`bucketResponse is not a S3.Bucket`)
            }

            uploadRequests.push(
                ...filesToUpload.map((file) => {
                    const key =
                        bucketResponse.folder !== undefined
                            ? bucketResponse.folder.path + path.basename(file.fsPath)
                            : path.basename(file.fsPath)
                    return fileToUploadRequest(bucketName, key, file)
                })
            )

            if (bucketResponse.folder) {
                globals.globalState.tryUpdate('aws.lastUploadedToS3Folder', {
                    bucket: bucketResponse.bucket,
                    folder: bucketResponse.folder,
                })
            }

            break
        }
    }

    await runBatchUploads(uploadRequests, outputChannel)

    void vscode.commands.executeCommand('aws.refreshAwsExplorer', true)
}