import net.jpountz.lz4.LZ4FrameInputStream;
import net.jpountz.lz4.LZ4FrameOutputStream;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class LZ4Utils
{
    public static byte[] decompressLZ4(byte[] data)
    {
        if (data == null || data.length == 0)
        {
            return new byte[0];
        }

        try (ByteArrayInputStream bais = new ByteArrayInputStream(data);
             LZ4FrameInputStream lz4Input = new LZ4FrameInputStream(bais))
        {

            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[512];
            int read;
            while ((read = lz4Input.read(buffer)) != -1)
            {
                baos.write(buffer, 0, read);
            }
            return baos.toByteArray();

        }
        catch (Exception e)
        {
            try
            {
                byte[] data2 = new byte[data.length];
                CustomLz4Decompressor.decompressFrame(data, data2);
                return data2;
            }
            catch (Exception ex)
            {
                System.err.println(ex);
                return data;
            }
        }
    }

    public static byte[] compressLZ4(byte[] data)
        throws IOException
    {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (LZ4FrameOutputStream lz4Out = new LZ4FrameOutputStream(baos))
        {
            lz4Out.write(data);
        }
        return baos.toByteArray();
    }
}

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class GlobalDecoder
{

    private DataReader dr;

    private List<String> strArr = new ArrayList<>();

    public GlobalDecoder(byte[] data)
    {
        this.dr = new DataReader(data);
        this.strArr.clear();
    }

    public Object decode()
        throws IOException
    {
        int typeCode = dr.readUInt8();

        switch (typeCode)
        {
            case 1:
                return dr.readInt32();
            case 2:
                return dr.readInt64();
            case 3:
                return dr.readFloat32();
            case 4:
                return dr.readFloat64();
            case 5:
                String str = dr.readUTF();
                strArr.add(str);
                return str;
            case 6:
                return dr.readUInt8() == 1;
            case 7:
                int len7 = dr.read7BitInt();
                return dr.readBytes(len7);
            case 8: // Map
                int mapSize = dr.read7BitInt();
                Map<String, Object> map = new HashMap<>();
                for (int i = 0; i < mapSize; i++)
                {
                    Object k = decode();
                    Object v = decode();
                    map.put(String.valueOf(k), v);
                }
                return map;
            case 9: // Array
                int arrLen = dr.read7BitInt();
                List<Object> list = new ArrayList<>();
                for (int i = 0; i < arrLen; i++)
                {
                    list.add(decode());
                }
                return list;
            case 10: // DateTime
                long timestamp = dr.readInt64();
                return new java.util.Date(timestamp);
            case 99: // String ref
                int index = dr.read7BitInt();
                if (index < 0 || index >= strArr.size())
                    return "";
                return strArr.get(index);
            default:
                return null;
        }
    }
}

import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.*;

public class GlobalEncoder
{
    private final DataWriter dw = new DataWriter();
    private final Map<String, Integer> strMap = new HashMap<>(); // 字符串缓存

    public void reset() {
        dw.reset();
        strMap.clear();
    }

    public byte[] getBytes(boolean copy) {
        byte[] arr = dw.toByteArray();
        return copy ? Arrays.copyOf(arr, arr.length) : arr;
    }

    public void encode(Object val) throws IOException {
        if (val == null) {
            encodeNull();
            return;
        }

        if (val instanceof Number) {
            encodeNumber((Number) val);
        } else if (val instanceof Boolean) {
            encodeBoolean((Boolean) val);
        } else if (val instanceof String) {
            encodeString((String) val);
        } else if (val instanceof byte[]) {
            encodeBinary((byte[]) val);
        } else if (val instanceof List<?>) {
            writeUInt8(9);
            List<?> list = (List<?>) val;
            dw.write7BitInt(list.size());
            for (Object o : list) {
                encode(o);
            }
        } else if (val instanceof Map<?, ?>) {
            writeUInt8(8);
            Map<?, ?> map = (Map<?, ?>) val;
            dw.write7BitInt(map.size());
            for (Map.Entry<?, ?> entry : map.entrySet()) {
                encode(entry.getKey().toString());
                encode(entry.getValue());
            }
        } else if (val instanceof Date) {
            encodeDateTime((Date) val);
        } else {
            // POJO → Map
            encodePojo(val);
        }
    }

    private void writeUInt8(int v) throws IOException {
        dw.writeUInt8(v);
    }

    public void encodeNull() throws IOException {
        writeUInt8(0);
    }

    public void encodeBoolean(Boolean b) throws IOException {
        writeUInt8(6);
        writeUInt8(b ? 1 : 0);
    }

    public void encodeString(String s) throws IOException {
        if (strMap.containsKey(s)) {
            writeUInt8(99);
            dw.write7BitInt(strMap.get(s));
        } else {
            writeUInt8(5);
            dw.writeUTF(s);
            strMap.put(s, strMap.size());
        }
    }

    public void encodeNumber(Number n) throws IOException {
        // 尽量精简类型
        if (n instanceof Integer || n instanceof Short || n instanceof Byte) {
            encodeInt(n.intValue());
        } else if (n instanceof Long) {
            encodeLong(n.longValue());
        } else if (n instanceof Float) {
            encodeFloat(n.floatValue());
        } else if (n instanceof Double) {
            encodeDouble(n.doubleValue());
        } else {
            // BigInteger, BigDecimal fallback
            encodeDouble(n.doubleValue());
        }
    }

    public void encodeInt(int val) throws IOException {
        writeUInt8(1);
        dw.writeInt32(val);
    }

    public void encodeLong(long val) throws IOException {
        writeUInt8(2);
        dw.writeInt64(val);
    }

    public void encodeFloat(float val) throws IOException {
        writeUInt8(3);
        dw.writeFloat32(val);
    }

    public void encodeDouble(double val) throws IOException {
        writeUInt8(4);
        dw.writeFloat64(val);
    }

    public void encodeBinary(byte[] val) throws IOException {
        writeUInt8(7);
        dw.write7BitInt(val.length);
        dw.writeUint8Array(val, 0, val.length);
    }

    public void encodeDateTime(Date date) throws IOException {
        writeUInt8(10);
        dw.writeInt64(date.getTime());
    }

    // 结构体/POJO编码
    private void encodePojo(Object obj) throws IOException {
        Map<String, Object> map = pojoToMap(obj);
        writeUInt8(8);
        dw.write7BitInt(map.size());
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            encode(entry.getKey());
            encode(entry.getValue());
        }
    }

    // 反射转Map（仅导出字段）
    private static Map<String, Object> pojoToMap(Object obj) {
        Map<String, Object> result = new LinkedHashMap<>();
        Class<?> clazz = obj.getClass();
        for (Field field : clazz.getDeclaredFields()) {
            if (Modifier.isStatic(field.getModifiers())) continue;
            if (!Modifier.isPublic(field.getModifiers())) field.setAccessible(true);
            try {
                result.put(field.getName(), field.get(obj));
            } catch (Exception ignore) {}
        }
        return result;
    }
}

import java.io.IOException;
import java.util.Arrays;
import java.util.Random;

import static com.ikun.xyzw.config.LZ4Utils.compressLZ4;
import static com.ikun.xyzw.config.LZ4Utils.decompressLZ4;

public class Crypto
{
    private static final Random RANDOM = new Random();

    public static byte[] decryptLX(byte[] data)
    {
        if (data.length < 4)
        {
            return data;
        }
        if (data[0] != 112 || data[1] != 108)
        {
            return data;
        }

        // 提取 key
        int key =
            (((data[2] >> 6) & 1) << 7) |
                (((data[2] >> 4) & 1) << 6) |
                (((data[2] >> 2) & 1) << 5) |
                (((data[2] >> 0) & 1) << 4) |
                (((data[3] >> 6) & 1) << 3) |
                (((data[3] >> 4) & 1) << 2) |
                (((data[3] >> 2) & 1) << 1) |
                (((data[3] >> 0) & 1) << 0);

        // 复制一份防止修改原始数据
        byte[] result = Arrays.copyOf(data, data.length);

        // XOR 解密
        int n = Math.min(result.length, 100);
        for (int i = 2; i < n; i++)
        {
            result[i] ^= key;
        }

        // 替换 LZ4 头部（Magic number）
        result[0] = 0x04;
        result[1] = 0x22;
        result[2] = 0x4D;
        result[3] = 0x18;

        // 解压
        return decompressLZ4(result);
    }

    public static byte[] decryptX(byte[] data)
    {
        if (data == null || data.length < 4)
        {
            return data;
        }

        if (data[0] != 112 || data[1] != 120)
        {
            return data;
        }

        // 提取 key
        int key =
            (((data[2] >> 6) & 1) << 7) |
                (((data[2] >> 4) & 1) << 6) |
                (((data[2] >> 2) & 1) << 5) |
                (((data[2] >> 0) & 1) << 4) |
                (((data[3] >> 6) & 1) << 3) |
                (((data[3] >> 4) & 1) << 2) |
                (((data[3] >> 2) & 1) << 1) |
                (((data[3] >> 0) & 1) << 0);

        // 复制数据，避免修改原始数组
        byte[] result = Arrays.copyOf(data, data.length);

        // 异或解密（从尾到头，跳过前 4 字节）
        for (int i = result.length - 1; i >= 4; i--)
        {
            result[i] ^= key;
        }

        // 返回去掉前4个字节的有效负载
        return Arrays.copyOfRange(result, 4, result.length);
    }

    public static byte[] encryptX(byte[] data)
    {
        // 1. 随机生成一个 4 字节的 ID
        int randomId = RANDOM.nextInt(); // 等价 rand.Uint32()

        byte[] result = new byte[data.length + 4];
        result[0] = (byte)(randomId & 0xFF);
        result[1] = (byte)((randomId >> 8) & 0xFF);
        result[2] = (byte)((randomId >> 16) & 0xFF);
        result[3] = (byte)((randomId >> 24) & 0xFF);

        // 2. 复制原始数据
        System.arraycopy(data, 0, result, 4, data.length);

        // 3. 随机 key (2 ~ 249)
        int key = 2 + RANDOM.nextInt(248);

        // 4. 整体 XOR 加密
        for (int i = result.length - 1; i >= 0; i--)
        {
            result[i] ^= key;
        }

        // 5. 设置固定头部标识（加密后的内容会被覆盖）
        result[0] = 112; // 'p'
        result[1] = 120; // 'x'

        // 6. 将 key 编码到 result[2], result[3]
        result[2] = (byte)((170 & result[2]) |
            ((key >> 7 & 1) << 6) |
            ((key >> 6 & 1) << 4) |
            ((key >> 5 & 1) << 2) |
            ((key >> 4 & 1) << 0));

        result[3] = (byte)((170 & result[3]) |
            ((key >> 3 & 1) << 6) |
            ((key >> 2 & 1) << 4) |
            ((key >> 1 & 1) << 2) |
            ((key >> 0 & 1) << 0));

        return result;
    }

    public static byte[] encryptLX(byte[] data)
        throws IOException
    {
        if (data == null || data.length == 0)
        {
            return new byte[0];
        }

        // 1. LZ4压缩
        byte[] compressed = compressLZ4(data);

        // 2. 生成密钥：范围 2~249
        int key = 2 + RANDOM.nextInt(248);

        // 3. 前100字节异或加密
        int n = Math.min(compressed.length, 100);
        for (int i = 0; i < n; i++)
        {
            compressed[i] ^= key;
        }

        // 4. 写入标记字节 + key位信息
        if (compressed.length >= 4)
        {
            compressed[0] = 112; // 'p'
            compressed[1] = 108; // 'l'

            // 高4位 -> 第2字节
            compressed[2] = (byte)((170 & compressed[2]) |
                (((key >> 7) & 1) << 6) |
                (((key >> 6) & 1) << 4) |
                (((key >> 5) & 1) << 2) |
                (((key >> 4) & 1) << 0));

            // 低4位 -> 第3字节
            compressed[3] = (byte)((170 & compressed[3]) |
                (((key >> 3) & 1) << 6) |
                (((key >> 2) & 1) << 4) |
                (((key >> 1) & 1) << 2) |
                (((key >> 0) & 1) << 0));
        }

        return compressed;
    }

}

import java.io.EOFException;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

public class DataReader {
    private byte[] data;
    private int position;


    public DataReader(byte[] data) {
        this.data = data;
        this.position = 0;
    }

    private boolean validate(int length) {
        return position + length <= data.length;
    }
    public int readUInt8() throws IOException {
        if (!validate(1)) throw new EOFException("read eof");
        return data[position++] & 0xFF;
    }

    public short readInt16() throws IOException {
        if (!validate(2)) throw new EOFException("read eof");
        int b0 = data[position++] & 0xFF;
        int b1 = data[position++] & 0xFF;
        return (short) (b0 | (b1 << 8));
    }

    public int readInt32() throws IOException {
        if (!validate(4)) throw new EOFException("read eof");
        int b0 = data[position++] & 0xFF;
        int b1 = data[position++] & 0xFF;
        int b2 = data[position++] & 0xFF;
        int b3 = data[position++] & 0xFF;
        return (b0) | (b1 << 8) | (b2 << 16) | (b3 << 24);
    }

    public long readInt64() throws IOException {
        // Go 的实现是用两个 int32 模拟的，Java 可直接读 8 字节
        if (!validate(8)) throw new EOFException("read eof");
        long b0 = readInt32() & 0xFFFFFFFFL;
        long b1 = readInt32() & 0xFFFFFFFFL;
        return b0 + (b1 << 32);
    }

    public float readFloat32() throws IOException {
        int bits = readInt32();
        return Float.intBitsToFloat(bits);
    }

    public double readFloat64() throws IOException {
        long b0 = readInt64();
        return Double.longBitsToDouble(b0);
    }

    public int read7BitInt() throws IOException {
        int result = 0;
        int shift = 0;

        while (true) {
            if (shift >= 35) throw new IOException("7-bit int too long");
            int b = readUInt8();
            result |= (b & 0x7F) << shift;
            if ((b & 0x80) == 0) break;
            shift += 7;
        }
        return result;
    }

    public String readUTF() throws IOException {
        int length = read7BitInt();
        return readUTFBytes(length);
    }

    public String readUTFBytes(int length) throws IOException {
        if (length == 0) return "";
        if (!validate(length)) throw new EOFException("read eof");
        String s = new String(data, position, length, StandardCharsets.UTF_8);
        position += length;
        return s;
    }

    public byte[] readUint8Array(int length, boolean copy) throws IOException {
        if (!validate(length)) throw new EOFException("read eof");
        byte[] result;
        if (copy) {
            result = Arrays.copyOfRange(data, position, position + length);
        } else {
            result = Arrays.copyOfRange(data, position, position + length); // Java 无法避免复制
        }
        position += length;
        return result;
    }

    public byte[] readBytes(int size) throws IOException {
        return readUint8Array(size, true);
    }
}

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class DataWriter {
    private final ByteArrayOutputStream out = new ByteArrayOutputStream();

    public byte[] toByteArray() {
        return out.toByteArray();
    }

    public void writeUInt8(int v) throws IOException
    {
        out.write(v & 0xFF);
    }

    public void writeInt8(int v) throws IOException {
        writeUInt8(v);
    }

    public void writeInt16(int v) throws IOException {
        out.write(v & 0xFF);
        out.write((v >> 8) & 0xFF);
    }

    public void writeInt32(int v) throws IOException {
        out.write(v & 0xFF);
        out.write((v >> 8) & 0xFF);
        out.write((v >> 16) & 0xFF);
        out.write((v >> 24) & 0xFF);
    }

    public void writeInt64(long v) throws IOException {
        writeInt32((int) (v & 0xFFFFFFFFL));
        writeInt32((int) ((v >> 32) & 0xFFFFFFFFL));
    }

    public void writeFloat32(float v) throws IOException {
        writeInt32(Float.floatToIntBits(v));
    }

    public void writeFloat64(double v) throws IOException {
        writeInt64(Double.doubleToLongBits(v));
    }

    public void write7BitInt(int value) throws IOException {
        while ((value & 0xFFFFFF80) != 0L) {
            out.write((value & 0x7F) | 0x80);
            value >>>= 7;
        }
        out.write(value & 0x7F);
    }

    public void writeUTF(String s) throws IOException {
        byte[] bytes = s.getBytes(StandardCharsets.UTF_8);
        write7BitInt(bytes.length);
        out.write(bytes);
    }

    public void writeUint8Array(byte[] data, int off, int len) throws IOException {
        out.write(data, off, len);
    }

    public void reset() {
        out.reset();
    }
}

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    private final RoleWebSocketHandler roleWebSocketHandler;

    public WebSocketConfig(RoleWebSocketHandler roleWebSocketHandler) {
        this.roleWebSocketHandler = roleWebSocketHandler;
    }

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry
                .addHandler(roleWebSocketHandler, "/ws/connect")
                .setAllowedOrigins("*");
    }
}

// 启动心跳
Map<String, Object> hb = new HashMap<>();
hb.put("ack", ack);
hb.put("cmd", "_sys/ack");
hb.put("time", timestamp);
byte[] hbData = encodeAndEncryptX(hb);
scheduler = Executors.newSingleThreadScheduledExecutor();
scheduler.scheduleAtFixedRate(() -> {
    if (session.isOpen()) {
        session.getAsyncRemote().sendBinary(ByteBuffer.wrap(hbData));
    } else {
        scheduler.shutdown();
    }
}, 0, 5, TimeUnit.SECONDS);

import com.google.gson.Gson;

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Map;

import static com.ikun.xyzw.crypto.Crypto.encryptLX;
import static com.ikun.xyzw.crypto.Crypto.encryptX;
import static com.ikun.xyzw.decoer.Decoder.decode;
import static com.ikun.xyzw.encoder.Encoder.encode;

public class LZ4Decode
{
    static Gson gson = new Gson();

    public static void main(String[] args)
        throws Exception
    {


        byte[] data =  Files.readAllBytes(Paths.get("src/main/java/com/ikun/cron/data/test.bin"));

        data = encodeReplaceSeq(data, 2);

        Object result = decryptLXAndDecode(data);
        System.out.println(gson.toJson(result));
        String resultBody = gson.toJson(result);
        Map<String, Object> resultMap = (Map<String, Object>)result;
        Object body = resultMap.get("body");
        if (body instanceof byte[])
        {
            Map<String, Object> bodyDecoded = (Map<String, Object>)decode((byte[])body);
            resultMap.put("body", bodyDecoded);
            System.out.println(result);
        }
        String response = AuthUserTool.authUser(resultBody);
        System.out.println("AuthUser 接口返回：" + response);

    }

    public static byte[] encodeReplaceSeq(byte[] data, int seq)
    {
        Object result;
        try
        {
            result = decryptLXAndDecode(data);
            if (result == null)
            {
                return null;
            }
        }
        catch (Exception e)
        {
            return null;
        }
        Map<String, Object> resultMap = (Map<String, Object>)result;

        resultMap.put("seq", seq);

        try
        {
            return encodeAndEncryptLX(resultMap);
        }
        catch (Exception e)
        {
            return null;
        }
    }

    public static Object decryptAndDecode(byte[] data, String method)
        throws Exception
    {
        if (data == null || data.length == 0)
        {
            throw new IllegalArgumentException("empty data");
        }

        byte[] decrypted;
        switch (method)
        {
            case "LX":
                decrypted = Crypto.decryptLX(data);
                break;
            case "X":
                decrypted = Crypto.decryptX(data);
                break;
            default:
                decrypted = data;
                break;
        }

        return decode(decrypted);
    }

    public static byte[] encodeAndEncrypt(Object value, String method)
        throws Exception
    {
        byte[] data = encode(value, true); // 对应 _Encode(value, true)

        switch (method)
        {
            case "LX":
                return encryptLX(data);
            case "X":
                return encryptX(data);
            default:
                return data;
        }
    }

    public static Object decryptLXAndDecode(byte[] data)
        throws Exception
    {
        return decryptAndDecode(data, "LX");
    }

    public static Object decryptXAndDecode(byte[] data)
        throws Exception
    {
        return decryptAndDecode(data, "X");
    }

    public static byte[] encodeAndEncryptX(Map<String, Object> value)
        throws Exception
    {
        return encodeAndEncrypt(value, "X");
    }

    public static byte[] encodeAndEncryptLX(Map<String, Object> value)
        throws Exception
    {
        return encodeAndEncrypt(value, "LX");
    }

}