import json
from volcenginesdkcore.rest import ApiException
from volcenginesdkcore import ApiClient, Configuration
from volcenginesdkcore.signv4 import SignerV4


def get_generic_client(access_key: str, secret_key: str, region: str, endpoint: str):
    """创建通用API客户端(适用于任何服务)"""
    try:
        config = Configuration()
        config.ak = access_key
        config.sk = secret_key
        config.region = region
        config.host = endpoint
        config.scheme = "https"
        return ApiClient(config)
    except Exception as e:
        print(f"客户端初始化失败: {str(e)}")
        return None



def call_aisearch_api(client: ApiClient, method: str, path: str, params: dict = None):
    try:
        # 设置服务名
        service = "aisearch"


        # 设置请求头
        headers = {
            "Content-Type": "application/json",
            "Accept": "application/json",
            "Host": client.configuration.host,
        }


        # 序列化请求体
        body = json.dumps(params) if params else ""


        # 手动签名请求
        SignerV4.sign(
            path=path,
            method=method.upper(),
            headers=headers,
            body=body,
            post_params={},
            query={},
            ak=client.configuration.ak,
            sk=client.configuration.sk,
            region=client.configuration.region,
            service=service,
        )


        # 使用rest客户端发送请求
        if method.upper() == "POST":
            response = client.rest_client.POST(
                url=f"https://{client.configuration.host}{path}",
                headers=headers,
                body=json.loads(body) if body else None,
                _preload_content=True,
            )
        else:
            response = client.rest_client.GET(
                url=f"https://{client.configuration.host}{path}",
                headers=headers,
                _preload_content=True,
            )


        # 解析响应
        response_data = json.loads(response.data)


        # 打印状态和保存结果
        print(f"API调用成功 (状态码: {response.status})")
        return response_data


    except ApiException as e:
        print(f"API调用失败: {e.status} {e.reason}")
        print(f"错误详情: {e.body}")
        return None
    except Exception as e:
        print(f"调用异常: {str(e)}")
        return None



if __name__ == "__main__":
    ACCESS_KEY = "" # 配置信息（请替换为实际值）
    SECRET_KEY = ""
    REGION = "cn-beijing"
    ENDPOINT = "aisearch.cn-beijing.volces.com"  # AISearch服务端点
    DATASET_ID = "" # 数据集ID


    # 创建通用客户端
    client = get_generic_client(ACCESS_KEY, SECRET_KEY, REGION, ENDPOINT)


    if client is None:
        print("客户端初始化失败，程序退出")
        exit(1)


    list_path = f"/api/v1/dataset/{DATASET_ID}/list_items"
    list_params = {"max_results": 3}
    list_result = call_aisearch_api(client, "POST", list_path, list_params)
    if list_result:
        with open("list_items.json", "w", encoding="utf-8") as f:
            json.dump(list_result, f, ensure_ascii=False, indent=2)
        print("列表结果已保存到 list_items.json")

package com.example;

import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.nio.file.Files;
import java.nio.file.Paths;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonParser;
import com.google.gson.JsonElement;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import com.volcengine.auth.ISignerV4;
import com.volcengine.auth.impl.SignerV4Impl;
import com.volcengine.model.Credentials;
import com.volcengine.service.SignableRequest;


public class App {
    private static final String AK = ""; // your ak
    private static final String SK = ""; // your sk
    private static final String HOST = "aisearch.cn-beijing.volces.com";
    private static final String SERVICE = "aisearch";
    private static final String REGION = "cn-beijing";
    private static final String SCHEMA = "https";
    
    public static class ApiClient {
        private final String accessKey;
        private final String secretKey;
        private final String region;
        private final String host;
        private final String service;
        private final HttpClient httpClient;
        private final Gson gson;
        
        public ApiClient(String accessKey, String secretKey, String region, String host, String service) {
            this.accessKey = accessKey;
            this.secretKey = secretKey;
            this.region = region;
            this.host = host;
            this.service = service;
            this.httpClient = HttpClients.createDefault();
            this.gson = new GsonBuilder().setPrettyPrinting().create();
        }
        
        public String getHost() {
            return host;
        }
        
        public Gson getGson() {
            return gson;
        }
    }
    
    public static class AISearchService {
        private final ApiClient client;
        
        public AISearchService(ApiClient client) {
            this.client = client;
        }
        
        public String callApi(String method, String path, Map<String, Object> params) throws Exception {
            try {
                // 1. 构建请求体
                String requestBody = params != null ? client.getGson().toJson(params) : "";
                
                // 2. 准备签名请求
                SignableRequest signableRequest = prepareRequest(
                    client.getHost(), 
                    path, 
                    method, 
                    new ArrayList<>(), 
                    requestBody, 
                    client.accessKey, 
                    client.secretKey
                );
                
                // 3. 构建最终的 HTTP 请求
                URI uri = signableRequest.getUriBuilder().build();
                HttpPost httpPost = new HttpPost(uri);
                
                // 4. 设置请求头
                httpPost.setHeader("Content-Type", "application/json");
                httpPost.setHeader("Accept", "application/json");
                httpPost.setHeader("Host", client.getHost());
                
                // 5. 复制认证相关请求头
                if (signableRequest.getFirstHeader("Authorization") != null) {
                    httpPost.setHeader("Authorization", signableRequest.getFirstHeader("Authorization").getValue());
                }
                if (signableRequest.getFirstHeader("X-Date") != null) {
                    httpPost.setHeader("X-Date", signableRequest.getFirstHeader("X-Date").getValue());
                }
                if (signableRequest.getFirstHeader("X-Content-Sha256") != null) {
                    httpPost.setHeader("X-Content-Sha256", signableRequest.getFirstHeader("X-Content-Sha256").getValue());
                }
                
                // 6. 设置请求体
                httpPost.setEntity(new StringEntity(requestBody, StandardCharsets.UTF_8));
                httpPost.setConfig(signableRequest.getConfig());
                
                // 8. 发送请求
                HttpResponse response = client.httpClient.execute(httpPost);
                
                // 9. 处理响应
                int statusCode = response.getStatusLine().getStatusCode();
                HttpEntity responseEntity = response.getEntity();
                
                if (responseEntity != null) {
                    String responseBody = EntityUtils.toString(responseEntity, StandardCharsets.UTF_8);
                    
                    if (statusCode >= 200 && statusCode < 300) {
                        System.out.println("API调用成功 (状态码: " + statusCode + ")");
                        return responseBody;
                    } else {
                        System.err.println("API调用失败: " + statusCode);
                        System.err.println("错误详情: " + responseBody);
                        return null;
                    }
                }
                
                return null;
                
            } catch (Exception e) {
                System.err.println("调用异常: " + e.getMessage());
                e.printStackTrace();
                return null;
            }
        }
        
        public String listItems(String datasetId, int maxResults) throws Exception {
            String path = "/api/v1/dataset/" + datasetId + "/list_items";
            Map<String, Object> params = new HashMap<>();
            params.put("max_results", maxResults);
            
            return callApi("POST", path, params);
        }
        
        public String getItem(String datasetId, String itemId) throws Exception {
            String path = "/api/v1/dataset/" + datasetId + "/get_item";
            Map<String, Object> params = new HashMap<>();
            params.put("_id", itemId);
            
            return callApi("POST", path, params);
        }
    }


    public static void main(String[] args) {
        // 配置信息（请替换为实际值）
        String DATASET_ID = "";
        int MAX_RESULTS = 3;
        
        try {
            // 创建通用客户端
            ApiClient client = new ApiClient(AK, SK, REGION, HOST, SERVICE);
            AISearchService service = new AISearchService(client);
            
            System.out.println("=== 列出数据集项目 ===");
            String listResult = service.listItems(DATASET_ID, MAX_RESULTS);
            if (listResult != null) {
                // 格式化并保存结果
                JsonElement jsonElement = JsonParser.parseString(listResult);
                String formattedJson = client.getGson().toJson(jsonElement);
                Files.write(Paths.get("list_items.json"), formattedJson.getBytes(StandardCharsets.UTF_8));
                System.out.println("列表结果已保存到 list_items.json");
            }
        } catch (Exception e) {
            System.err.println("程序执行异常: " + e.getMessage());
            e.printStackTrace();
        }
    }


    public static SignableRequest prepareRequest(String host, String path, String method, List<NameValuePair> params,
            String body, String ak, String sk) throws Exception {
        SignableRequest request = new SignableRequest();
        request.setMethod(method);
        request.setHeader("Accept", "application/json");
        request.setHeader("Content-Type", "application/json");
        request.setHeader("Host", HOST);
        request.setEntity(new StringEntity(body, "utf-8"));


        URIBuilder builder = request.getUriBuilder();
        builder.setScheme(SCHEMA);
        builder.setHost(host);
        builder.setPath(path);
        if (params != null) {
            builder.setParameters(params);
        }


        RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(5000).setConnectTimeout(2000).build();
        request.setConfig(requestConfig);


        Credentials credentials = new Credentials(REGION, SERVICE);
        credentials.setAccessKeyID(ak);
        credentials.setSecretAccessKey(sk);


        // 签名
        ISignerV4 ISigner = new SignerV4Impl();
        ISigner.sign(request, credentials);


        return request;
    }
}