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();
    }
}

#include <tencentcloud/core/TencentCloud.h>
#include <tencentcloud/core/profile/ClientProfile.h>
#include <tencentcloud/core/profile/HttpProfile.h>
#include <tencentcloud/core/Credential.h>
#include <tencentcloud/vod/v20240718/VodClient.h>
#include <tencentcloud/vod/v20240718/model/CreateStorageCredentialsRequest.h>
#include <tencentcloud/vod/v20240718/model/CreateStorageCredentialsResponse.h>
#include <string>
#include <sstream>
#include <iomanip>
#include <iostream>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

const uint64_t APP_ID = 251000000;                // 腾讯云账号 APPID
const uint64_t SUB_APP_ID = 1234567890;           // 云点播专业版应用 APPID
const std::string BUCKET_ID = "bucketid1";        // 云点播专业版应用存储桶的 ID
const std::string REGION = "ap-guangzhou";        // 云点播专业版应用存储桶地域
const std::string OBJECT_KEY = "upload/demo.mp4"; // 申请权限的存储文件 KEY

// 凭证结构体
struct Credential
{
    std::string accessKeyId;
    std::string secretAccessKey;
    std::string sessionToken;
};

// URL 编码函数
std::string UrlEncode(const std::string &value)
{
    std::ostringstream escaped;
    escaped.fill('0');
    escaped << std::hex;

    for (char c : value)
    {
        if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~')
        {
            escaped << c;
        }
        else
        {
            escaped << std::uppercase;
            escaped << '%' << std::setw(2) << int((unsigned char)c);
            escaped << std::nouppercase;
        }
    }

    return escaped.str();
}

// 获取临时凭证
Credential GetCredential()
{
    // 初始化腾讯云 SDK
    TencentCloud::InitAPI();

    // 创建 VOD 客户端
    TencentCloud::Credential credential("SecretId", "SecretKey"); // 填入腾讯云账号 SecretId 和 SecretKey
    TencentCloud::HttpProfile httpProfile;
    TencentCloud::ClientProfile clientProfile;
    clientProfile.SetHttpProfile(httpProfile);

    TencentCloud::Vod::V20240718::VodClient client(credential, "ap-guangzhou", clientProfile);

    // 构建策略
    json policy_json = {
        {"statement", {{{"action", {"name/vod:PutObject", "name/vod:ListParts", "name/vod:PostObject", "name/vod:CreateMultipartUpload", "name/vod:UploadPart", "name/vod:CompleteMultipartUpload", "name/vod:AbortMultipartUpload", "name/vod:ListMultipartUploads"}}, {"effect", "allow"}, {"resource", {"qcs::vod:" + REGION + ":uid/" + std::to_string(APP_ID) + ":prefix//" + std::to_string(SUB_APP_ID) + "/" + BUCKET_ID + "/" + OBJECT_KEY}}}}},
        {"version", "2.0"}};
    std::string policy = policy_json.dump();

    // 创建请求对象
    TencentCloud::Vod::V20240718::Model::CreateStorageCredentialsRequest req;
    req.SetSubAppId(SUB_APP_ID);
    req.SetPolicy(UrlEncode(policy));

    // 发送请求
    auto outcome = client.CreateStorageCredentials(req);
    if (!outcome.IsSuccess())
    {
        std::cerr << "Failed to get storage credentials: " << outcome.GetError().GetErrorMessage() << std::endl;
        TencentCloud::ShutdownAPI();
        exit(1);
    }

    // 提取凭证
    auto response = outcome.GetResult();
    auto creds = response.GetCredentials();

    Credential result;
    result.accessKeyId = creds.GetAccessKeyId();
    result.secretAccessKey = creds.GetSecretAccessKey();
    result.sessionToken = creds.GetSessionToken();

    // 清理腾讯云 SDK
    TencentCloud::ShutdownAPI();

    return result;
}

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

import json
import urllib.parse
from typing import NamedTuple

from tencentcloud.common import credential
from tencentcloud.common.profile import client_profile
from tencentcloud.vod.v20240718 import vod_client, models

# 常量定义
APP_ID = 251000000  # 腾讯云账号 APPID
SUB_APP_ID = 1234567890  # 云点播专业版应用 APPID
BUCKET_ID = "bucketid1"  # 云点播专业版应用存储桶的 ID
OBJECT_KEY = "upload/demo.mp4"  # 上传到存储后的文件 KEY
REGION = "ap-guangzhou"  # 地域


class Credential(NamedTuple):
    """临时凭证"""

    access_key_id: str
    secret_access_key: str
    session_token: str


def get_credential() -> Credential:
    """获取临时凭证"""
    # 1. 初始化调用腾讯云 API 对象
    cred = credential.Credential(
        "SecretId",  # 腾讯云账号 SecretId
        "SecretKey",  # 腾讯云账号 SecretKey
    )
    prof = client_profile.ClientProfile()
    vod_cli = vod_client.VodClient(cred, "ap-guangzhou", prof)

    # 2. 构造申请上传临时凭证请求
    policy = {
        "statement": [
            {
                "action": [
                    "name/vod:PutObject",
                    "name/vod:ListParts",
                    "name/vod:PostObject",
                    "name/vod:CreateMultipartUpload",
                    "name/vod:UploadPart",
                    "name/vod:CompleteMultipartUpload",
                    "name/vod:AbortMultipartUpload",
                    "name/vod:ListMultipartUploads",
                ],
                "effect": "allow",
                "resource": [f"qcs::vod:{REGION}:uid/{APP_ID}:prefix//{SUB_APP_ID}/{BUCKET_ID}/{OBJECT_KEY}"],
            }
        ],
        "version": "2.0",
    }

    req = models.CreateStorageCredentialsRequest()
    req.SubAppId = SUB_APP_ID
    req.Policy = urllib.parse.quote(json.dumps(policy))

    # 3. 申请上传临时凭证
    resp = vod_cli.CreateStorageCredentials(req)
    creds = resp.Credentials
    return Credential(
        access_key_id=creds.AccessKeyId,
        secret_access_key=creds.SecretAccessKey,
        session_token=creds.SessionToken,
    )