package cmbpoc;

import com.sunyard.RetWrap;
import com.sunyard.SydApi;
import com.sunyard.entity.TimeStats;
import com.sunyard.proto.Util;
import org.junit.*;
import racal.sunyard.main.SydApi4j;

public class PerformanceTest {

    private SydApi4j api;
    private byte[] privateKey4Ende;
    private byte[] publicKey4Ende;
    private byte[] orgData2K = new byte[2 * 1024];
    private byte[] orgData2M = new byte[2 * 1024 * 1024];
    private byte[] orgData10M = new byte[10 * 1024 * 1024];
    private static final int TEST_ROUNDS = 10;

    @Before
    public void start() {
        System.setProperty("com.sunyard.sydapi4j.debug", "false");
        String ip = System.getProperty("ip", "192.168.100.145");
        System.out.println("ip=" + ip);
        this.api = (SydApi4j) new SydApi4j().connect(ip, 8889, null, 30000);
        this.publicKey4Ende = Util.hexString2Bytes("03420004AF3D4E55D26564C6C937E6EA9232691C01AC5E7916AD2136F788CE7C1E4D0AE8C4754DEC2F7F6A78962D51A171A6F5B4F11823390AEC8B5B0246CD2CCF8052B7");
        this.privateKey4Ende = Util.hexString2Bytes("00010000963F7C3A98B7810F52D2861A060E18A9D4D59796CF33967DD61EEDA091E1AD9B0000000000000000000000000000000000000000000000000000000000000000");
    }

    @After
    public void stop() {
        if (null != api) {
            this.api.disconnect();
            this.api = null;
        }
    }

    @Test
    public void SYD_SM2_Encrypt_Performance_2K() {
        System.out.println("=== SYD_SM2_Encrypt Performance Test - 2K Data ===");
        long totalEncryptTime = 0;
        long totalDecryptTime = 0;

        for (int i = 0; i < TEST_ROUNDS; i++) {
            long encryptStart = System.currentTimeMillis();
            byte[] enData = this.api.SYD_SM2Encrypt(publicKey4Ende, orgData2K);
            long encryptEnd = System.currentTimeMillis();

            long decryptStart = System.currentTimeMillis();
            byte[] deData = this.api.SYD_SM2Decrypt(privateKey4Ende, enData);
            long decryptEnd = System.currentTimeMillis();

            totalEncryptTime += (encryptEnd - encryptStart);
            totalDecryptTime += (decryptEnd - decryptStart);

            Assert.assertArrayEquals(orgData2K, deData);
        }

        double avgEncryptTime = (double) totalEncryptTime / TEST_ROUNDS;
        double avgDecryptTime = (double) totalDecryptTime / TEST_ROUNDS;
        double encryptThroughput = (2.0 / avgEncryptTime) * 1000;
        double decryptThroughput = (2.0 / avgDecryptTime) * 1000;

        System.out.println("Test Rounds: " + TEST_ROUNDS);
        System.out.println("Data Size: 2KB");
        System.out.printf("Average Encrypt Time: %.2f ms%n", avgEncryptTime);
        System.out.printf("Average Decrypt Time: %.2f ms%n", avgDecryptTime);
        System.out.printf("Encrypt Throughput: %.2f KB/s%n", encryptThroughput);
        System.out.printf("Decrypt Throughput: %.2f KB/s%n", decryptThroughput);
        System.out.println();
    }

    @Test
    public void SYD_SM2_Encrypt_Performance_2M() {
        System.out.println("=== SYD_SM2_Encrypt Performance Test - 2M Data ===");
        long totalEncryptTime = 0;
        long totalDecryptTime = 0;

        for (int i = 0; i < TEST_ROUNDS; i++) {
            long encryptStart = System.currentTimeMillis();
            byte[] enData = this.api.SYD_SM2Encrypt(publicKey4Ende, orgData2M);
            long encryptEnd = System.currentTimeMillis();

            long decryptStart = System.currentTimeMillis();
            byte[] deData = this.api.SYD_SM2Decrypt(privateKey4Ende, enData);
            long decryptEnd = System.currentTimeMillis();

            totalEncryptTime += (encryptEnd - encryptStart);
            totalDecryptTime += (decryptEnd - decryptStart);

            Assert.assertArrayEquals(orgData2M, deData);
        }

        double avgEncryptTime = (double) totalEncryptTime / TEST_ROUNDS;
        double avgDecryptTime = (double) totalDecryptTime / TEST_ROUNDS;
        double encryptThroughput = (2048.0 / avgEncryptTime) * 1000;
        double decryptThroughput = (2048.0 / avgDecryptTime) * 1000;

        System.out.println("Test Rounds: " + TEST_ROUNDS);
        System.out.println("Data Size: 2MB");
        System.out.printf("Average Encrypt Time: %.2f ms%n", avgEncryptTime);
        System.out.printf("Average Decrypt Time: %.2f ms%n", avgDecryptTime);
        System.out.printf("Encrypt Throughput: %.2f KB/s%n", encryptThroughput);
        System.out.printf("Decrypt Throughput: %.2f KB/s%n", decryptThroughput);
        System.out.println();
    }

    @Test
    public void SYD_SM2_Encrypt_Performance_10M() {
        System.out.println("=== SYD_SM2_Encrypt Performance Test - 10M Data ===");
        long totalEncryptTime = 0;
        long totalDecryptTime = 0;

        for (int i = 0; i < TEST_ROUNDS; i++) {
            long encryptStart = System.currentTimeMillis();
            byte[] enData = this.api.SYD_SM2Encrypt(publicKey4Ende, orgData10M);
            long encryptEnd = System.currentTimeMillis();

            long decryptStart = System.currentTimeMillis();
            byte[] deData = this.api.SYD_SM2Decrypt(privateKey4Ende, enData);
            long decryptEnd = System.currentTimeMillis();

            totalEncryptTime += (encryptEnd - encryptStart);
            totalDecryptTime += (decryptEnd - decryptStart);

            Assert.assertArrayEquals(orgData10M, deData);
        }

        double avgEncryptTime = (double) totalEncryptTime / TEST_ROUNDS;
        double avgDecryptTime = (double) totalDecryptTime / TEST_ROUNDS;
        double encryptThroughput = (10240.0 / avgEncryptTime) * 1000;
        double decryptThroughput = (10240.0 / avgDecryptTime) * 1000;

        System.out.println("Test Rounds: " + TEST_ROUNDS);
        System.out.println("Data Size: 10MB");
        System.out.printf("Average Encrypt Time: %.2f ms%n", avgEncryptTime);
        System.out.printf("Average Decrypt Time: %.2f ms%n", avgDecryptTime);
        System.out.printf("Encrypt Throughput: %.2f KB/s%n", encryptThroughput);
        System.out.printf("Decrypt Throughput: %.2f KB/s%n", decryptThroughput);
        System.out.println();
    }

    @Test
    public void SYD_SM2_Encrypt_TimeStats_2M() {
        System.out.println("=== SYD_SM2_Encrypt Time Statistics Test - 2M Data ===");
        
        // 预热
        for (int i = 0; i < 2; i++) {
            byte[] enData = this.api.SYD_SM2Encrypt(publicKey4Ende, orgData2M);
            byte[] deData = this.api.SYD_SM2Decrypt(privateKey4Ende, enData);
        }
        
        // 正式测试
        TimeStats encryptStats = new TimeStats();
        TimeStats decryptStats = new TimeStats();
        
        byte[] enData = this.api.SYD_SM2Encrypt(publicKey4Ende, orgData2M, encryptStats);
        byte[] deData = this.api.SYD_SM2Decrypt(privateKey4Ende, enData, decryptStats);
        
        Assert.assertArrayEquals(orgData2M, deData);
        
        System.out.println("\n--- 加密阶段时间统计 ---");
        System.out.printf("发送阶段: %d ms (%.1f%%), 发送次数: %d%n", 
            encryptStats.getSendTime(), encryptStats.getSendPercentage(), encryptStats.getSendCount());
        System.out.printf("计算阶段: %d ms (%.1f%%)%n", 
            encryptStats.getComputeTime(), encryptStats.getComputePercentage());
        System.out.printf("接收阶段: %d ms (%.1f%%), 接收次数: %d%n", 
            encryptStats.getReceiveTime(), encryptStats.getReceivePercentage(), encryptStats.getReceiveCount());
        System.out.printf("加密总耗时: %d ms%n", encryptStats.getTotalTime());
        
        System.out.println("\n--- 解密阶段时间统计 ---");
        System.out.printf("发送阶段: %d ms (%.1f%%), 发送次数: %d%n", 
            decryptStats.getSendTime(), decryptStats.getSendPercentage(), decryptStats.getSendCount());
        System.out.printf("计算阶段: %d ms (%.1f%%)%n", 
            decryptStats.getComputeTime(), decryptStats.getComputePercentage());
        System.out.printf("接收阶段: %d ms (%.1f%%), 接收次数: %d%n", 
            decryptStats.getReceiveTime(), decryptStats.getReceivePercentage(), decryptStats.getReceiveCount());
        System.out.printf("解密总耗时: %d ms%n", decryptStats.getTotalTime());
        
        System.out.println("\n--- 汇总 ---");
        long totalTime = encryptStats.getTotalTime() + decryptStats.getTotalTime();
        System.out.printf("加密解密总耗时: %d ms%n", totalTime);
        System.out.printf("加密吞吐量: %.2f KB/s%n", (2048.0 / encryptStats.getTotalTime()) * 1000);
        System.out.printf("解密吞吐量: %.2f KB/s%n", (2048.0 / decryptStats.getTotalTime()) * 1000);
    }
}