// This example is implemented using AWS SDK for Java v2 service/s3 v2.31.35.
// AWS SDK for Java 2.30.0 and later require disabling S3's default integrity protection.
// Reference: https://github.com/aws/aws-sdk-java-v2/issues/5801
import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.http.nio.netty.NettyNioAsyncHttpClient;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import software.amazon.awssdk.services.s3.S3Configuration;
import software.amazon.awssdk.transfer.s3.S3TransferManager;
import software.amazon.awssdk.transfer.s3.model.UploadFileRequest;
import software.amazon.awssdk.transfer.s3.progress.LoggingTransferListener;
import software.amazon.awssdk.core.checksums.RequestChecksumCalculation;
import software.amazon.awssdk.core.checksums.ResponseChecksumValidation;

import java.io.File;
import java.net.URI;
import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        S3AsyncClient s3AsyncClient = null;
        S3TransferManager transferManager = null;

        try {
            // Professional Edition application AccessKey AccessKeyId
            AwsBasicCredentials credentials = AwsBasicCredentials.create(
                    "AccessKeyId", // Professional Edition application permanent AccessKeyId
                    "SecretAccessKey" // Professional Edition application permanent SecretAccessKey
            );
            String region = "ap-guangzhou"; // Professional Edition application bucket region
            String bucketId = "bucketid1"; // Professional Edition application bucket ID
            String filePath = "demo.mp4"; // Local file path
            String key = "upload/demo.mp4"; // File path in bucket
            String endpointUrl = String.format("https://vodpro.%s.eovod.com", region); // Bucket-level preset domain endpoint

            // Build S3 async client with custom endpoint
            s3AsyncClient = S3AsyncClient.builder()
                    .credentialsProvider(StaticCredentialsProvider.create(credentials)) // Set credentials provider
                    .endpointOverride(URI.create(endpointUrl)) // Set endpoint
                    .region(Region.of("auto")) // Must be set to "auto"
                    .httpClient(NettyNioAsyncHttpClient.builder().build()) // Set HTTP client
                    .serviceConfiguration(S3Configuration.builder()
                            .pathStyleAccessEnabled(false) // Set path style access, bucket level must explicitly disable PathStyle mode
                            .build())
                    .requestChecksumCalculation(RequestChecksumCalculation.WHEN_REQUIRED)
                    .responseChecksumValidation(ResponseChecksumValidation.WHEN_REQUIRED)
                    .build();

            // Create S3TransferManager with S3 async client
            transferManager = S3TransferManager.builder()
                    .s3Client(s3AsyncClient)
                    .build();

            File fileToUpload = new File(filePath);

            // Create upload request with transfer listener for progress tracking
            UploadFileRequest uploadRequest = UploadFileRequest.builder()
                    .putObjectRequest(builder -> builder
                            .bucket(bucketId)
                            .key(key))
                    .addTransferListener(LoggingTransferListener.create())
                    .source(fileToUpload)
                    .build();

            // Start upload
            CompletableFuture<Void> future = transferManager.uploadFile(uploadRequest)
                    .completionFuture()
                    .thenAccept(response -> {
                        System.out.println("Upload successful! ETag: " + response.response().eTag());
                    });

            // Wait for upload to complete
            future.join();

            System.out.println("Upload task completed");
        } catch (Exception e) {
            System.err.println("Upload failed: " + e.getMessage());
            e.printStackTrace();
        } finally {
            // Release resources
            try {
                if (transferManager != null) {
                    transferManager.close();
                }
                if (s3AsyncClient != null) {
                    s3AsyncClient.close();
                }
                System.out.println("Resources released");
            } catch (Exception e) {
                System.err.println("Error closing resources: " + e.getMessage());
            }
        }
    }
}

// This example is implemented using AWS SDK for C++ v1.11.560.
// AWS SDK for C++ v1.11.486 and later require disabling S3's default integrity protection.
// Reference: https://github.com/aws/aws-sdk-cpp/issues/3253
#include <aws/core/Aws.h>
#include <aws/core/auth/AWSCredentials.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/s3/S3Client.h>
#include <aws/transfer/TransferManager.h>
#include <iostream>

int main()
{
    // AWS SDK initialization
    Aws::SDKOptions options;
    options.loggingOptions.logLevel = Aws::Utils::Logging::LogLevel::Info;
    Aws::InitAPI(options);

    {
        // Define authentication and endpoint information
        const Aws::String accessKeyId = "AccessKeyId";         // Fill in AccessKeyId from VOD Professional key pair
        const Aws::String secretAccessKey = "SecretAccessKey"; // Fill in SecretAccessKey from VOD Professional key pair
        const Aws::String region = "ap-guangzhou";             // Bucket region
        const Aws::String bucketId = "bucketid1";              // Bucket ID in VOD Professional Edition
        const Aws::String keyName = "upload/demo.mp4";         // File path in bucket
        const Aws::String filePath = "demo.mp4";               // Local file path

        // Configure client
        Aws::Client::ClientConfiguration clientConfig;
        clientConfig.region = "auto";                                      // Must be set to "auto"
        clientConfig.scheme = Aws::Http::Scheme::HTTPS;                    // Use HTTPS protocol
        clientConfig.enableEndpointDiscovery = false;                      // Disable endpoint discovery
        clientConfig.verifySSL = true;                                     // Enable SSL certificate verification
        clientConfig.endpointOverride = "vodpro." + region + ".eovod.com"; // Bucket-level preset domain
        // Disable integrity check
        clientConfig.checksumConfig.requestChecksumCalculation = Aws::Client::RequestChecksumCalculation::WHEN_REQUIRED;
        clientConfig.checksumConfig.responseChecksumValidation = Aws::Client::ResponseChecksumValidation::WHEN_REQUIRED;

        // Set authentication information
        Aws::Auth::AWSCredentials credentials(accessKeyId, secretAccessKey); // Fill in VOD Professional AccessKey

        // Create S3 client
        auto s3Client = Aws::MakeShared<Aws::S3::S3Client>(
            "S3Client",
            credentials,
            clientConfig,
            Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy::Never, // Disable payload signing
            true                                                       // Bucket-level domain requires explicit VirtualAddressing
        );

        // Create thread pool executor
        auto executor = Aws::MakeShared<Aws::Utils::Threading::PooledThreadExecutor>("executor", 10);

        // Configure TransferManager
        Aws::Transfer::TransferManagerConfiguration transferConfig(executor.get());
        transferConfig.s3Client = s3Client;

        // Set part size to 10MB
        transferConfig.bufferSize = 10 * 1024 * 1024;

        // Create TransferManager
        auto transferManager = Aws::Transfer::TransferManager::Create(transferConfig);

        std::cout << "Starting file upload: " << filePath << " to " << bucketId << "/" << keyName << std::endl;

        // Perform upload
        auto uploadHandle = transferManager->UploadFile(
            filePath,                            // Local file path
            bucketId,                            // Bucket ID
            keyName,                             // Object key (storage path)
            "application/octet-stream",          // Content type
            Aws::Map<Aws::String, Aws::String>() // Metadata
        );

        // Wait for upload to complete
        uploadHandle->WaitUntilFinished();

        // Check upload status
        if (uploadHandle->GetStatus() == Aws::Transfer::TransferStatus::COMPLETED)
        {
            std::cout << "File upload completed successfully!" << std::endl;
        }
        else
        {
            auto lastError = uploadHandle->GetLastError();
            std::cerr << "File upload failed: " << lastError.GetMessage() << std::endl;
        }
    }

    // Clean up SDK resources
    Aws::ShutdownAPI(options);
    return 0;
}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
This example is implemented using AWS SDK for Python v1.38.7.
Boto3 AWS SDK for Python v1.36.0 and later require disabling S3's default integrity protection.
Reference: https://github.com/boto/boto3/issues/4392
"""

import boto3
from botocore.config import Config
from botocore.exceptions import ClientError

# Constant definitions
REGION = "ap-guangzhou"  # Bucket region
BUCKET_ID = "bucketid1"  # Fill in bucket ID in VOD Professional Edition
FILE_PATH = "demo.mp4"  # Local file path
OBJECT_KEY = "upload/demo.mp4"  # File path in bucket

# Create S3 client
s3_client = boto3.client(
    "s3",
    aws_access_key_id="AccessKeyId",  # Fill in AccessKeyId from key pair
    aws_secret_access_key="SecretAccessKey",  # Fill in SecretAccessKey from key pair
    endpoint_url=f"https://vodpro.{REGION}.eovod.com",  # Bucket-level preset upload domain
    region_name="auto",  # Must be set to "auto"
    config=Config(
        s3={"addressing_style": "virtual"},  # Use virtual hosted-style
        request_checksum_calculation="when_required",  # Boto3 AWS SDK for Python v1.36.0+ require disabling S3's default integrity protection
        response_checksum_validation="when_required",  # Boto3 AWS SDK for Python v1.36.0+ require disabling S3's default integrity protection
    ),
)

try:
    # Upload file
    response = s3_client.upload_file(
        Bucket=BUCKET_ID,  # Fill in bucket ID in VOD Professional Edition
        Key=OBJECT_KEY,  # File path in bucket
        Filename=FILE_PATH,  # Local file path
    )
    print(response)
except ClientError as e:
    print(f"Error: {e}")

// This example is implemented based on AWS SDK for Java v2 service/s3 v2.31.35.
// For AWS SDK for Java version 2.30.0 and later, the default integrity protection for S3 must be disabled.
// Reference: https://github.com/aws/aws-sdk-java-v2/issues/5801
import software.amazon.awssdk.auth.credentials.AwsSessionCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.http.nio.netty.NettyNioAsyncHttpClient;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3AsyncClient;
import software.amazon.awssdk.services.s3.S3Configuration;
import software.amazon.awssdk.transfer.s3.S3TransferManager;
import software.amazon.awssdk.transfer.s3.model.UploadFileRequest;
import software.amazon.awssdk.transfer.s3.progress.LoggingTransferListener;
import software.amazon.awssdk.core.checksums.RequestChecksumCalculation;
import software.amazon.awssdk.core.checksums.ResponseChecksumValidation;

import java.io.File;
import java.net.URI;
import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        S3AsyncClient s3AsyncClient = null;
        S3TransferManager transferManager = null;

        try {
            // 1. Get credentials
            CredentialHelper.Cred cred = CredentialHelper.getCredential();
            System.out.println("Temporary credentials obtained successfully. AccessKeyId: " + cred.getAccessKeyId());

            // 2. Create session credentials
            AwsSessionCredentials sessionCredentials = AwsSessionCredentials.create(
                    cred.getAccessKeyId(),
                    cred.getSecretAccessKey(),
                    cred.getSessionToken()
            );

            String region = "ap-guangzhou"; 
            String bucketId = "bucketid1";
            String filePath = "demo.mp4";
            String key = "upload/demo.mp4";
            String endpointUrl = String.format("https://vodpro.%s.eovod.com", region);

            // 3. Build S3AsyncClient with checksum protection disabled
            s3AsyncClient = S3AsyncClient.builder()
                    .credentialsProvider(StaticCredentialsProvider.create(sessionCredentials))
                    .endpointOverride(URI.create(endpointUrl))
                    .region(Region.of("auto"))
                    .httpClient(NettyNioAsyncHttpClient.builder().build())
                    .serviceConfiguration(
                        S3Configuration.builder()
                            .pathStyleAccessEnabled(false)
                            .build()
                    )
                    // Critical fix - disable CRC32C integrity protection
                    .requestChecksumCalculation(RequestChecksumCalculation.NONE)
                    .responseChecksumValidation(ResponseChecksumValidation.DISABLED)
                    .build();

            // 4. Create transfer manager
            transferManager = S3TransferManager.builder()
                    .s3Client(s3AsyncClient)
                    .build();

            // 5. Validate file
            File fileToUpload = new File(filePath);
            if (!fileToUpload.exists()) {
                throw new RuntimeException("File does not exist: " + filePath);
            }

            // 6. Prepare upload request
            UploadFileRequest uploadRequest = UploadFileRequest.builder()
                    .putObjectRequest(b -> b
                            .bucket(bucketId)
                            .key(key))
                    .addTransferListener(LoggingTransferListener.create())
                    .source(fileToUpload)
                    .build();

            // 7. Execute upload
            System.out.println("Starting file upload...");
            CompletableFuture<Void> future = transferManager.uploadFile(uploadRequest)
                    .completionFuture()
                    .thenAccept(response -> {
                        System.out.println("Upload successful! ETag: " + response.response().eTag());
                    });

            // 8. Wait for completion
            future.join();
            System.out.println("Upload task completed");

        } catch (Exception e) {
            System.err.println("Upload failed: " + e.getMessage());
            e.printStackTrace();
        } finally {
            // 9. Cleanup resources
            try {
                if (transferManager != null) transferManager.close();
                if (s3AsyncClient != null) s3AsyncClient.close();
                System.out.println("Resources released");
            } catch (Exception e) {
                System.err.println("Error closing resources: " + e.getMessage());
            }
        }
    }
}