package encoding;

import org.junit.Test;
import util.ByteHelper;


import java.math.BigInteger;

import static org.junit.Assert.*;

/*
 * @Author: feng Zhao
 * @Description:
 * @Version: 1.0.0
 * @Date: 22:40 2021/3/14
 * @Copyright: MIN-Group；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室
 */

public class EncoderTest {
    int MaxPacketSize = 8800;
    @Test
    public void TestEmpty() {
        Encoder encoder = new Encoder();
        Encoder estimator = new Encoder();
        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
        estimator.estimatorReset();

        assertTrue(encoder.empty());
        assertTrue(estimator.empty());

        encoder.prependByte((byte)20);
        estimator.prependByte((byte)20);

        assertFalse(encoder.empty());
        assertFalse(estimator.empty());


    }

    @Test
    public void TestEncoder_PrependByte(){
        Encoder encoder = new Encoder();
        Encoder estimator = new Encoder();
        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
        estimator.estimatorReset();
        // 测试前向添加 MaxPacketSize 次是否正常
        for (int i = 0; i < MaxPacketSize; i++) {
            int num = encoder.prependByte((byte) 97);
            estimator.prependByte((byte) 97);
            assertEquals(encoder.left,MaxPacketSize-i-2);
            assertEquals(encoder.buffer[MaxPacketSize-i-1],(byte)97);
            //todo 这里要用encoder.size().getVlIntValue2Int()，还是encoder.size().size()
//            assertEquals(encoder.size().size(),i+1);
//            assertEquals(estimator.size().size(),i+1);
            assertEquals(encoder.size().getVlIntValue2Int(),i+1);
            assertEquals(estimator.size().getVlIntValue2Int(),i+1);
            assertFalse(encoder.empty());
            assertFalse(estimator.empty());
            assertEquals(num,1);
        }
//        for (int i = 0; i < MaxPacketSize; i++) {
//            int num = encoder.prependByte((byte) 97);
//            estimator.prependByte((byte) 97);
//            if ((encoder.left == MaxPacketSize-i-2) ||
//                    (encoder.buffer[MaxPacketSize-i-1] != (byte)97) ||
//                    (encoder.size() != new SizeT(i+1)) ||
//                    (estimator.size() != new SizeT(i+1)) ||
//                    encoder.empty() || estimator.empty()|| (num != 1))
//            {
//                System.out.println("PrependByte Failed"+ i);
//                return;
//            }
//        }

        // 测试超出最大包大小的情况
        int a = encoder.prependByte((byte)1);
        assertEquals(a,0);
    }

    @Test
    public void TestEncoder_AppendByte(){
        Encoder encoder = new Encoder();
        Encoder estimator = new Encoder();
        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(MaxPacketSize));
        estimator.estimatorReset();

        // 测试后向添加 MaxPacketSize 次是否正常
        for (int i = 0; i < MaxPacketSize; i++) {
            int num = encoder.appendByte((byte) 97);
            estimator.appendByte((byte) 97);
            assertEquals(encoder.right, i + 1);
            assertEquals(encoder.buffer[i],(byte)97);
            //todo 这里要用encoder.size().getVlIntValue2Int()，还是encoder.size().size()
//            assertEquals(encoder.size().size(),i+1);
//            assertEquals(estimator.size().size(),i+1);
            assertEquals(encoder.size().getVlIntValue2Int(),i+1);
            assertEquals(estimator.size().getVlIntValue2Int(),i+1);
            assertFalse(encoder.empty());
            assertFalse(estimator.empty());
            assertEquals(num,1);
        }

        // 测试超出最大包大小的情况
        int a = encoder.appendByte((byte) 1);
        assertEquals(a,0);
        int b = encoder.prependByte((byte) 1);
        assertEquals(b,0);

    }

    @Test
    public void TestEncoder_PrependByteArray(){
        Encoder encoder = new Encoder();
        Encoder estimator = new Encoder();
        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
        estimator.estimatorReset();

        byte[] arr = new byte[]{1,2,3,4,5};
        int length = arr.length;
        // 测试prepend，没有超过MaxPacketSize
        int num1 = encoder.prependByteArray(arr, new SizeT(length));
        estimator.prependByteArray(arr, new SizeT(length));
        assertEquals(encoder.size().getVlIntValue2Int(), length);
        assertEquals(estimator.size().getVlIntValue2Int(), length);
        assertEquals(num1,length);

        // 检查插入的数据是否正确
        byte[] newSlice = ByteHelper.getLenBytes(encoder.buffer, new VlInt(MaxPacketSize - length), length);
        for (int i = 0; i < length; i++) {
            assertEquals(arr[i],newSlice[i]);
        }

        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(0));
        // 测试prepend，超过MaxPacketSize的情况
        int times = MaxPacketSize / arr.length + 1;
        for (int i = 0; i < times - 1; i++) {
            int num2 = encoder.prependByteArray(arr, new SizeT(length));
            assertEquals(num2,length);
        }
        int num3 = encoder.prependByteArray(arr, new SizeT(length));
        assertEquals(num3,0);
    }

    @Test
    public void TestEncoder_AppendByteArray(){
        Encoder encoder = new Encoder();
        Encoder estimator = new Encoder();
        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(MaxPacketSize));
        estimator.estimatorReset();

        byte[] arr = new byte[]{1, 2, 3, 4, 5};
        int length = arr.length;

        // 测试append，没有超过MaxPacketSize
        int num1 = encoder.appendByteArray(arr, new SizeT(length));
        estimator.appendByteArray(arr, new SizeT(length));
        assertEquals(encoder.size().getVlIntValue2Int(), length);
        assertEquals(estimator.size().getVlIntValue2Int(), length);
        assertEquals(num1, length);

        // 检查插入的数据是否正确
        byte[] newSlice = ByteHelper.getLenBytes(encoder.buffer, new VlInt(0), length);
        for (int i = 0; i < length; i++) {
            assertEquals(arr[i],newSlice[i]);
        }
        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(MaxPacketSize));

        // 测试prepend，超过MaxPacketSize的情况
        int times = MaxPacketSize / arr.length + 1;
        for (int i = 0; i < times - 1; i++) {
            int num2 = encoder.appendByteArray(arr, new SizeT(length));
            assertEquals(num2,length);
        }
        int num3 = encoder.appendByteArray(arr, new SizeT(length));
        assertEquals(num3,0);


    }

    //error
    @Test
    public void TestPrependVarNumber(){
        Encoder encoder = new Encoder();
        Encoder estimator = new Encoder();
        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
        estimator.estimatorReset();

        // 测试添加240
        int addLen = encoder.prependVarNumber(new VlInt(240));
        byte[] buffer1 = encoder.getBuffer();
        assertEquals(buffer1[0], (byte) 240);
        assertEquals(buffer1.length,1);
        assertEquals(addLen, 1);

        // 测试添加16位整型所能表示的最大值
        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
        encoder.prependVarNumber(new VlInt(65535));
        buffer1 = encoder.getBuffer();
        byte[] buf_tmp = ByteHelper.getLenBytes(buffer1, new VlInt(1), 2);
        int num1 = ByteHelper.new_byteArrayToInt(buf_tmp);
        assertEquals(buffer1.length,3);
        assertEquals(buffer1[0], (byte) 241);
        assertEquals(num1,65535);

        // 测试添加16位整型所能表示的最大值 + 1
        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
        encoder.prependVarNumber(new VlInt(65536));
        buffer1 = encoder.getBuffer();
        byte[] buf_tmp2 = ByteHelper.getLenBytes(buffer1, new VlInt(1), 4);
        int num2 = ByteHelper.new_byteArrayToInt(buf_tmp2);
        assertEquals(buffer1.length,5);
        assertEquals(buffer1[0], (byte) 242);
        assertEquals(num2,65536);

        // 测试添加32位整型所能表示的最大值 + 1
        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
        encoder.prependVarNumber(new VlInt(4294967296L));
        buffer1 = encoder.getBuffer();
        byte[] buf_tmp3 = ByteHelper.getLenBytes(buffer1, new VlInt(1), 8);
//        for (int i = 0; i < buf_tmp3.length; i++) {
//            System.out.println(buf_tmp3[i]);
//        }
//        System.out.println("buf_tmp3.length:"+buf_tmp3.length);
        long num3 = ByteHelper.uint64ToLong(buf_tmp3);
        System.out.println("num3:"+num3);
        assertEquals(buffer1.length,9);
        assertEquals(buffer1[0], (byte) 243);
        assertEquals(num3,4294967296L);

        // TODO 测试添加64位整型所能表示的最大值
        // uint64最大值在java中无法表示

    }




    @Test
    public void TestAppendVarNumber(){
        Encoder encoder = new Encoder();
        Encoder estimator = new Encoder();
        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(MaxPacketSize));
        estimator.estimatorReset();

        // 测试添加240
        int addLen = encoder.appendVarNumber(new VlInt(240));
        byte[] buffer1 = encoder.getBuffer();
        assertEquals(buffer1[0], (byte) 240);
        assertEquals(buffer1.length,1);
        assertEquals(addLen, 1);

        // 测试添加16位整型所能表示的最大值
        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
        encoder.appendVarNumber(new VlInt(65535));
        buffer1 = encoder.getBuffer();
        byte[] buf_tmp = ByteHelper.getLenBytes(buffer1, new VlInt(1), 2);
        int num1 = ByteHelper.new_byteArrayToInt(buf_tmp);
        assertEquals(buffer1.length,3);
        assertEquals(buffer1[0], (byte) 241);
        assertEquals(num1,65535);

        // 测试添加16位整型所能表示的最大值 + 1
        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
        encoder.appendVarNumber(new VlInt(65536));
        buffer1 = encoder.getBuffer();
        byte[] buf_tmp2 = ByteHelper.getLenBytes(buffer1, new VlInt(1), 4);
        int num2 = ByteHelper.new_byteArrayToInt(buf_tmp2);
        assertEquals(buffer1.length,5);
        assertEquals(buffer1[0], (byte) 242);
        assertEquals(num2,65536);

        // 测试添加32位整型所能表示的最大值 + 1
        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
        encoder.appendVarNumber(new VlInt(4294967296L));
        buffer1 = encoder.getBuffer();
        byte[] buf_tmp3 = ByteHelper.getLenBytes(buffer1, new VlInt(1), 8);
        long num3 = ByteHelper.uint64ToLong(buf_tmp3);
        System.out.println("num3:"+num3);
        assertEquals(buffer1.length,9);
        assertEquals(buffer1[0], (byte) 243);
        assertEquals(num3,4294967296L);

        // TODO 测试添加64位整型所能表示的最大值
        // uint64最大值在java中无法表示
    }

    @Test
    public void TestPrependNonNegativeInteger(){
        Encoder encoder = new Encoder();
        Encoder estimator = new Encoder();
        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(0));
        estimator.estimatorReset();

        // 测试添加255
        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(0));
        int addLen1 = encoder.prependNonNegativeInteger(255);
        assertEquals(addLen1, 1);
        byte[] buffer1 = encoder.getBuffer();
        assertEquals(buffer1[0], (byte) 255);
        assertEquals(buffer1.length,1);


        // 添加 MaxUint16
        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
        int addLen2 = encoder.prependNonNegativeInteger(65535);
        assertEquals(addLen2, 2);
        buffer1 = encoder.getBuffer();
        byte[] buf_tmp = ByteHelper.getLenBytes(buffer1, new VlInt(0), 2);
        int num1 = ByteHelper.new_byteArrayToInt(buf_tmp);
        assertEquals(buffer1.length,2);
        assertEquals(num1,65535);

        // 添加 MaxUint32
        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
        int addLen3 = encoder.prependNonNegativeInteger(4294967295L);
        assertEquals(addLen3, 4);
        buffer1 = encoder.getBuffer();
        byte[] buf_tmp2 = ByteHelper.getLenBytes(buffer1, new VlInt(0), 4);
//        long num2 = ByteHelper.new_byteArrayToLong(buf_tmp2);
        int num2 = ByteHelper.new_byteArrayToInt(buf_tmp2);
        assertEquals(buffer1.length,4);
        assertEquals(num2,4294967295L);

        // 添加 MaxUint64
        // TODO 测试添加64位整型所能表示的最大值
    }

    @Test
    public void TestAppendNonNegativeInteger(){
        Encoder encoder = new Encoder();
        Encoder estimator = new Encoder();
        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(MaxPacketSize));
        estimator.estimatorReset();

        // 测试添加255
        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(0));
        int addLen1 = encoder.appendNonNegativeInteger(255);
        assertEquals(addLen1, 1);
        byte[] buffer1 = encoder.getBuffer();
        assertEquals(buffer1[0], (byte) 255);
        assertEquals(buffer1.length,1);

        // 添加 MaxUint16
        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
        int addLen2 = encoder.appendNonNegativeInteger(65535);
        assertEquals(addLen2, 2);
        buffer1 = encoder.getBuffer();
        byte[] buf_tmp = ByteHelper.getLenBytes(buffer1, new VlInt(0), 2);
        int num1 = ByteHelper.new_byteArrayToInt(buf_tmp);
        assertEquals(buffer1.length,2);
        assertEquals(num1,65535);

        // 添加 MaxUint32
        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
        int addLen3 = encoder.appendNonNegativeInteger(4294967295L);
        assertEquals(addLen3, 4);
        buffer1 = encoder.getBuffer();
        byte[] buf_tmp2 = ByteHelper.getLenBytes(buffer1, new VlInt(0), 4);
        int num2 = ByteHelper.new_byteArrayToInt(buf_tmp2);
        assertEquals(buffer1.length,4);
        assertEquals(num2,4294967295L);

        // 添加 MaxUint64
        // TODO 测试添加64位整型所能表示的最大值
//        encoder.encoderReset(new SizeT(MaxPacketSize),new SizeT(0));
//        int addLen4 = encoder.appendNonNegativeInteger(18446744073709551615L);
//        assertEquals(addLen4, 8);
//        buffer1 = encoder.getBuffer();
//        byte[] buf_tmp3 = ByteHelper.getLenBytes(buffer1, new VlInt(0), 8);
//        long num3 = ByteHelper.new_byteArrayToLong(buf_tmp3);
//        assertEquals(buffer1.length,8);
//        assertEquals(num2,18446744073709551615L);
    }

    @Test
    public void TestPrependByteArrayBlock(){
        Encoder encoder = new Encoder();
        Encoder estimator = new Encoder();
        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(0));
        estimator.estimatorReset();

        byte[] buf = new byte[8000];
        for (int i = 1; i < 8000; i++) {
            buf[i] = (byte)(buf[i-1] +1);
        }
        //测试插入数据正确性
        int addLen = encoder.prependByteArrayBlock(new VlInt(241), buf, new SizeT(buf.length));
        assertEquals(addLen,3+8000+3);
        byte[] buf1 = encoder.getBuffer();
        assertEquals(addLen,8006);
        assertEquals(buf1.length,8006);
        assertEquals(buf1[0],(byte)241);
        assertEquals(buf1[3],(byte)241);
        //buf1[1:3] == 241
        byte[] buf_tmp = ByteHelper.getLenBytes(buf1, new VlInt(1), 2);
        int num1 = ByteHelper.new_byteArrayToInt(buf_tmp);
        assertEquals(num1,241);
        //buf1[4:6]==8000
        byte[] buf_tmp2 = ByteHelper.getLenBytes(buf1, new VlInt(4), 2);
        int num2 = ByteHelper.new_byteArrayToInt(buf_tmp2);
        assertEquals(num2,8000);

        //测试字节数组插入数据是否正确
        int std = 0;  //uint:std
        for (int i = 0; i < 8000; i++) {
            assertEquals(buf1[6+i],std);
            std = (std+1)%256;
        }

    }

    @Test
    public void TestAppendByteArrayBlock(){
        Encoder encoder = new Encoder();
        Encoder estimator = new Encoder();
        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(MaxPacketSize));
        estimator.estimatorReset();

        byte[] buf = new byte[8000];
        for (int i = 1; i < 8000; i++) {
            buf[i] = (byte)(buf[i-1] +1);
        }
        //测试插入数据正确性
        int addLen = encoder.appendByteArrayBlock(new VlInt(241), buf, new SizeT(buf.length));
        assertEquals(addLen,3+8000+3);
        byte[] buf1 = encoder.getBuffer();
        assertEquals(addLen,8006);
        assertEquals(buf1.length,8006);
        assertEquals(buf1[0],(byte)241);
        assertEquals(buf1[3],(byte)241);
        //buf1[1:3] == 241
        byte[] buf_tmp = ByteHelper.getLenBytes(buf1, new VlInt(1), 2);
        int num1 = ByteHelper.new_byteArrayToInt(buf_tmp);
        assertEquals(num1,241);
        //buf1[4:6]==8000
        byte[] buf_tmp2 = ByteHelper.getLenBytes(buf1, new VlInt(4), 2);
        int num2 = ByteHelper.new_byteArrayToInt(buf_tmp2);
        assertEquals(num2,8000);

        //测试字节数组插入数据是否正确
        int std = 0;  //uint:std
        for (int i = 0; i < 8000; i++) {
            assertEquals(buf1[6+i],std);
            std = (std+1)%256;
        }

    }

    @Test
    public void TestPrependBlock(){
        Encoder encoder = new Encoder();
        Encoder estimator = new Encoder();
        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(0));
        estimator.estimatorReset();

        byte[] buf = new byte[8000];
        Block block = new Block();
        block.setType(new VlInt(241));
        block.setLength(new VlInt(8000));
        block.setValue(buf);

        int addLen = encoder.prependBlock(block);
        assertEquals(addLen,8006);

        byte[] buf1 = encoder.getBuffer();
        assertEquals(addLen,8006);
        assertEquals(buf1.length,8006);
        assertEquals(buf1[0],(byte)241);
        assertEquals(buf1[3],(byte)241);
        //buf1[1:3] == 241
        byte[] buf_tmp = ByteHelper.getLenBytes(buf1, new VlInt(1), 2);
        int num1 = ByteHelper.new_byteArrayToInt(buf_tmp);
        assertEquals(num1,241);
        //buf1[4:6]==8000
        byte[] buf_tmp2 = ByteHelper.getLenBytes(buf1, new VlInt(4), 2);
        int num2 = ByteHelper.new_byteArrayToInt(buf_tmp2);
        assertEquals(num2,8000);
    }

    @Test
    public void TestAppendBlock(){
        Encoder encoder = new Encoder();
        Encoder estimator = new Encoder();
        encoder.encoderReset(new SizeT(MaxPacketSize), new SizeT(MaxPacketSize));
        estimator.estimatorReset();

        byte[] buf = new byte[8000];
        Block block = new Block();
        block.setType(new VlInt(241));
        block.setLength(new VlInt(8000));
        block.setValue(buf);

        int addLen = encoder.appendBlock(block);
        assertEquals(addLen,8006);

        byte[] buf1 = encoder.getBuffer();
        assertEquals(addLen,8006);
        assertEquals(buf1.length,8006);
        assertEquals(buf1[0],(byte)241);
        assertEquals(buf1[3],(byte)241);
        //buf1[1:3] == 241
        byte[] buf_tmp = ByteHelper.getLenBytes(buf1, new VlInt(1), 2);
        int num1 = ByteHelper.new_byteArrayToInt(buf_tmp);
        assertEquals(num1,241);
        //buf1[4:6]==8000
        byte[] buf_tmp2 = ByteHelper.getLenBytes(buf1, new VlInt(4), 2);
        int num2 = ByteHelper.new_byteArrayToInt(buf_tmp2);
        assertEquals(num2,8000);
    }















}