package com.zy.common.HslCommunication.Core.Transfer;

import com.zy.common.HslCommunication.Utilities;


/**
 * 字节转换类的基类，提供了一些基础的转换方法
 */
public class ByteTransformBase implements IByteTransform {

    /**
     * 实例化一个对象
     */
    public ByteTransformBase(){
        this.dataFormat = DataFormat.DCBA;
    }

    /**
     * 从缓存中提取出bool结果
     *
     * @param buffer 缓存数据
     * @param index  索引位置
     * @return boolean值
     */
    public boolean TransBool(byte[] buffer, int index) {
        return buffer[index] != 0x00;
    }

    /**
     * 缓存中提取byte结果
     *
     * @param buffer 缓存数据
     * @param index  索引位置
     * @return byte对象
     */
    public byte TransByte(byte[] buffer, int index) {
        return buffer[index];
    }

    /**
     * 从缓存中提取byte数组结果
     *
     * @param buffer 缓存数据
     * @param index  索引位置
     * @param length 读取的数组长度
     * @return byte数组
     */
    public byte[] TransByte(byte[] buffer, int index, int length) {
        byte[] tmp = new byte[length];
        System.arraycopy(buffer, index, tmp, 0, length);
        return tmp;
    }

    /**
     * 从缓存中提取short结果
     *
     * @param buffer 缓存数据
     * @param index  索引位置
     * @return short对象
     */
    public short TransInt16(byte[] buffer, int index) {
        return Utilities.getShort(buffer, index);
    }

    /**
     * 从缓存中提取short结果
     *
     * @param buffer 缓存数据
     * @param index  索引位置
     * @param length 读取的数组长度
     * @return short数组对象
     */
    public short[] TransInt16(byte[] buffer, int index, int length) {
        short[] tmp = new short[length];
        for (int i = 0; i < length; i++) {
            tmp[i] = TransInt16(buffer, index + 2 * i);
        }
        return tmp;
    }

    /**
     * 从缓存中提取int结果
     *
     * @param buffer 缓存数据
     * @param index  索引位置
     * @return int对象
     */
    public int TransInt32(byte[] buffer, int index) {
        return Utilities.getInt(ByteTransDataFormat4(buffer, index),0);
    }


    /**
     * 从缓存中提取int数组结果
     *
     * @param buffer 缓存数据
     * @param index  索引位置
     * @param length 读取的数组长度
     * @return int数组对象
     */
    public int[] TransInt32(byte[] buffer, int index, int length) {
        int[] tmp = new int[length];
        for (int i = 0; i < length; i++) {
            tmp[i] = TransInt32(buffer, index + 4 * i);
        }
        return tmp;
    }


    /**
     * 从缓存中提取long结果
     *
     * @param buffer 缓存数据
     * @param index  索引位置
     * @return long对象
     */
    public long TransInt64(byte[] buffer, int index) {
        return Utilities.getLong(ByteTransDataFormat8(buffer, index),0);
    }


    /**
     * 从缓存中提取long数组结果
     *
     * @param buffer 缓存数据
     * @param index  索引位置
     * @param length 读取的数组长度
     * @return long数组对象
     */
    public long[] TransInt64(byte[] buffer, int index, int length) {
        long[] tmp = new long[length];
        for (int i = 0; i < length; i++) {
            tmp[i] = TransInt64(buffer, index + 8 * i);
        }
        return tmp;
    }


    /**
     * 从缓存中提取float结果
     *
     * @param buffer 缓存对象
     * @param index  索引位置
     * @return float对象
     */
    public float TransSingle(byte[] buffer, int index) {
        return Utilities.getFloat(ByteTransDataFormat4(buffer, index),0);
    }


    /**
     * 从缓存中提取float数组结果
     *
     * @param buffer 缓存数据
     * @param index  索引位置
     * @param length 读取的数组长度
     * @return float数组对象
     */
    public float[] TransSingle(byte[] buffer, int index, int length) {
        float[] tmp = new float[length];
        for (int i = 0; i < length; i++) {
            tmp[i] = TransSingle(buffer, index + 4 * i);
        }
        return tmp;
    }


    /**
     * 从缓存中提取double结果
     *
     * @param buffer 缓存对象
     * @param index  索引位置
     * @return double对象
     */
    public double TransDouble(byte[] buffer, int index) {
        return Utilities.getDouble(ByteTransDataFormat8(buffer, index),0);
    }


    /**
     * 从缓存中提取double数组结果
     *
     * @param buffer 缓存对象
     * @param index  索引位置
     * @param length 读取的数组长度
     * @return double数组
     */
    public double[] TransDouble(byte[] buffer, int index, int length) {
        double[] tmp = new double[length];
        for (int i = 0; i < length; i++) {
            tmp[i] = TransDouble(buffer, index + 8 * i);
        }
        return tmp;
    }


    /**
     * 从缓存中提取string结果，使用指定的编码
     *
     * @param buffer   缓存对象
     * @param index    索引位置
     * @param length   byte数组长度
     * @param encoding 字符串的编码
     * @return string对象
     */
    public String TransString(byte[] buffer, int index, int length, String encoding) {
        return Utilities.getString(TransByte(buffer, index, length), encoding);
    }


    /**
     * bool变量转化缓存数据
     *
     * @param value 等待转化的数据
     * @return buffer数据
     */
    public byte[] TransByte(boolean value) {
        return TransByte(new boolean[]{value});
    }


    /**
     * bool数组变量转化缓存数据
     *
     * @param values 等待转化的数组
     * @return buffer数据
     */
    public byte[] TransByte(boolean[] values) {
        if (values == null) return null;

        byte[] buffer = new byte[values.length];
        for (int i = 0; i < values.length; i++) {
            if (values[i]) buffer[i] = 0x01;
        }

        return buffer;
    }


    /**
     * byte变量转化缓存数据
     *
     * @param value 等待转化的数据
     * @return buffer数据
     */
    public byte[] TransByte(byte value) {
        return new byte[]{value};
    }

    /**
     * short变量转化缓存数据
     *
     * @param value 等待转化的数据
     * @return buffer数据
     */
    public byte[] TransByte(short value) {
        return TransByte(new short[]{value});
    }

    /**
     * short数组变量转化缓存数据
     *
     * @param values 等待转化的数组
     * @return buffer数据
     */
    public byte[] TransByte(short[] values) {
        if (values == null) return null;
        byte[] buffer = new byte[values.length * 2];
        for (int i = 0; i < values.length; i++) {
            System.arraycopy(Utilities.getBytes(values[i]), 0, buffer, 2 * i, 2);
        }
        return buffer;
    }


    /**
     * int变量转化缓存数据
     *
     * @param value 等待转化的数据
     * @return buffer数据
     */
    public byte[] TransByte(int value) {
        return TransByte(new int[]{value});
    }


    /**
     * int数组变量转化缓存数据
     *
     * @param values 等待转化的数组
     * @return buffer数据
     */
    public byte[] TransByte(int[] values) {
        if (values == null) return null;

        byte[] buffer = new byte[values.length * 4];
        for (int i = 0; i < values.length; i++) {
            System.arraycopy(ByteTransDataFormat4(Utilities.getBytes(values[i])), 0, buffer, 4 * i, 4);
        }

        return buffer;
    }

    /**
     * long变量转化缓存数据
     *
     * @param value 等待转化的数据
     * @return buffer数据
     */
    public byte[] TransByte(long value) {
        return TransByte(new long[]{value});
    }


    /**
     * long数组变量转化缓存数据
     *
     * @param values 等待转化的数组
     * @return buffer数据
     */
    public byte[] TransByte(long[] values) {
        if (values == null) return null;

        byte[] buffer = new byte[values.length * 8];
        for (int i = 0; i < values.length; i++) {
            System.arraycopy(ByteTransDataFormat8(Utilities.getBytes(values[i])), 0, buffer, 8 * i, 8);
        }

        return buffer;
    }


    /**
     * float变量转化缓存数据
     *
     * @param value 等待转化的数据
     * @return buffer数据
     */
    public byte[] TransByte(float value) {
        return TransByte(new float[]{value});
    }


    /**
     * float数组变量转化缓存数据
     *
     * @param values 等待转化的数组
     * @return buffer数据
     */
    public byte[] TransByte(float[] values) {
        if (values == null) return null;

        byte[] buffer = new byte[values.length * 4];
        for (int i = 0; i < values.length; i++) {
            System.arraycopy(ByteTransDataFormat4(Utilities.getBytes(values[i])), 0, buffer, 4 * i, 4);
        }

        return buffer;
    }


    /**
     * double变量转化缓存数据
     *
     * @param value 等待转化的数据
     * @return buffer数据
     */
    public byte[] TransByte(double value) {
        return TransByte(new double[]{value});
    }

    /**
     * double数组变量转化缓存数据
     *
     * @param values 等待转化的数组
     * @return buffer数据
     */
    public byte[] TransByte(double[] values) {
        if (values == null) return null;

        byte[] buffer = new byte[values.length * 8];
        for (int i = 0; i < values.length; i++) {
            System.arraycopy(ByteTransDataFormat8(Utilities.getBytes(values[i])), 0, buffer, 8 * i, 8);
        }

        return buffer;
    }

    /**
     * 使用指定的编码字符串转化缓存数据
     *
     * @param value    等待转化的数据
     * @param encoding 字符串的编码方式
     * @return buffer数据
     */
    public byte[] TransByte(String value, String encoding) {
        return Utilities.getBytes(value, encoding);
    }


    private DataFormat dataFormat = DataFormat.ABCD;

    /**
     * 设置数据解析的格式，ABCD，BADC，CDAB，DCBA格式
     *
     * @param dataFormat
     */
    public void setDataFormat(DataFormat dataFormat) {
        this.dataFormat = dataFormat;
    }

    /**
     * 获取数据解析的格式，默认ABCD，可选BADC，CDAB，DCBA格式
     *
     * @return
     */
    public DataFormat getDataFormat() {
        return this.dataFormat;
    }


    /**
     * 反转多字节的数据信息
     *
     * @param value 数据字节
     * @param Index 起始索引，默认值为0
     * @return 实际字节信息
     */
    protected byte[] ByteTransDataFormat4(byte[] value, int Index) {
        byte[] buffer = new byte[4];
        switch (dataFormat) {
            case ABCD: {
                buffer[0] = value[Index + 3];
                buffer[1] = value[Index + 2];
                buffer[2] = value[Index + 1];
                buffer[3] = value[Index + 0];
                break;
            }
            case BADC: {
                buffer[0] = value[Index + 2];
                buffer[1] = value[Index + 3];
                buffer[2] = value[Index + 0];
                buffer[3] = value[Index + 1];
                break;
            }
            case CDAB: {
                buffer[0] = value[Index + 1];
                buffer[1] = value[Index + 0];
                buffer[2] = value[Index + 3];
                buffer[3] = value[Index + 2];
                break;
            }
            case DCBA: {
                buffer[0] = value[Index + 0];
                buffer[1] = value[Index + 1];
                buffer[2] = value[Index + 2];
                buffer[3] = value[Index + 3];
                break;
            }
        }
        return buffer;
    }


    /**
     * 反转多字节的数据信息
     *
     * @param value 数据字节
     * @return 实际字节信息
     */
    protected byte[] ByteTransDataFormat4(byte[] value) {
        return ByteTransDataFormat4(value, 0);
    }


    /**
     * 反转多字节的数据信息
     *
     * @param value 数据字节
     * @param Index 起始索引，默认值为0
     * @return 实际字节信息
     */
    protected byte[] ByteTransDataFormat8(byte[] value, int Index) {
        byte[] buffer = new byte[8];
        switch (dataFormat) {
            case ABCD: {
                buffer[0] = value[Index + 7];
                buffer[1] = value[Index + 6];
                buffer[2] = value[Index + 5];
                buffer[3] = value[Index + 4];
                buffer[4] = value[Index + 3];
                buffer[5] = value[Index + 2];
                buffer[6] = value[Index + 1];
                buffer[7] = value[Index + 0];
                break;
            }
            case BADC: {
                buffer[0] = value[Index + 6];
                buffer[1] = value[Index + 7];
                buffer[2] = value[Index + 4];
                buffer[3] = value[Index + 5];
                buffer[4] = value[Index + 2];
                buffer[5] = value[Index + 3];
                buffer[6] = value[Index + 0];
                buffer[7] = value[Index + 1];
                break;
            }

            case CDAB: {
                buffer[0] = value[Index + 1];
                buffer[1] = value[Index + 0];
                buffer[2] = value[Index + 3];
                buffer[3] = value[Index + 2];
                buffer[4] = value[Index + 5];
                buffer[5] = value[Index + 4];
                buffer[6] = value[Index + 7];
                buffer[7] = value[Index + 6];
                break;
            }
            case DCBA: {
                buffer[0] = value[Index + 0];
                buffer[1] = value[Index + 1];
                buffer[2] = value[Index + 2];
                buffer[3] = value[Index + 3];
                buffer[4] = value[Index + 4];
                buffer[5] = value[Index + 5];
                buffer[6] = value[Index + 6];
                buffer[7] = value[Index + 7];
                break;
            }
        }
        return buffer;
    }


    /**
     * 反转多字节的数据信息
     *
     * @param value 数据字节
     * @return 实际字节信息
     */
    protected byte[] ByteTransDataFormat8(byte[] value) {
        return ByteTransDataFormat8(value, 0);
    }
}