package sample;

import com.sunyard.proto.Util;
import com.sunyard.sge.database.*;
import com.sunyard.sge.database.Consts;
import org.apache.logging.log4j.Logger;
import org.junit.Assert;

import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;

public class Sample
{
    public static void main(String[] args) {

        // 路径要以 / 或 \\ 结尾表示目录

        // 通常单例就够了
        SydApiBuilder builder = new SydApiBuilder(
                new String[]{ "192.168.1.129","172.16.18.59" },
                new int[]{ 8889,8889 },
                10,
                15
        );

        // 每个工作线程中调用
        SydApi api = builder.build();
        try {
            // 不建议使用了
//            api = api.SYD_Connect_Ex(
//                    new String[]{ "192.168.0.200" },
//                    new int[]{ 8889 },
//                    10,
//                    15
//            );


            // 短数据加密解密
            shortEndeData( api );

            // 批量加密解密
            batchEndeData( api );

            // 长数据加密解密
            longDataEnde( api );

            // 短数据 MAC
            shortMAC( api );

            // 批量 MAC
            batchMACData( api );

            // 长数据 MAC
            longMAC( api );

            // 短数据 SM3
            shortSM3( api );

            // 长数据 SM3
            longSM3( api );


        } finally {
            if ( null != api ) {
                api.SYD_Disconnect_Ex();
            }
        }
    }

    public static void longDataEnde(SydApi api){

        // 密钥索引
        int keyIdx = 0;
        // 测试数据
        byte[] data = new byte[16 * 3 + 8];
        // 每包大小
        int pack = 16;

        // 测试数据 > 每包大小需要分包

        // 密文数据
        ByteBuffer enDataBuff = ByteBuffer.allocate( data.length + 16 );

        // 分包加密
        {
            int n = data.length / pack;
            int remainder = data.length % pack;
            if ( remainder > 0 ) {
                n += 1;
            } else {
                remainder = pack;
            }

            for ( int i = 0 ; i < n ; i ++ ) {
                byte[] buff = new byte[ pack ];

                // 首包
                if ( 0 == i ) {
                    System.arraycopy( data, i * pack, buff, 0, pack );
                    byte[] recv = api.SYD_SM4_LongData( keyIdx , buff, Consts.PkgNumHead, Consts.ECB_ENC);
                    enDataBuff.put( recv );
                    continue;
                }

                // 尾包
                if ( i == (n-1) ){
                    buff = new byte[ remainder ];
                    System.arraycopy( data, i * pack, buff, 0, remainder );
                    byte[] recv = api.SYD_SM4_LongData( keyIdx , buff, Consts.PkgNumTail, Consts.ECB_ENC);
                    enDataBuff.put( recv );
                    continue;
                }

                // 中间包
                System.arraycopy( data, i * pack, buff, 0, pack );
                byte[] recv = api.SYD_SM4_LongData( keyIdx , buff, Consts.PkgNumMiddle, Consts.ECB_ENC);
                enDataBuff.put( recv );

            }

        }

        byte[] enData = new byte[ enDataBuff.position() ];
        System.arraycopy( enDataBuff.array(), 0, enData,  0, enData.length );


        // 分包解密
        // 密文数据
        ByteBuffer deDataBuff = ByteBuffer.allocate( data.length + 16 );
        {
            int n = enData.length / pack;
            int remainder = enData.length % pack;
            if ( remainder > 0 ) {
                n += 1;
            } else {
                remainder = pack;
            }

            for ( int i = 0 ; i < n ; i ++ ) {
                byte[] buff = new byte[ pack ];

                // 首包
                if ( 0 == i ) {
                    System.arraycopy( enData, i * pack, buff, 0, pack );
                    byte[] recv = api.SYD_SM4_LongData( keyIdx , buff, Consts.PkgNumHead, Consts.ECB_DEC);
                    deDataBuff.put( recv );
                    continue;
                }

                // 尾包
                if ( i == (n-1) ){
                    buff = new byte[ remainder ];
                    System.arraycopy( enData, i * pack, buff, 0, remainder );
                    byte[] recv = api.SYD_SM4_LongData( keyIdx , buff, Consts.PkgNumTail, Consts.ECB_DEC);
                    deDataBuff.put( recv );
                    continue;
                }

                // 中间包
                System.arraycopy( enData, i * pack, buff, 0, pack );
                byte[] recv = api.SYD_SM4_LongData( keyIdx , buff, Consts.PkgNumMiddle, Consts.ECB_DEC);
                deDataBuff.put( recv );

            }
        }

        byte[] deData = new byte[ deDataBuff.position() ];
        System.arraycopy( deDataBuff.array(), 0, deData,  0, deData.length );
        // 断言解密后和原文相同
        Assert.assertArrayEquals( deData, data );
    }


    public static void longMAC(SydApi api){

        // 密钥索引
        int keyIdx = 0;
        // 测试数据
        byte[] data = new byte[16 * 3 + 8];
        // 每包大小
        int pack = 16;

        // 测试数据 > 每包大小需要分包

        LongDataReturn<String, String> recv = null;
        // 分包 MAC
        {
            int n = data.length / pack;
            int remainder = data.length % pack;
            if ( remainder > 0 ) {
                n += 1;
            } else {
                remainder = pack;
            }

            for ( int i = 0 ; i < n ; i ++ ) {
                byte[] buff = new byte[ pack ];

                // 首包
                if ( 0 == i ) {
                    System.arraycopy( data, i * pack, buff, 0, pack );
                    recv = api.SYD_SM4Mac_LongData( keyIdx , buff, Consts.PkgNumHead, null);
                    continue;
                }

                // 尾包
                if ( i == (n-1) ){
                    // 尾包大小可能不同
                    buff = new byte[ remainder ];
                    System.arraycopy( data, i * pack, buff, 0, remainder );
                    recv = api.SYD_SM4Mac_LongData( keyIdx , buff, Consts.PkgNumTail, recv.getProcData() );
                    continue;
                }

                // 中间包
                System.arraycopy( data, i * pack, buff, 0, pack );
                recv = api.SYD_SM4Mac_LongData( keyIdx , buff, Consts.PkgNumMiddle, recv.getProcData() );
            }
        }

        String mac = recv.getData();

        // 分包校验 MAC
        LongDataReturn<String, Boolean> check = null;
        ByteBuffer deDataBuff = ByteBuffer.allocate( data.length + 16 );
        {
            int n = data.length / pack;
            int remainder = data.length % pack;
            if ( remainder > 0 ) {
                n += 1;
            } else {
                remainder = pack;
            }

            for ( int i = 0 ; i < n ; i ++ ) {
                byte[] buff = new byte[ pack ];

                // 首包
                if ( 0 == i ) {
                    System.arraycopy( data, i * pack, buff, 0, pack );
                    check = api.SYD_SM4Mac_LongData( keyIdx , buff, Consts.PkgNumHead, null, mac);
                    continue;
                }

                // 尾包
                if ( i == (n-1) ){
                    // 尾包大小可能不同
                    buff = new byte[ remainder ];
                    System.arraycopy( data, i * pack, buff, 0, remainder );
                    check = api.SYD_SM4Mac_LongData( keyIdx , buff, Consts.PkgNumTail, check.getProcData() , mac);
                    continue;
                }

                // 中间包
                System.arraycopy( data, i * pack, buff, 0, pack );
                check = api.SYD_SM4Mac_LongData( keyIdx , buff, Consts.PkgNumMiddle, check.getProcData() , mac);

            }
        }

        // 断言 MAC 校验通过
        Assert.assertTrue( check.getData() );
    }

    public static void shortSM3(SydApi api){
        // 测试数据
        byte[] data = new byte[16];
        String macData = api.SYD_SM3_Hash_ShortData( data );
        Assert.assertEquals( macData , "106E34A2B8C7BB13156CFDD0D91379DCC47543DCF9787C68AE5EB582620AE6E8");
    }


    public static void longSM3(SydApi api){

        // 密钥索引
        int keyIdx = 0;
        // 测试数据
        byte[] data = new byte[16 * 3 + 8];
        // 每包大小
        int pack = 16;

        // 测试数据 > 每包大小需要分包

        LongDataReturn<String, String> recv = null;
        // 分包 MAC
        {
            int n = data.length / pack;
            int remainder = data.length % pack;
            if ( remainder > 0 ) {
                n += 1;
            } else {
                remainder = pack;
            }

            for ( int i = 0 ; i < n ; i ++ ) {
                byte[] buff = new byte[ pack ];

                // 首包
                if ( 0 == i ) {
                    System.arraycopy( data, i * pack, buff, 0, pack );
                    recv = api.SYD_SM3_Hash_LongData( buff, Consts.PkgNumHead, null);
                    continue;
                }

                // 尾包
                if ( i == (n-1) ){
                    // 尾包大小可能不同
                    buff = new byte[ remainder ];
                    System.arraycopy( data, i * pack, buff, 0, remainder );
                    recv = api.SYD_SM3_Hash_LongData( buff, Consts.PkgNumTail, recv.getProcData() );
                    continue;
                }

                // 中间包
                System.arraycopy( data, i * pack, buff, 0, pack );
                recv = api.SYD_SM3_Hash_LongData( buff, Consts.PkgNumMiddle, recv.getProcData() );
            }
        }

        String mac = recv.getData();

        // 断言
        Assert.assertEquals( mac, "87B81AF2B2B22CBDF268E211D012D604892D3C948FF298D61D6C942EEE847F86");
    }

    public static void shortMAC(SydApi api){
        // 密钥索引
        int keyIdx = 0;
        // 测试数据
        byte[] data = new byte[16];
        String macData = api.SYD_SM4Mac_ShortData( keyIdx , data );
        boolean ret = api.SYD_SM4Mac_ShortData( keyIdx , data, macData );
        Assert.assertTrue( ret );
    }

    public static void batchMACData(SydApi api){
        // 密钥索引
        int[] keyIdx = new int[]{ 0, 1, 2 };
        // 测试数据
        List<byte[]> data = new ArrayList<>();
        data.add( new byte[8] );
        data.add( new byte[16] );
        data.add( new byte[1024] );

        String[] macs = api.SYD_SM4Mac_BatchData( keyIdx , data);
        boolean[] checks = api.SYD_SM4Mac_BatchData( keyIdx , data, macs );

        for ( int i = 0 ; i < data.size() ;  i++ ) {
            Assert.assertTrue( checks[i] );
        }
    }


    public static void shortEndeData(SydApi api){
        // 密钥索引
        int keyIdx = 0;
        // 测试数据
        byte[] data = new byte[16];
        byte[] encData = api.SYD_SM4_ShortData( keyIdx , data, Consts.ECB_ENC );
        byte[] orgData = api.SYD_SM4_ShortData( keyIdx , encData, Consts.ECB_DEC );
        Assert.assertArrayEquals( orgData, data );
    }

    public static void batchEndeData(SydApi api){
        // 密钥索引
        int[] keyIdx = new int[]{ 0, 1, 2 };
        // 测试数据
        List<byte[]> data = new ArrayList<>();
        data.add( new byte[8] );
        data.add( new byte[16] );
        data.add( new byte[1024] );

        List<byte[]> encData = api.SYD_SM4_BatchData( keyIdx , data, Consts.ECB_ENC );
        List<byte[]> orgData = api.SYD_SM4_BatchData( keyIdx , encData, Consts.ECB_DEC );

        for ( int i = 0 ; i < data.size() ;  i++ ) {
            Assert.assertArrayEquals( orgData.get( i ), data.get( i ) );
        }

    }
}