import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.FileDescriptor;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.time.Duration;
import java.util.Base64;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 号码检测 OpenAPI —— 端到端最小可运行示例。
 *
 * <p>一个文件跑完整流程：申请上传地址 → 直传文件到对象存储 → 创建任务 → 轮询状态 → 下载结果。
 * 无任何第三方依赖，只用 JDK 自带的 HttpClient / Mac / MessageDigest。</p>
 *
 * <p><b>运行方式</b>（JDK 11 及以上，单文件源码模式，不需要先 javac）：</p>
 * <pre>
 *   // Windows PowerShell —— 参数必须加引号，见下
 *   java '-Dfile.encoding=UTF-8' OpenApiQuickStart.java
 *
 *   // cmd.exe / Linux / macOS
 *   java -Dfile.encoding=UTF-8 OpenApiQuickStart.java
 * </pre>
 *
 * <p><b>中文 Windows 请务必加 {@code -Dfile.encoding=UTF-8}</b>：本文件以 UTF-8 保存，
 * 而中文版 JDK 18 之前默认按 GBK 读源码，不加这个参数屏幕上的中文会变成乱码
 * （功能不受影响，只是显示问题）。JDK 18 起默认就是 UTF-8，可以不加。</p>
 *
 * <p><b>PowerShell 必须给这个参数加引号</b>，否则它会在点号处把参数拆成
 * {@code -Dfile} 和 {@code .encoding=UTF-8} 两段，Java 把后半段当成主类名，
 * 报 {@code 找不到或无法加载主类 .encoding=UTF-8}。cmd.exe 与 Linux/macOS 无此问题。
 * 嫌麻烦可以改设环境变量：{@code $env:JAVA_TOOL_OPTIONS = '-Dfile.encoding=UTF-8'}。</p>
 *
 * <p>只需改下面几个常量：API_KEY、FILE_PATH、COUNTRY、PRODUCT_TYPE、BASE_URL。</p>
 *
 * <p><b>最容易踩的坑</b>：第 2 步直传时必须带 {@code Content-Type: text/plain}。
 * 预签名 URL 是按这个类型算出来的，换成 application/octet-stream 之类，
 * 对象存储会直接拒签（403 SignatureDoesNotMatch）——
 * 这正是「文件上传后没有结果」最常见的原因：文件压根没传上去，
 * 任务拿到的是一个不存在的对象键。</p>
 */
public class OpenApiQuickStart
{
    /* ==================== 需要你填的参数 ==================== */

    /** 控制台生成的 API Key，同时用作 HMAC 签名密钥 */
    private static final String API_KEY = "YOUR_API_KEY";

    /**
     * 本地待检测文件的绝对路径（纯文本，一行一个号码/邮箱/用户名）。
     *
     * <p><b>Windows 路径请用正斜杠</b>，Java 在 Windows 上同样认：
     * {@code "C:/Users/you/Downloads/numbers.txt"}。
     * 用反斜杠则每个都要写成两个（{@code "C:\\Users\\you\\..."}）——
     * 单个反斜杠是 Java 的转义符，{@code \U}、{@code \d}、{@code \T} 都不是合法转义，
     * 直接编译报「非法转义符」。</p>
     *
     * <p>目录名或文件名里的<b>空格不需要任何处理</b>，也不要加引号：
     * 文件名含中文也不用管，发请求前会自动 URL 编码。</p>
     */
    private static final String FILE_PATH = "C:/Users/dev/Downloads/2000.txt";

    /**
     * ISO-2 国家码（大写），如 US、TH、BR。
     *
     * <p>号码类产品必填；邮箱 / 用户名类产品不需要，留空字符串即可
     * （是否必填看 GET /products 返回的 country_required）。</p>
     */
    private static final String COUNTRY = "US";

    /** 任务类型 = 对外产品 ID，取自 GET /products，不要硬编码猜 7 是 [Telegram 号码检测] */
    private static final int PRODUCT_TYPE = 7;

    /** API 基地址，末尾不要加斜杠 */
    private static final String BASE_URL = "https://api.geeknums.io";

    /* ==================== 轮询与状态 ==================== */

    /** 轮询间隔：检测通常以分钟计，10 秒足够跟进 */
    private static final long POLL_INTERVAL_MILLIS = 10_000L;

    /** 轮询上限，防止无限等待（10 秒 × 720 = 2 小时） */
    private static final int MAX_POLL_ATTEMPTS = 720;

    /** 任务终态：6 = Exported（完成，结果可下载），8 = Error（失败，会退款） */
    private static final int STATUS_EXPORTED = 6;
    private static final int STATUS_ERROR = 8;

    private static final HttpClient HTTP = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .followRedirects(HttpClient.Redirect.NORMAL)
            .build();

    private static final SecureRandom RANDOM = new SecureRandom();

    public static void main(String[] args) throws Exception
    {
        // 控制台按 UTF-8 输出：Windows 默认 GBK，中文与 → 之类的符号会变成乱码。
        // 只管显示，不影响任何请求内容（请求体一律显式按 UTF-8 编码）。
        System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out), true, "UTF-8"));

        Path localFile = Paths.get(FILE_PATH);
        if (!Files.exists(localFile))
        {
            throw new IllegalStateException("文件不存在：" + localFile.toAbsolutePath());
        }
        String fileName = localFile.getFileName().toString();

        System.out.println("== 0/5 账号检查（顺带验证签名是否算对） ==");
        System.out.println("账号信息：" + get("/api/open/v1/account"));

        /* ---------- 1. 申请上传地址 ---------- */
        System.out.println();
        System.out.println("== 1/5 申请上传地址 ==");
        // file_name 需要 URL 编码：文件名里的空格与中文不编码，签名里的 path 会与服务端不一致
        String uploadResp = get("/api/open/v1/files/upload-url?file_name=" + urlEncode(fileName));
        String presignedUrl = jsonString(uploadResp, "presigned_url");
        String objectKey = jsonString(uploadResp, "file_path");
        if (presignedUrl.isEmpty() || objectKey.isEmpty())
        {
            throw new IllegalStateException("未取到上传地址，响应：" + uploadResp);
        }
        System.out.println("对象键 file_path = " + objectKey);

        /* ---------- 2. 直传文件到对象存储 ---------- */
        System.out.println();
        System.out.println("== 2/5 上传文件 ==");
        uploadFile(presignedUrl, localFile);
        System.out.println("上传成功，大小 " + Files.size(localFile) + " 字节");

        /* ---------- 3. 创建任务 ---------- */
        System.out.println();
        System.out.println("== 3/5 创建任务 ==");
        // 手拼 JSON 仅为免依赖；真实项目请用 Jackson / Gson
        StringBuilder body = new StringBuilder();
        body.append('{')
            .append("\"type\":").append(PRODUCT_TYPE).append(',')
            .append("\"file_path\":\"").append(jsonEscape(objectKey)).append("\",")
            .append("\"file_name\":\"").append(jsonEscape(fileName)).append('"');
        if (!COUNTRY.isEmpty())
        {
            body.append(",\"country\":\"").append(jsonEscape(COUNTRY)).append('"');
        }
        body.append('}');

        String created = post("/api/open/v1/tasks", body.toString());
        long taskId = jsonLong(created, "id");
        if (taskId <= 0)
        {
            throw new IllegalStateException("创建任务失败，响应：" + created);
        }
        System.out.println("任务已创建，id = " + taskId);
        System.out.println("计费条数 total = " + jsonLong(created, "total")
                + "（归一去重、按国家过滤后的有效条数，通常小于文件行数）");

        /* ---------- 4. 轮询直到终态 ---------- */
        System.out.println();
        System.out.println("== 4/5 轮询任务状态 ==");
        int status = pollUntilDone(taskId);

        if (status == STATUS_ERROR)
        {
            String detail = get("/api/open/v1/tasks/" + taskId);
            System.out.println("任务失败，error_code = " + jsonString(detail, "error_code")
                    + "（失败任务会退款）");
            return;
        }

        /* ---------- 5. 下载结果 ---------- */
        System.out.println();
        System.out.println("== 5/5 下载结果 ==");
        Path outDir = localFile.toAbsolutePath().getParent().resolve("result_" + taskId);
        Files.createDirectories(outDir);

        // 完整结果包 zip：给人看的交付物，可加 &lang=zh 让表头与枚举值按语言翻译
        download("/api/open/v1/tasks/" + taskId + "/result", outDir.resolve("result.zip"));
        // 整份 CSV：恒为 canonical token（male/female、yes/no），供程序解析，不随语言变
        download("/api/open/v1/tasks/" + taskId + "/result-csv", outDir.resolve("result.csv"));
        // 已激活号码清单：纯文本一行一个，可直接用于投放
        download("/api/open/v1/tasks/" + taskId + "/activated", outDir.resolve("activated.txt"));

        System.out.println();
        System.out.println("全部完成，结果目录：" + outDir);
    }

    /* ==================== 轮询 ==================== */

    /**
     * 轮询任务直到进入终态，返回最终状态值。
     *
     * <p>状态：1 Created / 2 Pending / 3 Processing / 4 Processed / 5 Exporting
     * / 6 Exported(终) / 7 Unknown / 8 Error(终)。</p>
     *
     * <p>注意别把 status=3 当成失败：部分上游不返回中间进度，
     * success 长时间为 0 是正常的，以终态为准。</p>
     */
    private static int pollUntilDone(long taskId) throws Exception
    {
        for (int attempt = 1; attempt <= MAX_POLL_ATTEMPTS; attempt++)
        {
            String detail = get("/api/open/v1/tasks/" + taskId);
            int status = (int) jsonLong(detail, "status");
            long total = jsonLong(detail, "total");
            long success = jsonLong(detail, "success");
            long activated = jsonLong(detail, "activated");

            System.out.printf("[%d] status=%d (%s) 进度 %d/%d 命中 %d%n",
                    attempt, status, statusName(status), success, total, activated);

            if (status == STATUS_EXPORTED || status == STATUS_ERROR)
            {
                return status;
            }
            Thread.sleep(POLL_INTERVAL_MILLIS);
        }
        throw new IllegalStateException("轮询超时，任务仍未结束：" + taskId);
    }

    private static String statusName(int status)
    {
        switch (status)
        {
            case 1: return "Created";
            case 2: return "Pending";
            case 3: return "Processing";
            case 4: return "Processed";
            case 5: return "Exporting";
            case 6: return "Exported";
            case 7: return "Unknown";
            case 8: return "Error";
            default: return "Unrecognised";
        }
    }

    /* ==================== 签名与请求 ==================== */

    /**
     * 计算签名并发起一次已签名请求。
     *
     * <p>签名原文五段，以 \n 连接，顺序不可变：</p>
     * <pre>
     *   METHOD \n PATH[?QUERY] \n TIMESTAMP \n NONCE \n SHA256_HEX(body)
     * </pre>
     *
     * <p>两个最常见的签名错误：</p>
     * <ul>
     *   <li><b>PATH 漏了 /api</b>：取的是完整 URL 的 path，含 context-path，
     *       即 /api/open/v1/tasks 而不是 /open/v1/tasks。</li>
     *   <li><b>query 被重排或解码</b>：原样带上，不排序、不解码。</li>
     * </ul>
     *
     * <p>GET 请求 body 传空串，但空串<b>同样要算 SHA-256</b>
     * （空串的摘要是 e3b0c442… 那一串，不是留空）。</p>
     */
    private static HttpResponse<byte[]> signedSend(String method, String pathWithQuery, String body)
            throws IOException, InterruptedException
    {
        String ts = String.valueOf(System.currentTimeMillis());
        String nonce = randomNonce();

        String signBase = String.join("\n", method, pathWithQuery, ts, nonce, sha256Hex(body));
        String sign = hmacBase64(signBase, API_KEY);

        HttpRequest.Builder builder = HttpRequest.newBuilder(URI.create(BASE_URL + pathWithQuery))
                .timeout(Duration.ofMinutes(10))
                .header("X-Api-Key", API_KEY)
                .header("X-Api-Ts", ts)
                .header("X-Api-Nonce", nonce)
                .header("X-Api-Sign", sign);

        if (body.isEmpty())
        {
            builder.method(method, HttpRequest.BodyPublishers.noBody());
        }
        else
        {
            // Content-Type 必须是 application/json：服务端只把 JSON 体计入签名
            builder.header("Content-Type", "application/json")
                   .method(method, HttpRequest.BodyPublishers.ofString(body, StandardCharsets.UTF_8));
        }
        return HTTP.send(builder.build(), HttpResponse.BodyHandlers.ofByteArray());
    }

    /** GET 并返回响应文本；非 2xx 直接抛错并带上响应体（错误原因都在 body 里） */
    private static String get(String pathWithQuery) throws IOException, InterruptedException
    {
        HttpResponse<byte[]> res = signedSend("GET", pathWithQuery, "");
        String text = new String(res.body(), StandardCharsets.UTF_8);
        if (res.statusCode() / 100 != 2)
        {
            throw new IllegalStateException("GET " + pathWithQuery
                    + " 失败 HTTP " + res.statusCode() + "：" + text);
        }
        return text;
    }

    /** POST JSON 并返回响应文本 */
    private static String post(String pathWithQuery, String json) throws IOException, InterruptedException
    {
        HttpResponse<byte[]> res = signedSend("POST", pathWithQuery, json);
        String text = new String(res.body(), StandardCharsets.UTF_8);
        if (res.statusCode() / 100 != 2)
        {
            throw new IllegalStateException("POST " + pathWithQuery
                    + " 失败 HTTP " + res.statusCode() + "：" + text);
        }
        return text;
    }

    /** 下载二进制结果到本地文件 */
    private static void download(String pathWithQuery, Path target) throws IOException, InterruptedException
    {
        HttpResponse<byte[]> res = signedSend("GET", pathWithQuery, "");
        if (res.statusCode() / 100 != 2)
        {
            // 部分产品没有 activated 清单，404 属正常，不中断整个流程
            System.out.println("跳过 " + target.getFileName()
                    + "（HTTP " + res.statusCode() + "："
                    + new String(res.body(), StandardCharsets.UTF_8) + "）");
            return;
        }
        Files.write(target, res.body());
        System.out.println("已保存 " + target.getFileName() + "（" + res.body().length + " 字节）");
    }

    /**
     * 直传文件到预签名 URL。
     *
     * <p><b>这一步不带那四个鉴权头</b>：预签名 URL 本身已含授权信息，
     * 额外带上反而可能被对象存储当作冲突签名而拒绝。</p>
     *
     * <p><b>Content-Type 必须是 text/plain</b>，且预签名 URL 有效期只有 15 分钟——
     * 拿到就立刻上传，别缓存复用。</p>
     */
    private static void uploadFile(String presignedUrl, Path file) throws IOException, InterruptedException
    {
        HttpRequest req = HttpRequest.newBuilder(URI.create(presignedUrl))
                .timeout(Duration.ofMinutes(30))
                .header("Content-Type", "text/plain")
                .PUT(HttpRequest.BodyPublishers.ofFile(file))
                .build();

        HttpResponse<String> res = HTTP.send(req, HttpResponse.BodyHandlers.ofString());
        if (res.statusCode() / 100 != 2)
        {
            throw new IllegalStateException("上传失败 HTTP " + res.statusCode() + "：" + res.body()
                    + "\n提示：403 SignatureDoesNotMatch 基本都是 Content-Type 不是 text/plain，"
                    + "或预签名 URL 已超过 15 分钟有效期。");
        }
    }

    /* ==================== 加密与编码工具 ==================== */

    /** SHA-256 十六进制小写 */
    private static String sha256Hex(String data) throws IOException
    {
        try
        {
            byte[] bytes = MessageDigest.getInstance("SHA-256")
                    .digest(data.getBytes(StandardCharsets.UTF_8));
            return toHex(bytes);
        }
        catch (Exception e)
        {
            throw new IOException("SHA-256 计算失败", e);
        }
    }

    /** Base64(HMAC-SHA256(data, secret)) */
    private static String hmacBase64(String data, String secret) throws IOException
    {
        try
        {
            Mac mac = Mac.getInstance("HmacSHA256");
            mac.init(new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
            return Base64.getEncoder()
                    .encodeToString(mac.doFinal(data.getBytes(StandardCharsets.UTF_8)));
        }
        catch (Exception e)
        {
            throw new IOException("HMAC 计算失败", e);
        }
    }

    /** 32 位十六进制随机串，落在服务端要求的 16~64 字符内；每个请求必须不同，复用会被判重放 */
    private static String randomNonce()
    {
        byte[] bytes = new byte[16];
        RANDOM.nextBytes(bytes);
        return toHex(bytes);
    }

    /** 字节数组转十六进制小写 */
    private static String toHex(byte[] bytes)
    {
        StringBuilder sb = new StringBuilder(bytes.length * 2);
        for (byte b : bytes)
        {
            sb.append(Character.forDigit((b >> 4) & 0xF, 16));
            sb.append(Character.forDigit(b & 0xF, 16));
        }
        return sb.toString();
    }

    /**
     * URL 查询参数编码。
     *
     * <p>不用 URLEncoder.encode：它把空格编成 {@code +}（那是表单规则），
     * 而签名里的 path 要与服务端看到的查询串完全一致，空格必须是 %20。</p>
     */
    private static String urlEncode(String s)
    {
        StringBuilder out = new StringBuilder();
        for (byte b : s.getBytes(StandardCharsets.UTF_8))
        {
            int c = b & 0xFF;
            if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9')
                    || c == '-' || c == '_' || c == '.' || c == '~')
            {
                out.append((char) c);
            }
            else
            {
                out.append('%')
                   .append(Character.toUpperCase(Character.forDigit((c >> 4) & 0xF, 16)))
                   .append(Character.toUpperCase(Character.forDigit(c & 0xF, 16)));
            }
        }
        return out.toString();
    }

    /** JSON 字符串值转义（手拼 JSON 时用） */
    private static String jsonEscape(String s)
    {
        return s.replace("\\", "\\\\").replace("\"", "\\\"");
    }

    /* ==================== 极简 JSON 取值 ==================== */
    /*
     * 仅为「零依赖」而手写，只够取顶层的字符串与整数字段。
     * 真实项目请换成 Jackson：new ObjectMapper().readTree(json).path("id").asLong()
     */

    /** 取顶层字符串字段；不存在返回空串 */
    private static String jsonString(String json, String field)
    {
        Matcher m = Pattern.compile("\"" + Pattern.quote(field) + "\"\\s*:\\s*\"((?:[^\"\\\\]|\\\\.)*)\"")
                .matcher(json);
        if (!m.find())
        {
            return "";
        }
        return m.group(1).replace("\\/", "/").replace("\\\"", "\"").replace("\\\\", "\\");
    }

    /** 取顶层整数字段；不存在或非数字返回 -1 */
    private static long jsonLong(String json, String field)
    {
        Matcher m = Pattern.compile("\"" + Pattern.quote(field) + "\"\\s*:\\s*(-?\\d+)")
                .matcher(json);
        return m.find() ? Long.parseLong(m.group(1)) : -1L;
    }
}
