GoogleDriveClient.cs

using Google.Apis.Drive.v3;
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Pipelines;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using DriveFile = Google.Apis.Drive.v3.Data.File;

namespace ManagedCode.Storage.GoogleDrive.Clients;

public class GoogleDriveClient : IGoogleDriveClient
{
    private const string FolderMimeType = "application/vnd.google-apps.folder";
    private readonly DriveService _driveService;

    public GoogleDriveClient(DriveService driveService)
    {
        _driveService = driveService ?? throw new ArgumentNullException(nameof(driveService));
    }

    public Task EnsureRootAsync(string rootFolderId, bool createIfNotExists, CancellationToken cancellationToken)
    {
        // Google Drive root exists by default when using "root". Additional folder tree is created on demand in UploadAsync.
        return Task.CompletedTask;
    }

    public async Task<DriveFile> UploadAsync(string rootFolderId, string path, Stream content, string? contentType, bool supportsAllDrives, CancellationToken cancellationToken)
    {
        var (parentId, fileName) = await EnsureParentFolderAsync(rootFolderId, path, supportsAllDrives, cancellationToken);

        var fileMetadata = new DriveFile
        {
            Name = fileName,
            Parents = new List<string> { parentId }
        };

        var request = _driveService.Files.Create(fileMetadata, content, contentType ?? "application/octet-stream");
        request.Fields = "id,name,parents,createdTime,modifiedTime,md5Checksum,size";
        request.SupportsAllDrives = supportsAllDrives;
        await request.UploadAsync(cancellationToken);
        return request.ResponseBody ?? throw new InvalidOperationException("Google Drive upload returned no metadata.");
    }

    public async Task<Stream> DownloadAsync(string rootFolderId, string path, bool supportsAllDrives, CancellationToken cancellationToken)
    {
        var file = await FindFileByPathAsync(rootFolderId, path, supportsAllDrives, cancellationToken) ?? throw new FileNotFoundException(path);
        var pipe = new Pipe();
        var getRequest = _driveService.Files.Get(file.Id);
        getRequest.SupportsAllDrives = supportsAllDrives;

        _ = Task.Run(async () =>
        {
            try
            {
                await using var destination = pipe.Writer.AsStream(leaveOpen: true);
                await getRequest.DownloadAsync(destination, cancellationToken);
                pipe.Writer.Complete();
            }
            catch (Exception ex)
            {
                pipe.Writer.Complete(ex);
            }
        }, cancellationToken);

        return pipe.Reader.AsStream();
    }

    public async Task<bool> DeleteAsync(string rootFolderId, string path, bool supportsAllDrives, CancellationToken cancellationToken)
    {
        var file = await FindFileByPathAsync(rootFolderId, path, supportsAllDrives, cancellationToken);
        if (file == null)
        {
            return false;
        }

        await DeleteRecursiveAsync(file.Id, file.MimeType, supportsAllDrives, cancellationToken);
        return true;
    }

    public async Task<bool> ExistsAsync(string rootFolderId, string path, bool supportsAllDrives, CancellationToken cancellationToken)
    {
        return await FindFileByPathAsync(rootFolderId, path, supportsAllDrives, cancellationToken) != null;
    }

    public Task<DriveFile?> GetMetadataAsync(string rootFolderId, string path, bool supportsAllDrives, CancellationToken cancellationToken)
    {
        return FindFileByPathAsync(rootFolderId, path, supportsAllDrives, cancellationToken);
    }

    public async IAsyncEnumerable<DriveFile> ListAsync(string rootFolderId, string? directory, bool supportsAllDrives, [EnumeratorCancellation] CancellationToken cancellationToken)
    {
        string parentId;
        if (string.IsNullOrWhiteSpace(directory))
        {
            parentId = rootFolderId;
        }
        else
        {
            parentId = await EnsureFolderPathAsync(rootFolderId, directory!, false, supportsAllDrives, cancellationToken) ?? string.Empty;
            if (string.IsNullOrWhiteSpace(parentId))
            {
                yield break;
            }
        }

        var request = _driveService.Files.List();
        request.SupportsAllDrives = supportsAllDrives;
        request.IncludeItemsFromAllDrives = supportsAllDrives;

        request.Q = $"'{parentId}' in parents and trashed=false";

        request.Fields = "nextPageToken,files(id,name,parents,createdTime,modifiedTime,md5Checksum,size,mimeType)";

        do
        {
            var response = await request.ExecuteAsync(cancellationToken);
            foreach (var file in response.Files ?? Enumerable.Empty<DriveFile>())
            {
                cancellationToken.ThrowIfCancellationRequested();
                yield return file;
            }

            request.PageToken = response.NextPageToken;
        } while (!string.IsNullOrEmpty(request.PageToken));
    }

    private async Task<(string ParentId, string Name)> EnsureParentFolderAsync(string rootFolderId, string fullPath, bool supportsAllDrives, CancellationToken cancellationToken)
    {
        var normalizedPath = fullPath.Replace("\\", "/").Trim('/');
        var segments = normalizedPath.Split('/', StringSplitOptions.RemoveEmptyEntries);
        if (segments.Length == 0)
        {
            return (rootFolderId, Guid.NewGuid().ToString("N"));
        }

        var parentPath = string.Join('/', segments.Take(segments.Length - 1));
        var parentId = await EnsureFolderPathAsync(rootFolderId, parentPath, true, supportsAllDrives, cancellationToken) ?? rootFolderId;
        return (parentId, segments.Last());
    }

    private async Task<string?> EnsureFolderPathAsync(string rootFolderId, string path, bool createIfMissing, bool supportsAllDrives, CancellationToken cancellationToken)
    {
        var currentId = rootFolderId;
        foreach (var segment in path.Split('/', StringSplitOptions.RemoveEmptyEntries))
        {
            var folder = await FindChildAsync(currentId, segment, supportsAllDrives, cancellationToken);
            if (folder == null)
            {
                if (!createIfMissing)
                {
                    return null;
                }

                var metadata = new DriveFile { Name = segment, MimeType = "application/vnd.google-apps.folder", Parents = new List<string> { currentId } };
                var createRequest = _driveService.Files.Create(metadata);
                createRequest.SupportsAllDrives = supportsAllDrives;
                folder = await createRequest.ExecuteAsync(cancellationToken);
            }

            currentId = folder.Id;
        }

        return currentId;
    }

    private async Task<DriveFile?> FindChildAsync(string parentId, string name, bool supportsAllDrives, CancellationToken cancellationToken)
    {
        var request = _driveService.Files.List();
        request.Q = $"'{parentId}' in parents and name='{name}' and trashed=false";
        request.Fields = "files(id,name,parents,createdTime,modifiedTime,md5Checksum,size,mimeType)";
        request.SupportsAllDrives = supportsAllDrives;
        request.IncludeItemsFromAllDrives = supportsAllDrives;
        var response = await request.ExecuteAsync(cancellationToken);
        return response.Files?.FirstOrDefault();
    }

    private async Task DeleteRecursiveAsync(string fileId, string? mimeType, bool supportsAllDrives, CancellationToken cancellationToken)
    {
        cancellationToken.ThrowIfCancellationRequested();

        if (string.Equals(mimeType, FolderMimeType, StringComparison.OrdinalIgnoreCase))
        {
            await DeleteFolderChildrenAsync(fileId, supportsAllDrives, cancellationToken);
        }

        var trashRequest = _driveService.Files.Update(new DriveFile { Trashed = true }, fileId);
        trashRequest.SupportsAllDrives = supportsAllDrives;
        await trashRequest.ExecuteAsync(cancellationToken);
    }

    private async Task DeleteFolderChildrenAsync(string folderId, bool supportsAllDrives, CancellationToken cancellationToken)
    {
        var request = _driveService.Files.List();
        request.Q = $"'{folderId}' in parents and trashed=false";
        request.Fields = "nextPageToken,files(id,mimeType)";
        request.SupportsAllDrives = supportsAllDrives;
        request.IncludeItemsFromAllDrives = supportsAllDrives;

        do
        {
            var response = await request.ExecuteAsync(cancellationToken);
            foreach (var entry in response.Files ?? Enumerable.Empty<DriveFile>())
            {
                cancellationToken.ThrowIfCancellationRequested();
                if (string.IsNullOrWhiteSpace(entry.Id))
                {
                    continue;
                }

                await DeleteRecursiveAsync(entry.Id, entry.MimeType, supportsAllDrives, cancellationToken);
            }

            request.PageToken = response.NextPageToken;
        } while (!string.IsNullOrWhiteSpace(request.PageToken));
    }

    private async Task<DriveFile?> FindFileByPathAsync(string rootFolderId, string path, bool supportsAllDrives, CancellationToken cancellationToken)
    {
        var normalizedPath = path.Replace("\\", "/").Trim('/');
        var segments = normalizedPath.Split('/', StringSplitOptions.RemoveEmptyEntries);
        if (segments.Length == 0)
        {
            return null;
        }

        var parentPath = string.Join('/', segments.Take(segments.Length - 1));
        var fileName = segments.Last();
        var parentId = await EnsureFolderPathAsync(rootFolderId, parentPath, false, supportsAllDrives, cancellationToken);
        if (parentId == null)
        {
            return null;
        }

        return await FindChildAsync(parentId, fileName, supportsAllDrives, cancellationToken);
    }
}