// 本示例基于 AWS SDK for Java v2 service/s3 v2.31.35 实现。
// AWS SDK for Java 2.30.0 及以后版本需禁用 S3 的默认完整性保护。
// 具体参考: 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 {
            // 专业版应用永久密钥 AccessKeyId
            AwsBasicCredentials credentials = AwsBasicCredentials.create(
                    "AccessKeyId", // 专业版应用永久密钥 AccessKeyId
                    "SecretAccessKey" // 专业版应用永久密钥 SecretAccessKey
            );
            String region = "ap-guangzhou"; // 专业版应用存储桶地域
            String bucketId = "bucketid1"; // 专业版应用存储桶ID
            String filePath = "demo.mp4"; // 本地文件路径
            String key = "upload/demo.mp4"; // 文件在存储桶中的路径
            String endpointUrl = String.format("https://vodpro.%s.eovod.com", region); // 桶级别预置域名端点

            // 使用自定义端点构建S3异步客户端
            s3AsyncClient = S3AsyncClient.builder()
                    .credentialsProvider(StaticCredentialsProvider.create(credentials)) // 设置凭证提供者
                    .endpointOverride(URI.create(endpointUrl)) // 设置端点
                    .region(Region.of("auto")) // 固定填写 auto
                    .httpClient(NettyNioAsyncHttpClient.builder().build()) // 设置HTTP客户端
                    .serviceConfiguration(S3Configuration.builder()
                            .pathStyleAccessEnabled(false) // 设置路径样式访问, 桶级别需明确禁用 PathStyle 模式
                            .build())
                    .requestChecksumCalculation(RequestChecksumCalculation.WHEN_REQUIRED)
                    .responseChecksumValidation(ResponseChecksumValidation.WHEN_REQUIRED)
                    .build();

            // 使用S3异步客户端创建S3TransferManager
            transferManager = S3TransferManager.builder()
                    .s3Client(s3AsyncClient)
                    .build();

            File fileToUpload = new File(filePath);

            // 创建上传请求并添加传输监听器用于进度跟踪
            UploadFileRequest uploadRequest = UploadFileRequest.builder()
                    .putObjectRequest(builder -> builder
                            .bucket(bucketId)
                            .key(key))
                    .addTransferListener(LoggingTransferListener.create())
                    .source(fileToUpload)
                    .build();

            // 开始上传
            CompletableFuture<Void> future = transferManager.uploadFile(uploadRequest)
                    .completionFuture()
                    .thenAccept(response -> {
                        System.out.println("上传成功! ETag: " + response.response().eTag());
                    });

            // 等待上传完成
            future.join();

            System.out.println("上传任务完成");
        } catch (Exception e) {
            System.err.println("上传失败: " + e.getMessage());
            e.printStackTrace();
        } finally {
            // 资源释放
            try {
                if (transferManager != null) {
                    transferManager.close();
                }
                if (s3AsyncClient != null) {
                    s3AsyncClient.close();
                }
                System.out.println("资源已释放");
            } catch (Exception e) {
                System.err.println("关闭资源时发生错误: " + e.getMessage());
            }
        }
    }
}

// 本示例基于 AWS SDK for C++ v1.11.560 实现。
// AWS SDK for C++ v1.11.486 及以后版本需禁用 S3 的默认完整性保护。
// 具体参考: 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 初始化
    Aws::SDKOptions options;
    options.loggingOptions.logLevel = Aws::Utils::Logging::LogLevel::Info;
    Aws::InitAPI(options);

    {
        // 定义认证和端点信息
        const Aws::String accessKeyId = "AccessKeyId";         // 填入点播专业版密钥对中的 AccessKeyId
        const Aws::String secretAccessKey = "SecretAccessKey"; // 填入点播专业版密钥对中的 SecretAccessKey
        const Aws::String region = "ap-guangzhou";             // 存储桶所在地域
        const Aws::String bucketId = "bucketid1";              // 点播专业版应用中的存储桶 ID
        const Aws::String keyName = "upload/demo.mp4";         // 文件在存储桶中的路径
        const Aws::String filePath = "demo.mp4";               // 本地文件路径

        // 配置客户端
        Aws::Client::ClientConfiguration clientConfig;
        clientConfig.region = "auto";                                      // 固定填写 auto
        clientConfig.scheme = Aws::Http::Scheme::HTTPS;                    // 协议使用 HTTPS
        clientConfig.enableEndpointDiscovery = false;                      // 禁用 endpoint discovery
        clientConfig.verifySSL = true;                                     // 启用 SSL 证书验证
        clientConfig.endpointOverride = "vodpro." + region + ".eovod.com"; // 桶级别预置域名
        // 禁用完整性校验
        clientConfig.checksumConfig.requestChecksumCalculation = Aws::Client::RequestChecksumCalculation::WHEN_REQUIRED;
        clientConfig.checksumConfig.responseChecksumValidation = Aws::Client::ResponseChecksumValidation::WHEN_REQUIRED;

        // 设置认证信息
        Aws::Auth::AWSCredentials credentials(accessKeyId, secretAccessKey); // 填入点播专业版永久密钥

        // 创建 S3 客户端
        auto s3Client = Aws::MakeShared<Aws::S3::S3Client>(
            "S3Client",
            credentials,
            clientConfig,
            Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy::Never, // 禁用 payload signing
            true                                                       // 桶级别预置域名需明确使用 VirtualAddressing
        );

        // 创建线程池执行器
        auto executor = Aws::MakeShared<Aws::Utils::Threading::PooledThreadExecutor>("executor", 10);

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

        // 设置分片大小为 10MB
        transferConfig.bufferSize = 10 * 1024 * 1024;

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

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

        // 执行上传
        auto uploadHandle = transferManager->UploadFile(
            filePath,                            // 本地文件路径
            bucketId,                            // 存储桶ID
            keyName,                             // 对象键（存储路径）
            "application/octet-stream",          // 内容类型
            Aws::Map<Aws::String, Aws::String>() // 元数据
        );

        // 等待上传完成
        uploadHandle->WaitUntilFinished();

        // 检查上传状态
        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;
        }
    }

    // 清理SDK资源
    Aws::ShutdownAPI(options);
    return 0;
}

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

"""
本示例基于 AWS SDK for Python v1.38.7 实现。
Boto3 的 AWS SDK for Python v1.36.0 及以后版本需禁用 S3 的默认完整性保护。
具体参考: https://github.com/boto/boto3/issues/4392
"""

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

# 常量定义
REGION = "ap-guangzhou"  # 存储桶地域
BUCKET_ID = "bucketid1"  # 填入点播专业版应用中的存储桶 ID
FILE_PATH = "demo.mp4"  # 本地文件路径
OBJECT_KEY = "upload/demo.mp4"  # 文件在存储桶中的路径

# 创建 S3 客户端
s3_client = boto3.client(
    "s3",
    aws_access_key_id="AccessKeyId",  # 填入密钥对中的 AccessKeyId
    aws_secret_access_key="SecretAccessKey",  # 填入密钥对中的 SecretAccessKey
    endpoint_url=f"https://vodpro.{REGION}.eovod.com",  # 桶级别预置上传域名
    region_name="auto",  # 固定填写 auto
    config=Config(
        s3={"addressing_style": "virtual"},  # 使用 virtual hosted-style
        request_checksum_calculation="when_required",  # Boto3 的 AWS SDK for Python v1.36.0 及以后版本需禁用 S3 的默认完整性保护。
        response_checksum_validation="when_required",  # Boto3 的 AWS SDK for Python v1.36.0 及以后版本需禁用 S3 的默认完整性保护。
    ),
)

try:
    # 上传文件
    response = s3_client.upload_file(
        Bucket=BUCKET_ID,  # 填入点播专业版应用中的存储桶 ID
        Key=OBJECT_KEY,  # 文件在存储桶中的路径
        Filename=FILE_PATH,  # 本地文件路径
    )
    print(response)
except ClientError as e:
    print(f"Error: {e}")

import com.tencentcloudapi.common.Credential;
import com.tencentcloudapi.common.exception.TencentCloudSDKException;
import com.tencentcloudapi.common.profile.ClientProfile;
import com.tencentcloudapi.vod.v20240718.VodClient;
import com.tencentcloudapi.vod.v20240718.models.CreateStorageCredentialsRequest;
import com.tencentcloudapi.vod.v20240718.models.CreateStorageCredentialsResponse;

import org.json.JSONArray;
import org.json.JSONObject;

import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

/**
 * 凭证辅助类，负责获取临时存储凭证
 */
public class CredentialHelper {
    // 常量定义
    private static final long APP_ID = 251000000; // 腾讯云账号 APPID
    private static final long SUB_APP_ID = 1234567890; // 云点播专业版应用 APPID
    private static final String BUCKET_ID = "bucketid1"; // 云点播专业版应用存储桶的 ID
    private static final String FILE_KEY = "upload/demo.mp4"; // 上传到存储后的文件 KEY
    private static final String REGION = "ap-guangzhou"; // 存储桶所在地域

    /**
     * 凭证对象，存储临时凭证信息
     */
    public static class Cred {
        private final String accessKeyId;
        private final String secretAccessKey;
        private final String sessionToken;

        public Cred(String accessKeyId, String secretAccessKey, String sessionToken) {
            this.accessKeyId = accessKeyId;
            this.secretAccessKey = secretAccessKey;
            this.sessionToken = sessionToken;
        }

        public String getAccessKeyId() {
            return accessKeyId;
        }

        public String getSecretAccessKey() {
            return secretAccessKey;
        }

        public String getSessionToken() {
            return sessionToken;
        }
    }

    /**
     * 获取临时凭证
     *
     * @return 临时凭证对象
     * @throws Exception 如果获取凭证失败
     */
    public static Cred getCredential() throws Exception {
        try {
            // 1. 初始化腾讯云 API 客户端
            Credential credential = new Credential("SecretId", "SecretKey"); // 腾讯云账号 SecretId 和 SecretKey
            ClientProfile clientProfile = new ClientProfile(); // 客户端配置
            VodClient vodClient = new VodClient(credential, "ap-guangzhou", clientProfile); // 创建 VodClient 对象

            // 2. 构造并编码策略
            String policyJson = createPolicyJson();
            String encodedPolicy = URLEncoder.encode(policyJson, StandardCharsets.UTF_8.name());

            // 3. 创建并发送请求
            CreateStorageCredentialsRequest req = new CreateStorageCredentialsRequest();
            req.setSubAppId(SUB_APP_ID); // 云点播专业版应用 APPID
            req.setPolicy(encodedPolicy); // 策略

            // 4. 获取响应并返回凭证
            CreateStorageCredentialsResponse resp = vodClient.CreateStorageCredentials(req);

            return new Cred(
                    resp.getCredentials().getAccessKeyId(),
                    resp.getCredentials().getSecretAccessKey(),
                    resp.getCredentials().getSessionToken());
        } catch (TencentCloudSDKException e) {
            System.err.println("获取存储凭证失败: " + e.getMessage());
            throw new Exception("获取存储凭证失败", e);
        }
    }

    /**
     * 创建策略JSON字符串，使用 org.json 库
     *
     * @return 策略JSON字符串
     */
    private static String createPolicyJson() {
        // 构建资源路径
        String resource = String.format(
                "qcs::vod:%s:uid/%d:prefix//%d/%s/%s",
                REGION,
                APP_ID,
                SUB_APP_ID,
                BUCKET_ID,
                FILE_KEY);

        // 构建操作列表
        String[] actions = {
                "name/vod:PutObject",
                "name/vod:ListParts",
                "name/vod:PostObject",
                "name/vod:CreateMultipartUpload",
                "name/vod:UploadPart",
                "name/vod:CompleteMultipartUpload",
                "name/vod:AbortMultipartUpload",
                "name/vod:ListMultipartUploads"
        };

        // 使用 JSONObject 构建 JSON
        JSONObject policy = new JSONObject();
        policy.put("version", "2.0");

        JSONArray statements = new JSONArray();
        JSONObject statement = new JSONObject();

        JSONArray actionArray = new JSONArray();
        for (String action : actions) {
            actionArray.put(action);
        }
        statement.put("action", actionArray);

        statement.put("effect", "allow");

        JSONArray resources = new JSONArray();
        resources.put(resource);
        statement.put("resource", resources);

        statements.put(statement);
        policy.put("statement", statements);

        return policy.toString();
    }
}