Пишем адаптер для локального хранилища S3 на C#

public interface IStorageAdapter
{
    Task<bool> BucketExistsAsync(string bucketName, CancellationToken cancellationToken = default);
    Task CreateBucketAsync(string bucketName, CancellationToken cancellationToken = default);
    Task<StorageObject> GetObjectAsync(string bucketName, string objectKey, CancellationToken cancellationToken = default);
    Task<string> PutObjectAsync(string bucketName, string objectKey, Stream content, CancellationToken cancellationToken = default);
    Task DeleteObjectAsync(string bucketName, string objectKey, CancellationToken cancellationToken = default);
    Task<IEnumerable<StorageObjectInfo>> ListObjectsAsync(string bucketName, string prefix = null, CancellationToken cancellationToken = default);
}

public class S3StorageAdapter : IStorageAdapter
{
    private readonly IAmazonS3 _s3Client;
    private readonly ILogger<S3StorageAdapter> _logger;
    private readonly IRetryPolicy _retryPolicy;
    
    public S3StorageAdapter(IAmazonS3 s3Client, ILogger<S3StorageAdapter> logger, IRetryPolicy retryPolicy)
    {
        _s3Client = s3Client ?? throw new ArgumentNullException(nameof(s3Client));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        _retryPolicy = retryPolicy ?? throw new ArgumentNullException(nameof(retryPolicy));
    }
    
    public async Task<bool> BucketExistsAsync(string bucketName, CancellationToken cancellationToken = default)
    {
        try
        {
            return await _retryPolicy.ExecuteAsync(async () =>
            {
                var response = await _s3Client.DoesS3BucketExistV2Async(bucketName);
                return response;
            }, cancellationToken);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error checking bucket existence: {BucketName}", bucketName);
            throw;
        }
    }
}

public class S3ClientFactory : IS3ClientFactory
{
    private readonly IConfiguration _configuration;
    
    public S3ClientFactory(IConfiguration configuration)
    {
        _configuration = configuration;
    }
    
    public IAmazonS3 CreateClient()
    {
        var config = new AmazonS3Config
        {
            ServiceURL = _configuration["S3:ServiceUrl"],
            ForcePathStyle = _configuration.GetValue<bool>("S3:ForcePathStyle"),
            UseHttp = _configuration.GetValue<bool>("S3:UseHttp"),
            MaxErrorRetry = _configuration.GetValue<int>("S3:MaxRetries"),
            Timeout = TimeSpan.FromSeconds(_configuration.GetValue<int>("S3:TimeoutSeconds")),
            ReadWriteTimeout = TimeSpan.FromSeconds(_configuration.GetValue<int>("S3:ReadWriteTimeoutSeconds"))
        };
        
        return new AmazonS3Client(_configuration["S3:AccessKey"], _configuration["S3:SecretKey"], config);
    }
}

public class DocumentRepository : IDocumentRepository
{
    private readonly IStorageAdapter _storageAdapter;
    private readonly string _bucketName;
    
    public DocumentRepository(IStorageAdapter storageAdapter, IConfiguration configuration)
    {
        _storageAdapter = storageAdapter;
        _bucketName = configuration["Documents:BucketName"];
    }
    
    public async Task<Document> GetDocumentAsync(Guid documentId)
    {
        var objectKey = $"documents/{documentId}";
        var storageObject = await _storageAdapter.GetObjectAsync(_bucketName, objectKey);
        
        return JsonSerializer.Deserialize<Document>(storageObject.Content);
    }
}

public class SerializationManager : ISerializationManager
{
    private readonly JsonSerializerOptions _jsonOptions;
    
    public SerializationManager()
    {
        _jsonOptions = new JsonSerializerOptions
        {
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
            WriteIndented = false,
            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
        };
    }
    
    public async Task<T> DeserializeAsync<T>(Stream stream, SerializationFormat format)
    {
        return format switch
        {
            SerializationFormat.Json => await JsonSerializer.DeserializeAsync<T>(stream, _jsonOptions),
            SerializationFormat.Binary => DeserializeBinary<T>(stream),
            _ => throw new NotSupportedException($"Format {format} is not supported")
        };
    }
}

public class S3AdapterOptions
{
    public string ServiceUrl { get; set; }
    public string AccessKey { get; set; }
    public string SecretKey { get; set; }
    public bool ForcePathStyle { get; set; } = true;
    public int TimeoutSeconds { get; set; } = 30;
    public int MaxRetries { get; set; } = 3;
    public TimeSpan RetryDelay { get; set; } = TimeSpan.FromSeconds(1);
    public bool UseHttps { get; set; } = false;
    
    public void Validate()
    {
        if (string.IsNullOrEmpty(ServiceUrl))
            throw new ArgumentException("ServiceUrl is required");
        if (string.IsNullOrEmpty(AccessKey))
            throw new ArgumentException("AccessKey is required");
        if (string.IsNullOrEmpty(SecretKey))
            throw new ArgumentException("SecretKey is required");
    }
}

public class BatchOperationManager
{
    private readonly SemaphoreSlim _semaphore;
    private readonly IStorageAdapter _adapter;
    
    public BatchOperationManager(IStorageAdapter adapter, int maxConcurrency = 10)
    {
        _adapter = adapter;
        _semaphore = new SemaphoreSlim(maxConcurrency);
    }
    
    public async Task<BatchResult> ProcessBatchAsync(IEnumerable<BatchOperation> operations)
    {
        var tasks = operations.Select(op => ProcessOperationAsync(op));
        var results = await Task.WhenAll(tasks);
        
        return new BatchResult
        {
            SuccessCount = results.Count(r => r.IsSuccess),
            FailureCount = results.Count(r => !r.IsSuccess),
            Results = results
        };
    }
    
    private async Task<OperationResult> ProcessOperationAsync(BatchOperation operation)
    {
        await _semaphore.WaitAsync();
        try
        {
            return await ExecuteOperationAsync(operation);
        }
        finally
        {
            _semaphore.Release();
        }
    }
}

S3Adapter/
├── src/
│   ├── S3Adapter.Core/
│   │   ├── Interfaces/
│   │   ├── Models/
│   │   └── Exceptions/
│   ├── S3Adapter.Implementation/
│   │   ├── Adapters/
│   │   ├── Configuration/
│   │   └── Services/
│   └── S3Adapter.Sample/
│       ├── Controllers/
│       └── Program.cs
├── tests/
│   ├── S3Adapter.UnitTests/
│   └── S3Adapter.IntegrationTests/
├── docker-compose.yml
└── S3Adapter.sln

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddS3Adapter(this IServiceCollection services, IConfiguration configuration)
    {
        services.Configure<S3AdapterOptions>(configuration.GetSection("S3Configuration"));
        
        services.AddSingleton<IS3ClientFactory, S3ClientFactory>();
        services.AddSingleton<IAmazonS3>(provider =>
        {
            var factory = provider.GetRequiredService<IS3ClientFactory>();
            return factory.CreateClient();
        });
        
        services.AddScoped<IStorageAdapter, S3StorageAdapter>();
        services.AddScoped<IRetryPolicy, ExponentialBackoffRetryPolicy>();
        
        return services;
    }
}

S3_SERVICE_URL=http://localhost:9000
S3_ACCESS_KEY=minioadmin
S3_SECRET_KEY=minioadmin
S3_FORCE_PATH_STYLE=true
S3_USE_HTTPS=false
ASPNETCORE_ENVIRONMENT=Development

public class S3HealthCheck : IHealthCheck
{
    private readonly IAmazonS3 _s3Client;
    
    public S3HealthCheck(IAmazonS3 s3Client)
    {
        _s3Client = s3Client;
    }
    
    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
    {
        try
        {
            await _s3Client.ListBucketsAsync(cancellationToken);
            return HealthCheckResult.Healthy("S3 service is available");
        }
        catch (Exception ex)
        {
            return HealthCheckResult.Unhealthy("S3 service is not available", ex);
        }
    }
}

services.Configure<JsonSerializerOptions>(options =>
{
    options.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
    options.WriteIndented = false;
    options.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull;
    options.Converters.Add(new JsonStringEnumConverter());
});

services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = configuration.GetConnectionString("Redis");
    options.InstanceName = "S3Adapter";
});
 
services.AddSingleton<IDistributedCacheService, DistributedCacheService>();

services.AddOpenTelemetry()
    .WithTracing(builder =>
    {
        builder.AddAspNetCoreInstrumentation()
               .AddHttpClientInstrumentation()
               .AddSource("S3Adapter")
               .SetSampler(new AlwaysOnSampler())
               .AddJaegerExporter();
    });

public class S3ConfigurationValidator : IValidateOptions<S3AdapterOptions>
{
    public ValidateOptionsResult Validate(string name, S3AdapterOptions options)
    {
        var failures = new List<string>();
        
        if (string.IsNullOrEmpty(options.ServiceUrl))
            failures.Add("ServiceUrl is required");
        
        if (options.TimeoutSeconds <= 0)
            failures.Add("TimeoutSeconds must be positive");
        
        if (failures.Any())
            return ValidateOptionsResult.Fail(failures);
        
        return ValidateOptionsResult.Success;
    }
}

public class S3StorageAdapter : IStorageAdapter, IDisposable
{
    private readonly IAmazonS3 _s3Client;
    private readonly ILogger<S3StorageAdapter> _logger;
    private readonly IRetryPolicy _retryPolicy;
    private readonly S3AdapterOptions _options;
    private readonly SemaphoreSlim _semaphore;
    private bool _disposed = false;
 
    public S3StorageAdapter(
        IAmazonS3 s3Client,
        ILogger<S3StorageAdapter> logger,
        IRetryPolicy retryPolicy,
        IOptions<S3AdapterOptions> options)
    {
        _s3Client = s3Client ?? throw new ArgumentNullException(nameof(s3Client));
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        _retryPolicy = retryPolicy ?? throw new ArgumentNullException(nameof(retryPolicy));
        _options = options.Value ?? throw new ArgumentNullException(nameof(options));
        _semaphore = new SemaphoreSlim(_options.MaxConcurrentOperations, _options.MaxConcurrentOperations);
    }
 
    public async Task<bool> BucketExistsAsync(string bucketName, CancellationToken cancellationToken = default)
    {
        ValidateBucketName(bucketName);
        
        await _semaphore.WaitAsync(cancellationToken);
        try
        {
            return await _retryPolicy.ExecuteAsync(async () =>
            {
                _logger.LogDebug("Checking bucket existence: {BucketName}", bucketName);
                var response = await _s3Client.DoesS3BucketExistV2Async(bucketName);
                _logger.LogDebug("Bucket {BucketName} exists: {Exists}", bucketName, response);
                return response;
            }, cancellationToken);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error checking bucket existence: {BucketName}", bucketName);
            throw new StorageException($"Failed to check bucket existence: {bucketName}", ex);
        }
        finally
        {
            _semaphore.Release();
        }
    }
 
    public async Task CreateBucketAsync(string bucketName, CancellationToken cancellationToken = default)
    {
        ValidateBucketName(bucketName);
        
        if (await BucketExistsAsync(bucketName, cancellationToken))
        {
            _logger.LogInformation("Bucket {BucketName} already exists", bucketName);
            return;
        }
 
        await _semaphore.WaitAsync(cancellationToken);
        try
        {
            await _retryPolicy.ExecuteAsync(async () =>
            {
                _logger.LogInformation("Creating bucket: {BucketName}", bucketName);
                var request = new PutBucketRequest
                {
                    BucketName = bucketName,
                    UseClientRegion = true
                };
                
                await _s3Client.PutBucketAsync(request, cancellationToken);
                _logger.LogInformation("Bucket {BucketName} created successfully", bucketName);
            }, cancellationToken);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error creating bucket: {BucketName}", bucketName);
            throw new StorageException($"Failed to create bucket: {bucketName}", ex);
        }
        finally
        {
            _semaphore.Release();
        }
    }
}

public async Task<string> PutObjectAsync(string bucketName, string objectKey, Stream content, 
    ObjectMetadata metadata = null, CancellationToken cancellationToken = default)
{
    ValidateBucketName(bucketName);
    ValidateObjectKey(objectKey);
    
    if (content == null)
        throw new ArgumentNullException(nameof(content));
 
    await _semaphore.WaitAsync(cancellationToken);
    try
    {
        return await _retryPolicy.ExecuteAsync(async () =>
        {
            _logger.LogDebug("Uploading object: {BucketName}/{ObjectKey}", bucketName, objectKey);
            
            var request = new PutObjectRequest
            {
                BucketName = bucketName,
                Key = objectKey,
                InputStream = content,
                ContentType = metadata?.ContentType ?? "application/octet-stream",
                ServerSideEncryptionMethod = ServerSideEncryptionMethod.AES256
            };
 
            if (metadata?.CustomMetadata != null)
            {
                foreach (var kvp in metadata.CustomMetadata)
                {
                    request.Headers.Add($"x-amz-meta-{kvp.Key}", kvp.Value);
                }
            }
 
            if (content.CanSeek)
            {
                request.Headers.ContentLength = content.Length;
            }
 
            var response = await _s3Client.PutObjectAsync(request, cancellationToken);
            
            _logger.LogInformation("Object uploaded successfully: {BucketName}/{ObjectKey}, ETag: {ETag}", 
                bucketName, objectKey, response.ETag);
            
            return response.ETag;
        }, cancellationToken);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error uploading object: {BucketName}/{ObjectKey}", bucketName, objectKey);
        throw new StorageException($"Failed to upload object: {bucketName}/{objectKey}", ex);
    }
    finally
    {
        _semaphore.Release();
    }
}
 
public async Task<StorageObject> GetObjectAsync(string bucketName, string objectKey, CancellationToken cancellationToken = default)
{
    ValidateBucketName(bucketName);
    ValidateObjectKey(objectKey);
 
    await _semaphore.WaitAsync(cancellationToken);
    try
    {
        return await _retryPolicy.ExecuteAsync(async () =>
        {
            _logger.LogDebug("Downloading object: {BucketName}/{ObjectKey}", bucketName, objectKey);
            
            var request = new GetObjectRequest
            {
                BucketName = bucketName,
                Key = objectKey
            };
 
            var response = await _s3Client.GetObjectAsync(request, cancellationToken);
            
            var metadata = new ObjectMetadata
            {
                ContentType = response.Headers.ContentType,
                ContentLength = response.Headers.ContentLength,
                LastModified = response.LastModified,
                ETag = response.ETag,
                CustomMetadata = response.Metadata.Where(kvp => kvp.Key.StartsWith("x-amz-meta-"))
                    .ToDictionary(kvp => kvp.Key.Substring(11), kvp => kvp.Value)
            };
 
            _logger.LogInformation("Object downloaded successfully: {BucketName}/{ObjectKey}, Size: {Size}", 
                bucketName, objectKey, response.Headers.ContentLength);
 
            return new StorageObject
            {
                BucketName = bucketName,
                Key = objectKey,
                Content = response.ResponseStream,
                Metadata = metadata
            };
        }, cancellationToken);
    }
    catch (AmazonS3Exception ex) when (ex.StatusCode == HttpStatusCode.NotFound)
    {
        _logger.LogWarning("Object not found: {BucketName}/{ObjectKey}", bucketName, objectKey);
        throw new ObjectNotFoundException($"Object not found: {bucketName}/{objectKey}");
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error downloading object: {BucketName}/{ObjectKey}", bucketName, objectKey);
        throw new StorageException($"Failed to download object: {bucketName}/{objectKey}", ex);
    }
    finally
    {
        _semaphore.Release();
    }
}

public async Task<ObjectMetadata> GetObjectMetadataAsync(string bucketName, string objectKey, CancellationToken cancellationToken = default)
{
    ValidateBucketName(bucketName);
    ValidateObjectKey(objectKey);
 
    await _semaphore.WaitAsync(cancellationToken);
    try
    {
        return await _retryPolicy.ExecuteAsync(async () =>
        {
            _logger.LogDebug("Getting object metadata: {BucketName}/{ObjectKey}", bucketName, objectKey);
            
            var request = new GetObjectMetadataRequest
            {
                BucketName = bucketName,
                Key = objectKey
            };
 
            var response = await _s3Client.GetObjectMetadataAsync(request, cancellationToken);
            
            return new ObjectMetadata
            {
                ContentType = response.Headers.ContentType,
                ContentLength = response.Headers.ContentLength,
                LastModified = response.LastModified,
                ETag = response.ETag,
                CustomMetadata = response.Metadata.Where(kvp => kvp.Key.StartsWith("x-amz-meta-"))
                    .ToDictionary(kvp => kvp.Key.Substring(11), kvp => kvp.Value)
            };
        }, cancellationToken);
    }
    catch (AmazonS3Exception ex) when (ex.StatusCode == HttpStatusCode.NotFound)
    {
        throw new ObjectNotFoundException($"Object not found: {bucketName}/{objectKey}");
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error getting object metadata: {BucketName}/{ObjectKey}", bucketName, objectKey);
        throw new StorageException($"Failed to get object metadata: {bucketName}/{objectKey}", ex);
    }
    finally
    {
        _semaphore.Release();
    }
}
 
private void ValidateBucketName(string bucketName)
{
    if (string.IsNullOrWhiteSpace(bucketName))
        throw new ArgumentException("Bucket name cannot be null or empty", nameof(bucketName));
    
    if (bucketName.Length < 3 || bucketName.Length > 63)
        throw new ArgumentException("Bucket name must be between 3 and 63 characters", nameof(bucketName));
    
    if (!Regex.IsMatch(bucketName, @"^[a-z0-9][a-z0-9\-]*[a-z0-9]$"))
        throw new ArgumentException("Bucket name contains invalid characters", nameof(bucketName));
}
 
private void ValidateObjectKey(string objectKey)
{
    if (string.IsNullOrWhiteSpace(objectKey))
        throw new ArgumentException("Object key cannot be null or empty", nameof(objectKey));
    
    if (objectKey.Length > 1024)
        throw new ArgumentException("Object key cannot exceed 1024 characters", nameof(objectKey));
}

public async Task<string> CopyObjectAsync(string sourceBucket, string sourceKey, string destinationBucket, string destinationKey, CancellationToken cancellationToken = default)
{
    ValidateBucketName(sourceBucket);
    ValidateObjectKey(sourceKey);
    ValidateBucketName(destinationBucket);
    ValidateObjectKey(destinationKey);
 
    await _semaphore.WaitAsync(cancellationToken);
    try
    {
        return await _retryPolicy.ExecuteAsync(async () =>
        {
            _logger.LogDebug("Copying object: {SourceBucket}/{SourceKey} to {DestinationBucket}/{DestinationKey}", 
                sourceBucket, sourceKey, destinationBucket, destinationKey);
 
            var request = new CopyObjectRequest
            {
                SourceBucket = sourceBucket,
                SourceKey = sourceKey,
                DestinationBucket = destinationBucket,
                DestinationKey = destinationKey,
                ServerSideEncryptionMethod = ServerSideEncryptionMethod.AES256
            };
 
            var response = await _s3Client.CopyObjectAsync(request, cancellationToken);
            
            _logger.LogInformation("Object copied successfully: {SourceBucket}/{SourceKey} to {DestinationBucket}/{DestinationKey}", 
                sourceBucket, sourceKey, destinationBucket, destinationKey);
            
            return response.ETag;
        }, cancellationToken);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error copying object: {SourceBucket}/{SourceKey} to {DestinationBucket}/{DestinationKey}", 
            sourceBucket, sourceKey, destinationBucket, destinationKey);
        throw new StorageException($"Failed to copy object: {sourceBucket}/{sourceKey} to {destinationBucket}/{destinationKey}", ex);
    }
    finally
    {
        _semaphore.Release();
    }
}
 
public async Task DeleteObjectAsync(string bucketName, string objectKey, CancellationToken cancellationToken = default)
{
    ValidateBucketName(bucketName);
    ValidateObjectKey(objectKey);
 
    await _semaphore.WaitAsync(cancellationToken);
    try
    {
        await _retryPolicy.ExecuteAsync(async () =>
        {
            _logger.LogDebug("Deleting object: {BucketName}/{ObjectKey}", bucketName, objectKey);
            
            var request = new DeleteObjectRequest
            {
                BucketName = bucketName,
                Key = objectKey
            };
 
            await _s3Client.DeleteObjectAsync(request, cancellationToken);
            _logger.LogInformation("Object deleted successfully: {BucketName}/{ObjectKey}", bucketName, objectKey);
        }, cancellationToken);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error deleting object: {BucketName}/{ObjectKey}", bucketName, objectKey);
        throw new StorageException($"Failed to delete object: {bucketName}/{objectKey}", ex);
    }
    finally
    {
        _semaphore.Release();
    }
}

public async Task<BatchDeleteResult> DeleteObjectsAsync(string bucketName, IEnumerable<string> objectKeys, CancellationToken cancellationToken = default)
{
    ValidateBucketName(bucketName);
    
    var keysList = objectKeys?.ToList() ?? throw new ArgumentNullException(nameof(objectKeys));
    if (!keysList.Any())
        return new BatchDeleteResult { SuccessfulDeletes = new List<string>(), Errors = new List<BatchDeleteError>() };
 
    var successfulDeletes = new List<string>();
    var errors = new List<BatchDeleteError>();
 
    // Обрабатываем батчами по 1000 объектов (лимит S3)
    var batches = keysList.Batch(1000);
    
    foreach (var batch in batches)
    {
        await _semaphore.WaitAsync(cancellationToken);
        try
        {
            await _retryPolicy.ExecuteAsync(async () =>
            {
                var request = new DeleteObjectsRequest
                {
                    BucketName = bucketName,
                    Objects = batch.Select(key => new KeyVersion { Key = key }).ToList()
                };
 
                var response = await _s3Client.DeleteObjectsAsync(request, cancellationToken);
                
                successfulDeletes.AddRange(response.DeletedObjects.Select(d => d.Key));
                errors.AddRange(response.DeleteErrors.Select(e => new BatchDeleteError
                {
                    Key = e.Key,
                    Code = e.Code,
                    Message = e.Message
                }));
            }, cancellationToken);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error in batch delete operation for bucket: {BucketName}", bucketName);
            errors.AddRange(batch.Select(key => new BatchDeleteError
            {
                Key = key,
                Code = "InternalError",
                Message = ex.Message
            }));
        }
        finally
        {
            _semaphore.Release();
        }
    }
 
    return new BatchDeleteResult
    {
        SuccessfulDeletes = successfulDeletes,
        Errors = errors
    };
}

public async Task<PagedResult<StorageObjectInfo>> ListObjectsAsync(string bucketName, string prefix = null, 
    int maxKeys = 1000, string continuationToken = null, CancellationToken cancellationToken = default)
{
    ValidateBucketName(bucketName);
    
    if (maxKeys <= 0 || maxKeys > 1000)
        throw new ArgumentOutOfRangeException(nameof(maxKeys), "MaxKeys must be between 1 and 1000");
 
    await _semaphore.WaitAsync(cancellationToken);
    try
    {
        return await _retryPolicy.ExecuteAsync(async () =>
        {
            _logger.LogDebug("Listing objects in bucket: {BucketName}, prefix: {Prefix}, maxKeys: {MaxKeys}", 
                bucketName, prefix, maxKeys);
 
            var request = new ListObjectsV2Request
            {
                BucketName = bucketName,
                Prefix = prefix,
                MaxKeys = maxKeys,
                ContinuationToken = continuationToken
            };
 
            var response = await _s3Client.ListObjectsV2Async(request, cancellationToken);
            
            var objects = response.S3Objects.Select(obj => new StorageObjectInfo
            {
                Key = obj.Key,
                Size = obj.Size,
                LastModified = obj.LastModified,
                ETag = obj.ETag,
                StorageClass = obj.StorageClass?.Value
            }).ToList();
 
            _logger.LogInformation("Listed {Count} objects in bucket {BucketName}", objects.Count, bucketName);
 
            return new PagedResult<StorageObjectInfo>
            {
                Items = objects,
                IsTruncated = response.IsTruncated,
                NextContinuationToken = response.NextContinuationToken,
                TotalCount = response.KeyCount
            };
        }, cancellationToken);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error listing objects in bucket: {BucketName}", bucketName);
        throw new StorageException($"Failed to list objects in bucket: {bucketName}", ex);
    }
    finally
    {
        _semaphore.Release();
    }
}

public async Task<IEnumerable<ObjectVersion>> ListObjectVersionsAsync(string bucketName, string objectKey, CancellationToken cancellationToken = default)
{
    ValidateBucketName(bucketName);
    ValidateObjectKey(objectKey);
 
    await _semaphore.WaitAsync(cancellationToken);
    try
    {
        return await _retryPolicy.ExecuteAsync(async () =>
        {
            var request = new ListVersionsRequest
            {
                BucketName = bucketName,
                Prefix = objectKey
            };
 
            var response = await _s3Client.ListVersionsAsync(request, cancellationToken);
            
            return response.Versions
                .Where(v => v.Key == objectKey)
                .Select(v => new ObjectVersion
                {
                    Key = v.Key,
                    VersionId = v.VersionId,
                    IsLatest = v.IsLatest,
                    LastModified = v.LastModified,
                    Size = v.Size,
                    ETag = v.ETag
                })
                .OrderByDescending(v => v.LastModified);
        }, cancellationToken);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error listing object versions: {BucketName}/{ObjectKey}", bucketName, objectKey);
        throw new StorageException($"Failed to list object versions: {bucketName}/{objectKey}", ex);
    }
    finally
    {
        _semaphore.Release();
    }
}
 
public async Task<StorageObject> GetObjectVersionAsync(string bucketName, string objectKey, string versionId, CancellationToken cancellationToken = default)
{
    ValidateBucketName(bucketName);
    ValidateObjectKey(objectKey);
    
    if (string.IsNullOrWhiteSpace(versionId))
        throw new ArgumentException("Version ID cannot be null or empty", nameof(versionId));
 
    await _semaphore.WaitAsync(cancellationToken);
    try
    {
        return await _retryPolicy.ExecuteAsync(async () =>
        {
            var request = new GetObjectRequest
            {
                BucketName = bucketName,
                Key = objectKey,
                VersionId = versionId
            };
 
            var response = await _s3Client.GetObjectAsync(request, cancellationToken);
            
            return new StorageObject
            {
                BucketName = bucketName,
                Key = objectKey,
                VersionId = versionId,
                Content = response.ResponseStream,
                Metadata = new ObjectMetadata
                {
                    ContentType = response.Headers.ContentType,
                    ContentLength = response.Headers.ContentLength,
                    LastModified = response.LastModified,
                    ETag = response.ETag
                }
            };
        }, cancellationToken);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error getting object version: {BucketName}/{ObjectKey}, version: {VersionId}", 
            bucketName, objectKey, versionId);
        throw new StorageException($"Failed to get object version: {bucketName}/{objectKey}", ex);
    }
    finally
    {
        _semaphore.Release();
    }
}

public void Dispose()
{
    Dispose(true);
    GC.SuppressFinalize(this);
}
 
protected virtual void Dispose(bool disposing)
{
    if (!_disposed)
    {
        if (disposing)
        {
            _semaphore?.Dispose();
            _s3Client?.Dispose();
        }
        _disposed = true;
    }
}

public async Task<PagedResult<StorageObjectInfo>> ListObjectsWithFilterAsync(string bucketName, 
    ObjectFilter filter, CancellationToken cancellationToken = default)
{
    ValidateBucketName(bucketName);
    
    if (filter == null)
        throw new ArgumentNullException(nameof(filter));
 
    await _semaphore.WaitAsync(cancellationToken);
    try
    {
        return await _retryPolicy.ExecuteAsync(async () =>
        {
            var allObjects = new List<StorageObjectInfo>();
            string continuationToken = null;
            
            do
            {
                var request = new ListObjectsV2Request
                {
                    BucketName = bucketName,
                    Prefix = filter.Prefix,
                    MaxKeys = 1000,
                    ContinuationToken = continuationToken
                };
 
                var response = await _s3Client.ListObjectsV2Async(request, cancellationToken);
                
                var filteredObjects = response.S3Objects
                    .Where(obj => ApplyObjectFilter(obj, filter))
                    .Select(obj => new StorageObjectInfo
                    {
                        Key = obj.Key,
                        Size = obj.Size,
                        LastModified = obj.LastModified,
                        ETag = obj.ETag,
                        StorageClass = obj.StorageClass?.Value
                    });
 
                allObjects.AddRange(filteredObjects);
                continuationToken = response.NextContinuationToken;
                
            } while (continuationToken != null && allObjects.Count < filter.MaxResults);
 
            var sortedObjects = ApplySorting(allObjects, filter.SortBy, filter.SortDirection);
            var pagedObjects = sortedObjects.Skip(filter.Skip).Take(filter.MaxResults).ToList();
 
            return new PagedResult<StorageObjectInfo>
            {
                Items = pagedObjects,
                IsTruncated = sortedObjects.Count() > filter.Skip + filter.MaxResults,
                TotalCount = allObjects.Count
            };
        }, cancellationToken);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error filtering objects in bucket: {BucketName}", bucketName);
        throw new StorageException($"Failed to filter objects in bucket: {bucketName}", ex);
    }
    finally
    {
        _semaphore.Release();
    }
}
 
private bool ApplyObjectFilter(S3Object obj, ObjectFilter filter)
{
    if (filter.MinSize.HasValue && obj.Size < filter.MinSize.Value)
        return false;
    
    if (filter.MaxSize.HasValue && obj.Size > filter.MaxSize.Value)
        return false;
    
    if (filter.ModifiedAfter.HasValue && obj.LastModified < filter.ModifiedAfter.Value)
        return false;
    
    if (filter.ModifiedBefore.HasValue && obj.LastModified > filter.ModifiedBefore.Value)
        return false;
    
    if (filter.FileExtensions?.Any() == true)
    {
        var extension = Path.GetExtension(obj.Key)?.ToLowerInvariant();
        if (!filter.FileExtensions.Contains(extension))
            return false;
    }
 
    return true;
}
 
private IEnumerable<StorageObjectInfo> ApplySorting(IEnumerable<StorageObjectInfo> objects, 
    SortBy sortBy, SortDirection direction)
{
    var query = sortBy switch
    {
        SortBy.Name => direction == SortDirection.Ascending ? 
            objects.OrderBy(o => o.Key) : objects.OrderByDescending(o => o.Key),
        SortBy.Size => direction == SortDirection.Ascending ? 
            objects.OrderBy(o => o.Size) : objects.OrderByDescending(o => o.Size),
        SortBy.LastModified => direction == SortDirection.Ascending ? 
            objects.OrderBy(o => o.LastModified) : objects.OrderByDescending(o => o.LastModified),
        _ => objects.OrderBy(o => o.Key)
    };
    
    return query;
}

public async Task<bool> VerifyObjectIntegrityAsync(string bucketName, string objectKey, 
    string expectedHash, HashAlgorithmType hashType = HashAlgorithmType.MD5, 
    CancellationToken cancellationToken = default)
{
    ValidateBucketName(bucketName);
    ValidateObjectKey(objectKey);
    
    if (string.IsNullOrWhiteSpace(expectedHash))
        throw new ArgumentException("Expected hash cannot be null or empty", nameof(expectedHash));
 
    await _semaphore.WaitAsync(cancellationToken);
    try
    {
        return await _retryPolicy.ExecuteAsync(async () =>
        {
            using var storageObject = await GetObjectAsync(bucketName, objectKey, cancellationToken);
            using var hashAlgorithm = CreateHashAlgorithm(hashType);
            
            var computedHash = await ComputeHashAsync(storageObject.Content, hashAlgorithm, cancellationToken);
            var isValid = string.Equals(computedHash, expectedHash, StringComparison.OrdinalIgnoreCase);
            
            _logger.LogInformation("Integrity check for {BucketName}/{ObjectKey}: {Result}", 
                bucketName, objectKey, isValid ? "VALID" : "INVALID");
            
            return isValid;
        }, cancellationToken);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error verifying object integrity: {BucketName}/{ObjectKey}", bucketName, objectKey);
        throw new StorageException($"Failed to verify object integrity: {bucketName}/{objectKey}", ex);
    }
    finally
    {
        _semaphore.Release();
    }
}
 
private HashAlgorithm CreateHashAlgorithm(HashAlgorithmType hashType)
{
    return hashType switch
    {
        HashAlgorithmType.MD5 => MD5.Create(),
        HashAlgorithmType.SHA1 => SHA1.Create(),
        HashAlgorithmType.SHA256 => SHA256.Create(),
        HashAlgorithmType.SHA512 => SHA512.Create(),
        _ => throw new NotSupportedException($"Hash algorithm {hashType} is not supported")
    };
}
 
private async Task<string> ComputeHashAsync(Stream stream, HashAlgorithm hashAlgorithm, CancellationToken cancellationToken)
{
    const int bufferSize = 8192;
    var buffer = new byte[bufferSize];
    int bytesRead;
    
    while ((bytesRead = await stream.ReadAsync(buffer, 0, bufferSize, cancellationToken)) > 0)
    {
        hashAlgorithm.TransformBlock(buffer, 0, bytesRead, null, 0);
    }
    
    hashAlgorithm.TransformFinalBlock(new byte[0], 0, 0);
    return Convert.ToBase64String(hashAlgorithm.Hash);
}

public async Task<string> GeneratePresignedUrlAsync(string bucketName, string objectKey, 
    TimeSpan expiration, HttpVerb httpVerb = HttpVerb.GET, CancellationToken cancellationToken = default)
{
    ValidateBucketName(bucketName);
    ValidateObjectKey(objectKey);
    
    if (expiration <= TimeSpan.Zero)
        throw new ArgumentException("Expiration must be positive", nameof(expiration));
    
    if (expiration > TimeSpan.FromDays(7))
        throw new ArgumentException("Expiration cannot exceed 7 days", nameof(expiration));
 
    await _semaphore.WaitAsync(cancellationToken);
    try
    {
        return await _retryPolicy.ExecuteAsync(async () =>
        {
            var request = new GetPreSignedUrlRequest
            {
                BucketName = bucketName,
                Key = objectKey,
                Expires = DateTime.UtcNow.Add(expiration),
                Verb = httpVerb
            };
 
            var presignedUrl = await _s3Client.GetPreSignedURLAsync(request);
            
            _logger.LogDebug("Generated presigned URL for {BucketName}/{ObjectKey}, expires in {Expiration}", 
                bucketName, objectKey, expiration);
            
            return presignedUrl;
        }, cancellationToken);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error generating presigned URL: {BucketName}/{ObjectKey}", bucketName, objectKey);
        throw new StorageException($"Failed to generate presigned URL: {bucketName}/{objectKey}", ex);
    }
    finally
    {
        _semaphore.Release();
    }
}

public async Task<StorageStatistics> GetStorageStatisticsAsync(string bucketName, string prefix = null, 
    CancellationToken cancellationToken = default)
{
    ValidateBucketName(bucketName);
 
    await _semaphore.WaitAsync(cancellationToken);
    try
    {
        return await _retryPolicy.ExecuteAsync(async () =>
        {
            var statistics = new StorageStatistics
            {
                BucketName = bucketName,
                Prefix = prefix,
                GeneratedAt = DateTime.UtcNow
            };
 
            var allObjects = new List<S3Object>();
            string continuationToken = null;
            
            do
            {
                var request = new ListObjectsV2Request
                {
                    BucketName = bucketName,
                    Prefix = prefix,
                    MaxKeys = 1000,
                    ContinuationToken = continuationToken
                };
 
                var response = await _s3Client.ListObjectsV2Async(request, cancellationToken);
                allObjects.AddRange(response.S3Objects);
                continuationToken = response.NextContinuationToken;
                
            } while (continuationToken != null);
 
            statistics.TotalObjects = allObjects.Count;
            statistics.TotalSize = allObjects.Sum(obj => obj.Size);
            statistics.AverageObjectSize = statistics.TotalObjects > 0 ? 
                statistics.TotalSize / statistics.TotalObjects : 0;
 
            var groupedByExtension = allObjects
                .GroupBy(obj => Path.GetExtension(obj.Key)?.ToLowerInvariant() ?? "no-extension")
                .Select(g => new FileTypeStatistics
                {
                    Extension = g.Key,
                    Count = g.Count(),
                    TotalSize = g.Sum(obj => obj.Size)
                })
                .OrderByDescending(stat => stat.TotalSize);
 
            statistics.FileTypeStatistics = groupedByExtension.ToList();
 
            _logger.LogInformation("Storage statistics for {BucketName}: {TotalObjects} objects, {TotalSize} bytes", 
                bucketName, statistics.TotalObjects, statistics.TotalSize);
 
            return statistics;
        }, cancellationToken);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error getting storage statistics: {BucketName}", bucketName);
        throw new StorageException($"Failed to get storage statistics: {bucketName}", ex);
    }
    finally
    {
        _semaphore.Release();
    }
}

public class StreamingObjectProcessor : IStreamingObjectProcessor
{
    private readonly IAmazonS3 _s3Client;
    private readonly ILogger<StreamingObjectProcessor> _logger;
    private readonly int _bufferSize;
 
    public StreamingObjectProcessor(IAmazonS3 s3Client, ILogger<StreamingObjectProcessor> logger, int bufferSize = 1024 * 1024)
    {
        _s3Client = s3Client;
        _logger = logger;
        _bufferSize = bufferSize;
    }
 
    public async Task ProcessObjectStreamAsync(string bucketName, string objectKey, 
        Func<Stream, Task> processor, CancellationToken cancellationToken = default)
    {
        using var response = await _s3Client.GetObjectAsync(bucketName, objectKey, cancellationToken);
        
        var bufferedStream = new BufferedStream(response.ResponseStream, _bufferSize);
        await processor(bufferedStream);
    }
 
    public async Task<string> UploadStreamAsync(string bucketName, string objectKey, 
        Stream sourceStream, IProgress<long> progress = null, CancellationToken cancellationToken = default)
    {
        var request = new PutObjectRequest
        {
            BucketName = bucketName,
            Key = objectKey,
            InputStream = sourceStream,
            UseChunkEncoding = true
        };
 
        if (progress != null)
        {
            request.StreamTransferProgress += (sender, args) =>
            {
                progress.Report(args.TransferredBytes);
            };
        }
 
        var response = await _s3Client.PutObjectAsync(request, cancellationToken);
        return response.ETag;
    }
}

public class MultipartUploadManager : IMultipartUploadManager
{
    private readonly IAmazonS3 _s3Client;
    private readonly ILogger<MultipartUploadManager> _logger;
    private readonly int _partSize;
    private readonly int _maxConcurrency;
 
    public MultipartUploadManager(IAmazonS3 s3Client, ILogger<MultipartUploadManager> logger, 
        int partSize = 5 * 1024 * 1024, int maxConcurrency = 3)
    {
        _s3Client = s3Client;
        _logger = logger;
        _partSize = partSize;
        _maxConcurrency = maxConcurrency;
    }
 
    public async Task<string> UploadLargeFileAsync(string bucketName, string objectKey, 
        Stream fileStream, IProgress<MultipartUploadProgress> progress = null, 
        CancellationToken cancellationToken = default)
    {
        var initiateRequest = new InitiateMultipartUploadRequest
        {
            BucketName = bucketName,
            Key = objectKey
        };
 
        var initiateResponse = await _s3Client.InitiateMultipartUploadAsync(initiateRequest, cancellationToken);
        var uploadId = initiateResponse.UploadId;
 
        try
        {
            var uploadTasks = new List<Task<UploadPartResponse>>();
            var completedParts = new List<PartETag>();
            var partNumber = 1;
            var totalParts = (int)Math.Ceiling((double)fileStream.Length / _partSize);
 
            var semaphore = new SemaphoreSlim(_maxConcurrency);
 
            while (fileStream.Position < fileStream.Length)
            {
                var currentPartSize = Math.Min(_partSize, (int)(fileStream.Length - fileStream.Position));
                var partData = new byte[currentPartSize];
                await fileStream.ReadAsync(partData, 0, currentPartSize, cancellationToken);
 
                var currentPartNumber = partNumber++;
                
                await semaphore.WaitAsync(cancellationToken);
                
                var uploadTask = Task.Run(async () =>
                {
                    try
                    {
                        using var partStream = new MemoryStream(partData);
                        var uploadRequest = new UploadPartRequest
                        {
                            BucketName = bucketName,
                            Key = objectKey,
                            UploadId = uploadId,
                            PartNumber = currentPartNumber,
                            InputStream = partStream,
                            PartSize = currentPartSize
                        };
 
                        var uploadResponse = await _s3Client.UploadPartAsync(uploadRequest, cancellationToken);
                        
                        progress?.Report(new MultipartUploadProgress
                        {
                            PartNumber = currentPartNumber,
                            TotalParts = totalParts,
                            BytesUploaded = currentPartNumber * _partSize
                        });
 
                        return uploadResponse;
                    }
                    finally
                    {
                        semaphore.Release();
                    }
                }, cancellationToken);
 
                uploadTasks.Add(uploadTask);
            }
 
            var uploadResults = await Task.WhenAll(uploadTasks);
            completedParts.AddRange(uploadResults.Select(r => new PartETag(r.PartNumber, r.ETag)));
 
            var completeRequest = new CompleteMultipartUploadRequest
            {
                BucketName = bucketName,
                Key = objectKey,
                UploadId = uploadId,
                PartETags = completedParts.OrderBy(p => p.PartNumber).ToList()
            };
 
            var completeResponse = await _s3Client.CompleteMultipartUploadAsync(completeRequest, cancellationToken);
            return completeResponse.ETag;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Multipart upload failed, aborting upload {UploadId}", uploadId);
            await _s3Client.AbortMultipartUploadAsync(bucketName, objectKey, uploadId, cancellationToken);
            throw;
        }
    }
}

public class OptimizedS3ClientFactory : IS3ClientFactory
{
    private readonly IConfiguration _configuration;
    private readonly IConnectionPool _connectionPool;
 
    public OptimizedS3ClientFactory(IConfiguration configuration, IConnectionPool connectionPool)
    {
        _configuration = configuration;
        _connectionPool = connectionPool;
    }
 
    public IAmazonS3 CreateClient()
    {
        var httpClientHandler = new HttpClientHandler()
        {
            MaxConnectionsPerServer = _configuration.GetValue<int>("S3:MaxConnectionsPerServer", 50),
            UseCookies = false,
            UseProxy = false
        };
 
        var httpClient = new HttpClient(httpClientHandler)
        {
            Timeout = TimeSpan.FromSeconds(_configuration.GetValue<int>("S3:HttpTimeoutSeconds", 300))
        };
 
        var config = new AmazonS3Config
        {
            ServiceURL = _configuration["S3:ServiceUrl"],
            ForcePathStyle = true,
            UseHttp = true,
            MaxErrorRetry = 3,
            HttpClient = httpClient,
            BufferSize = _configuration.GetValue<int>("S3:BufferSize", 8192),
            MaxConnectionsPerServer = _configuration.GetValue<int>("S3:MaxConnectionsPerServer", 50)
        };
 
        return new AmazonS3Client(_configuration["S3:AccessKey"], _configuration["S3:SecretKey"], config);
    }
}

public class CompressingStorageAdapter : IStorageAdapter
{
    private readonly IStorageAdapter _baseAdapter;
    private readonly ICompressionService _compressionService;
 
    public CompressingStorageAdapter(IStorageAdapter baseAdapter, ICompressionService compressionService)
    {
        _baseAdapter = baseAdapter;
        _compressionService = compressionService;
    }
 
    public async Task<string> PutObjectAsync(string bucketName, string objectKey, Stream content, 
        ObjectMetadata metadata = null, CancellationToken cancellationToken = default)
    {
        var shouldCompress = ShouldCompressContent(metadata?.ContentType, content.Length);
        
        if (shouldCompress)
        {
            using var compressedStream = await _compressionService.CompressAsync(content, cancellationToken);
            
            if (metadata == null)
                metadata = new ObjectMetadata();
            
            metadata.CustomMetadata["compression"] = "gzip";
            metadata.CustomMetadata["original-size"] = content.Length.ToString();
            
            return await _baseAdapter.PutObjectAsync(bucketName, objectKey, compressedStream, metadata, cancellationToken);
        }
 
        return await _baseAdapter.PutObjectAsync(bucketName, objectKey, content, metadata, cancellationToken);
    }
 
    public async Task<StorageObject> GetObjectAsync(string bucketName, string objectKey, CancellationToken cancellationToken = default)
    {
        var storageObject = await _baseAdapter.GetObjectAsync(bucketName, objectKey, cancellationToken);
        
        if (storageObject.Metadata?.CustomMetadata?.ContainsKey("compression") == true)
        {
            var decompressedStream = await _compressionService.DecompressAsync(storageObject.Content, cancellationToken);
            
            return new StorageObject
            {
                BucketName = storageObject.BucketName,
                Key = storageObject.Key,
                Content = decompressedStream,
                Metadata = storageObject.Metadata
            };
        }
 
        return storageObject;
    }
 
    private bool ShouldCompressContent(string contentType, long contentLength)
    {
        if (contentLength < 1024) return false; // Не сжимаем маленькие файлы
        
        var compressibleTypes = new[] { "text/", "application/json", "application/xml", "application/javascript" };
        return compressibleTypes.Any(type => contentType?.StartsWith(type, StringComparison.OrdinalIgnoreCase) == true);
    }
}

public class ResilientRetryPolicy : IRetryPolicy
{
    private readonly ILogger<ResilientRetryPolicy> _logger;
    private readonly CircuitBreakerPolicy _circuitBreaker;
    private readonly RetryPolicy _retryPolicy;
 
    public ResilientRetryPolicy(ILogger<ResilientRetryPolicy> logger)
    {
        _logger = logger;
        
        _retryPolicy = Policy
            .Handle<AmazonS3Exception>(ex => IsRetriableException(ex))
            .Or<TaskCanceledException>()
            .Or<TimeoutException>()
            .WaitAndRetryAsync(
                retryCount: 3,
                sleepDurationProvider: retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)) + TimeSpan.FromMilliseconds(new Random().Next(0, 1000)),
                onRetry: (outcome, timespan, retryCount, context) =>
                {
                    _logger.LogWarning("Retry attempt {RetryCount} after {Delay}ms: {Exception}", 
                        retryCount, timespan.TotalMilliseconds, outcome.Exception?.Message);
                });
 
        _circuitBreaker = Policy
            .Handle<AmazonS3Exception>()
            .CircuitBreakerAsync(
                handledEventsAllowedBeforeBreaking: 5,
                durationOfBreak: TimeSpan.FromSeconds(30),
                onBreak: (exception, timespan) =>
                {
                    _logger.LogError("Circuit breaker opened for {Duration}s: {Exception}", 
                        timespan.TotalSeconds, exception.Message);
                },
                onReset: () =>
                {
                    _logger.LogInformation("Circuit breaker reset");
                });
    }
 
    public async Task<T> ExecuteAsync<T>(Func<Task<T>> action, CancellationToken cancellationToken = default)
    {
        var policy = Policy.WrapAsync(_retryPolicy, _circuitBreaker);
        return await policy.ExecuteAsync(action);
    }
 
    private bool IsRetriableException(AmazonS3Exception ex)
    {
        return ex.StatusCode == HttpStatusCode.InternalServerError ||
               ex.StatusCode == HttpStatusCode.BadGateway ||
               ex.StatusCode == HttpStatusCode.ServiceUnavailable ||
               ex.StatusCode == HttpStatusCode.GatewayTimeout ||
               ex.ErrorCode == "RequestTimeout" ||
               ex.ErrorCode == "SlowDown";
    }
}

public class InstrumentedStorageAdapter : IStorageAdapter
{
    private readonly IStorageAdapter _baseAdapter;
    private readonly IMetricsCollector _metricsCollector;
    private readonly ILogger<InstrumentedStorageAdapter> _logger;
 
    public InstrumentedStorageAdapter(IStorageAdapter baseAdapter, IMetricsCollector metricsCollector, ILogger<InstrumentedStorageAdapter> logger)
    {
        _baseAdapter = baseAdapter;
        _metricsCollector = metricsCollector;
        _logger = logger;
    }
 
    public async Task<string> PutObjectAsync(string bucketName, string objectKey, Stream content, 
        ObjectMetadata metadata = null, CancellationToken cancellationToken = default)
    {
        var correlationId = Guid.NewGuid().ToString();
        var stopwatch = Stopwatch.StartNew();
        
        using var activity = Activity.Current?.Source.StartActivity("S3.PutObject");
        activity?.SetTag("bucket.name", bucketName);
        activity?.SetTag("object.key", objectKey);
        activity?.SetTag("correlation.id", correlationId);
 
        try
        {
            _logger.LogInformation("Starting upload {CorrelationId}: {BucketName}/{ObjectKey}", 
                correlationId, bucketName, objectKey);
 
            var result = await _baseAdapter.PutObjectAsync(bucketName, objectKey, content, metadata, cancellationToken);
            
            stopwatch.Stop();
            _metricsCollector.RecordOperationDuration("put_object", stopwatch.Elapsed);
            _metricsCollector.IncrementCounter("operations_total", ("operation", "put_object"), ("status", "success"));
            
            _logger.LogInformation("Upload completed {CorrelationId}: {BucketName}/{ObjectKey} in {Duration}ms", 
                correlationId, bucketName, objectKey, stopwatch.ElapsedMilliseconds);
 
            return result;
        }
        catch (Exception ex)
        {
            stopwatch.Stop();
            _metricsCollector.IncrementCounter("operations_total", ("operation", "put_object"), ("status", "error"));
            _metricsCollector.RecordOperationDuration("put_object_error", stopwatch.Elapsed);
            
            _logger.LogError(ex, "Upload failed {CorrelationId}: {BucketName}/{ObjectKey} after {Duration}ms", 
                correlationId, bucketName, objectKey, stopwatch.ElapsedMilliseconds);
 
            throw;
        }
    }
}

public class CachingStorageAdapter : IStorageAdapter
{
    private readonly IStorageAdapter _baseAdapter;
    private readonly IDistributedCache _cache;
    private readonly ILogger<CachingStorageAdapter> _logger;
    private readonly TimeSpan _defaultCacheDuration = TimeSpan.FromMinutes(15);
 
    public CachingStorageAdapter(IStorageAdapter baseAdapter, IDistributedCache cache, ILogger<CachingStorageAdapter> logger)
    {
        _baseAdapter = baseAdapter;
        _cache = cache;
        _logger = logger;
    }
 
    public async Task<ObjectMetadata> GetObjectMetadataAsync(string bucketName, string objectKey, CancellationToken cancellationToken = default)
    {
        var cacheKey = $"metadata:{bucketName}:{objectKey}";
        
        var cachedMetadata = await _cache.GetAsync(cacheKey, cancellationToken);
        if (cachedMetadata != null)
        {
            _logger.LogDebug("Metadata cache hit for {BucketName}/{ObjectKey}", bucketName, objectKey);
            return JsonSerializer.Deserialize<ObjectMetadata>(cachedMetadata);
        }
 
        var metadata = await _baseAdapter.GetObjectMetadataAsync(bucketName, objectKey, cancellationToken);
        
        var serializedMetadata = JsonSerializer.SerializeToUtf8Bytes(metadata);
        var cacheOptions = new DistributedCacheEntryOptions
        {
            AbsoluteExpirationRelativeToNow = _defaultCacheDuration
        };
        
        await _cache.SetAsync(cacheKey, serializedMetadata, cacheOptions, cancellationToken);
        _logger.LogDebug("Metadata cached for {BucketName}/{ObjectKey}", bucketName, objectKey);
 
        return metadata;
    }
 
    public async Task DeleteObjectAsync(string bucketName, string objectKey, CancellationToken cancellationToken = default)
    {
        await _baseAdapter.DeleteObjectAsync(bucketName, objectKey, cancellationToken);
        
        // Инвалидируем кеш после удаления
        var cacheKey = $"metadata:{bucketName}:{objectKey}";
        await _cache.RemoveAsync(cacheKey, cancellationToken);
    }
}

public class EventDrivenStorageAdapter : IStorageAdapter
{
    private readonly IStorageAdapter _baseAdapter;
    private readonly IEventPublisher _eventPublisher;
    private readonly ILogger<EventDrivenStorageAdapter> _logger;
 
    public EventDrivenStorageAdapter(IStorageAdapter baseAdapter, IEventPublisher eventPublisher, ILogger<EventDrivenStorageAdapter> logger)
    {
        _baseAdapter = baseAdapter;
        _eventPublisher = eventPublisher;
        _logger = logger;
    }
 
    public async Task<string> PutObjectAsync(string bucketName, string objectKey, Stream content, 
        ObjectMetadata metadata = null, CancellationToken cancellationToken = default)
    {
        var etag = await _baseAdapter.PutObjectAsync(bucketName, objectKey, content, metadata, cancellationToken);
        
        var objectEvent = new S3ObjectEvent
        {
            EventType = S3EventType.ObjectCreated,
            BucketName = bucketName,
            ObjectKey = objectKey,
            ETag = etag,
            Timestamp = DateTime.UtcNow,
            ObjectSize = content.Length
        };
 
        await _eventPublisher.PublishAsync(objectEvent, cancellationToken);
        return etag;
    }
 
    public async Task DeleteObjectAsync(string bucketName, string objectKey, CancellationToken cancellationToken = default)
    {
        await _baseAdapter.DeleteObjectAsync(bucketName, objectKey, cancellationToken);
        
        var deleteEvent = new S3ObjectEvent
        {
            EventType = S3EventType.ObjectDeleted,
            BucketName = bucketName,
            ObjectKey = objectKey,
            Timestamp = DateTime.UtcNow
        };
 
        await _eventPublisher.PublishAsync(deleteEvent, cancellationToken);
    }
}

public class TransactionalStorageUnitOfWork : IStorageUnitOfWork
{
    private readonly IStorageAdapter _adapter;
    private readonly List<IStorageOperation> _operations;
    private readonly List<ICompensationAction> _compensationActions;
    private readonly ILogger<TransactionalStorageUnitOfWork> _logger;
 
    public TransactionalStorageUnitOfWork(IStorageAdapter adapter, ILogger<TransactionalStorageUnitOfWork> logger)
    {
        _adapter = adapter;
        _operations = new List<IStorageOperation>();
        _compensationActions = new List<ICompensationAction>();
        _logger = logger;
    }
 
    public void AddOperation(IStorageOperation operation)
    {
        _operations.Add(operation);
    }
 
    public async Task<TransactionResult> CommitAsync(CancellationToken cancellationToken = default)
    {
        var executedOperations = new List<IStorageOperation>();
        
        try
        {
            foreach (var operation in _operations)
            {
                await operation.ExecuteAsync(_adapter, cancellationToken);
                executedOperations.Add(operation);
                
                var compensationAction = operation.CreateCompensationAction();
                if (compensationAction != null)
                {
                    _compensationActions.Insert(0, compensationAction); // LIFO порядок для компенсации
                }
            }
 
            return new TransactionResult { IsSuccess = true, ExecutedOperations = executedOperations.Count };
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Transaction failed, executing compensation actions");
            
            await ExecuteCompensationAsync(cancellationToken);
            
            return new TransactionResult 
            { 
                IsSuccess = false, 
                ExecutedOperations = executedOperations.Count,
                Error = ex.Message
            };
        }
    }
 
    private async Task ExecuteCompensationAsync(CancellationToken cancellationToken)
    {
        foreach (var compensationAction in _compensationActions)
        {
            try
            {
                await compensationAction.ExecuteAsync(_adapter, cancellationToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Compensation action failed: {ActionType}", compensationAction.GetType().Name);
            }
        }
    }
}

public class MemoryOptimizedStorageAdapter : IStorageAdapter
{
    private readonly IStorageAdapter _baseAdapter;
    private readonly ArrayPool<byte> _arrayPool;
    private readonly ILogger<MemoryOptimizedStorageAdapter> _logger;
 
    public MemoryOptimizedStorageAdapter(IStorageAdapter baseAdapter, ILogger<MemoryOptimizedStorageAdapter> logger)
    {
        _baseAdapter = baseAdapter;
        _arrayPool = ArrayPool<byte>.Shared;
        _logger = logger;
    }
 
    public async Task<string> PutObjectAsync(string bucketName, string objectKey, Stream content, 
        ObjectMetadata metadata = null, CancellationToken cancellationToken = default)
    {
        const int bufferSize = 81920; // 80KB buffer
        var buffer = _arrayPool.Rent(bufferSize);
        
        try
        {
            using var bufferedStream = new BufferedStream(content, bufferSize);
            var memoryStream = new MemoryStream();
            
            int bytesRead;
            while ((bytesRead = await bufferedStream.ReadAsync(buffer, 0, bufferSize, cancellationToken)) > 0)
            {
                await memoryStream.WriteAsync(buffer, 0, bytesRead, cancellationToken);
            }
            
            memoryStream.Position = 0;
            return await _baseAdapter.PutObjectAsync(bucketName, objectKey, memoryStream, metadata, cancellationToken);
        }
        finally
        {
            _arrayPool.Return(buffer);
        }
    }
 
    public async Task<StorageObject> GetObjectAsync(string bucketName, string objectKey, CancellationToken cancellationToken = default)
    {
        var storageObject = await _baseAdapter.GetObjectAsync(bucketName, objectKey, cancellationToken);
        
        // Оборачиваем поток в оптимизированный буферизованный поток
        var optimizedStream = new PooledBufferedStream(storageObject.Content, _arrayPool);
        
        return new StorageObject
        {
            BucketName = storageObject.BucketName,
            Key = storageObject.Key,
            Content = optimizedStream,
            Metadata = storageObject.Metadata
        };
    }
}

public class TelemetryStorageAdapter : IStorageAdapter
{
    private readonly IStorageAdapter _baseAdapter;
    private readonly IMeterFactory _meterFactory;
    private readonly Meter _meter;
    private readonly Counter<long> _operationCounter;
    private readonly Histogram<double> _operationDuration;
    private readonly Histogram<long> _objectSize;
 
    public TelemetryStorageAdapter(IStorageAdapter baseAdapter, IMeterFactory meterFactory)
    {
        _baseAdapter = baseAdapter;
        _meterFactory = meterFactory;
        _meter = _meterFactory.Create("S3Adapter");
        
        _operationCounter = _meter.CreateCounter<long>("s3_operations_total", "operations", "Total number of S3 operations");
        _operationDuration = _meter.CreateHistogram<double>("s3_operation_duration", "seconds", "Duration of S3 operations");
        _objectSize = _meter.CreateHistogram<long>("s3_object_size", "bytes", "Size of S3 objects");
    }
 
    public async Task<string> PutObjectAsync(string bucketName, string objectKey, Stream content, 
        ObjectMetadata metadata = null, CancellationToken cancellationToken = default)
    {
        var stopwatch = Stopwatch.StartNew();
        var objectSize = content.Length;
        
        try
        {
            var result = await _baseAdapter.PutObjectAsync(bucketName, objectKey, content, metadata, cancellationToken);
            
            _operationCounter.Add(1, new KeyValuePair<string, object?>("operation", "put_object"), 
                new KeyValuePair<string, object?>("status", "success"));
            
            return result;
        }
        catch (Exception)
        {
            _operationCounter.Add(1, new KeyValuePair<string, object?>("operation", "put_object"), 
                new KeyValuePair<string, object?>("status", "error"));
            throw;
        }
        finally
        {
            stopwatch.Stop();
            _operationDuration.Record(stopwatch.Elapsed.TotalSeconds, 
                new KeyValuePair<string, object?>("operation", "put_object"));
            _objectSize.Record(objectSize, new KeyValuePair<string, object?>("operation", "put_object"));
        }
    }
}

public class AdaptiveStorageAdapter : IStorageAdapter
{
    private readonly IStorageAdapter _baseAdapter;
    private readonly IPerformanceMonitor _performanceMonitor;
    private readonly ILogger<AdaptiveStorageAdapter> _logger;
    private TimeSpan _currentTimeout = TimeSpan.FromSeconds(30);
    private int _currentRetryCount = 3;
 
    public AdaptiveStorageAdapter(IStorageAdapter baseAdapter, IPerformanceMonitor performanceMonitor, ILogger<AdaptiveStorageAdapter> logger)
    {
        _baseAdapter = baseAdapter;
        _performanceMonitor = performanceMonitor;
        _logger = logger;
    }
 
    public async Task<string> PutObjectAsync(string bucketName, string objectKey, Stream content, 
        ObjectMetadata metadata = null, CancellationToken cancellationToken = default)
    {
        var metrics = _performanceMonitor.GetCurrentMetrics();
        AdjustParameters(metrics);
 
        using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
        timeoutCts.CancelAfter(_currentTimeout);
 
        try
        {
            var result = await ExecuteWithAdaptiveRetry(
                () => _baseAdapter.PutObjectAsync(bucketName, objectKey, content, metadata, timeoutCts.Token),
                _currentRetryCount
            );
 
            _performanceMonitor.RecordSuccess(_currentTimeout);
            return result;
        }
        catch (OperationCanceledException) when (timeoutCts.Token.IsCancellationRequested)
        {
            _performanceMonitor.RecordTimeout(_currentTimeout);
            throw new TimeoutException($"Operation timed out after {_currentTimeout.TotalSeconds} seconds");
        }
    }
 
    private void AdjustParameters(PerformanceMetrics metrics)
    {
        if (metrics.AverageResponseTime > TimeSpan.FromSeconds(20))
        {
            _currentTimeout = TimeSpan.FromSeconds(Math.Min(120, _currentTimeout.TotalSeconds * 1.5));
            _currentRetryCount = Math.Max(1, _currentRetryCount - 1);
        }
        else if (metrics.AverageResponseTime < TimeSpan.FromSeconds(5))
        {
            _currentTimeout = TimeSpan.FromSeconds(Math.Max(15, _currentTimeout.TotalSeconds * 0.8));
            _currentRetryCount = Math.Min(5, _currentRetryCount + 1);
        }
 
        _logger.LogDebug("Adjusted parameters: timeout={Timeout}s, retries={Retries}", 
            _currentTimeout.TotalSeconds, _currentRetryCount);
    }
 
    private async Task<T> ExecuteWithAdaptiveRetry<T>(Func<Task<T>> operation, int maxRetries)
    {
        for (int attempt = 0; attempt <= maxRetries; attempt++)
        {
            try
            {
                return await operation();
            }
            catch (Exception ex) when (attempt < maxRetries && IsRetriableException(ex))
            {
                var delay = TimeSpan.FromMilliseconds(Math.Pow(2, attempt) * 1000);
                _logger.LogWarning("Retry attempt {Attempt} after {Delay}ms: {Error}", 
                    attempt + 1, delay.TotalMilliseconds, ex.Message);
                await Task.Delay(delay);
            }
        }
 
        throw new InvalidOperationException("Should not reach here");
    }
 
    private bool IsRetriableException(Exception ex)
    {
        return ex is TimeoutException || 
               ex is TaskCanceledException ||
               (ex is AmazonS3Exception s3Ex && s3Ex.StatusCode >= HttpStatusCode.InternalServerError);
    }
}

public class PrewarmedStorageAdapter : IStorageAdapter, IHostedService
{
    private readonly IStorageAdapter _baseAdapter;
    private readonly IConfiguration _configuration;
    private readonly ILogger<PrewarmedStorageAdapter> _logger;
    private readonly Timer _healthCheckTimer;
 
    public PrewarmedStorageAdapter(IStorageAdapter baseAdapter, IConfiguration configuration, ILogger<PrewarmedStorageAdapter> logger)
    {
        _baseAdapter = baseAdapter;
        _configuration = configuration;
        _logger = logger;
        _healthCheckTimer = new Timer(PerformHealthCheck, null, Timeout.Infinite, Timeout.Infinite);
    }
 
    public async Task StartAsync(CancellationToken cancellationToken)
    {
        await PrewarmConnections(cancellationToken);
        _healthCheckTimer.Change(TimeSpan.Zero, TimeSpan.FromMinutes(5));
    }
 
    public async Task StopAsync(CancellationToken cancellationToken)
    {
        _healthCheckTimer.Change(Timeout.Infinite, Timeout.Infinite);
    }
 
    private async Task PrewarmConnections(CancellationToken cancellationToken)
    {
        var prewarmBucket = _configuration["S3:PrewarmBucket"];
        if (string.IsNullOrEmpty(prewarmBucket))
        {
            _logger.LogInformation("No prewarm bucket configured, skipping connection prewarming");
            return;
        }
 
        try
        {
            _logger.LogInformation("Prewarming S3 connections to bucket: {BucketName}", prewarmBucket);
            
            // Проверяем существование бакета
            var bucketExists = await _baseAdapter.BucketExistsAsync(prewarmBucket, cancellationToken);
            if (!bucketExists)
            {
                await _baseAdapter.CreateBucketAsync(prewarmBucket, cancellationToken);
            }
 
            // Выполняем несколько операций для прогрева пула соединений
            var tasks = new List<Task>();
            for (int i = 0; i < 5; i++)
            {
                tasks.Add(PerformWarmupOperation(prewarmBucket, i, cancellationToken));
            }
 
            await Task.WhenAll(tasks);
            _logger.LogInformation("S3 connections prewarmed successfully");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to prewarm S3 connections");
        }
    }
 
    private async Task PerformWarmupOperation(string bucketName, int index, CancellationToken cancellationToken)
    {
        try
        {
            var warmupKey = $"warmup/test-{index}";
            var testData = Encoding.UTF8.GetBytes($"warmup-data-{index}");
            
            using var stream = new MemoryStream(testData);
            await _baseAdapter.PutObjectAsync(bucketName, warmupKey, stream, null, cancellationToken);
            await _baseAdapter.DeleteObjectAsync(bucketName, warmupKey, cancellationToken);
        }
        catch (Exception ex)
        {
            _logger.LogWarning(ex, "Warmup operation {Index} failed", index);
        }
    }
 
    private async void PerformHealthCheck(object state)
    {
        try
        {
            var prewarmBucket = _configuration["S3:PrewarmBucket"];
            if (!string.IsNullOrEmpty(prewarmBucket))
            {
                await _baseAdapter.BucketExistsAsync(prewarmBucket, CancellationToken.None);
            }
        }
        catch (Exception ex)
        {
            _logger.LogWarning(ex, "Health check failed");
        }
    }
 
    // Все остальные методы делегируются базовому адаптеру
    public Task<bool> BucketExistsAsync(string bucketName, CancellationToken cancellationToken = default)
        => _baseAdapter.BucketExistsAsync(bucketName, cancellationToken);
 
    public Task CreateBucketAsync(string bucketName, CancellationToken cancellationToken = default)
        => _baseAdapter.CreateBucketAsync(bucketName, cancellationToken);
 
    public Task<StorageObject> GetObjectAsync(string bucketName, string objectKey, CancellationToken cancellationToken = default)
        => _baseAdapter.GetObjectAsync(bucketName, objectKey, cancellationToken);
 
    public Task<string> PutObjectAsync(string bucketName, string objectKey, Stream content, ObjectMetadata metadata = null, CancellationToken cancellationToken = default)
        => _baseAdapter.PutObjectAsync(bucketName, objectKey, content, metadata, cancellationToken);
 
    public Task DeleteObjectAsync(string bucketName, string objectKey, CancellationToken cancellationToken = default)
        => _baseAdapter.DeleteObjectAsync(bucketName, objectKey, cancellationToken);
}

// Program.cs - точка входа приложения
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using S3Adapter.Core;
using S3Adapter.Implementation;
using S3Adapter.Sample.Services;
 
var builder = Host.CreateApplicationBuilder(args);
 
// Регистрация сервисов
builder.Services.AddS3Adapter(builder.Configuration);
builder.Services.AddMemoryCache();
builder.Services.AddLogging(configure => configure.AddConsole());
 
// Регистрация демонстрационных сервисов
builder.Services.AddScoped<IDocumentService, DocumentService>();
builder.Services.AddScoped<IFileProcessingService, FileProcessingService>();
builder.Services.AddHostedService<S3AdapterDemoService>();
 
var host = builder.Build();
 
// Запуск демонстрационного приложения
await host.RunAsync();