package org.springblade.modules.words;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author yongxuan.he
 * @date 2020/3/17
 */
public class NumHelper {

    public enum SerializableType {
        /** 大小在-128~127之间的整数，占用空间为1字节 */
        TINY_INT(1),
        /** 大小在-32768~32767之间的整数，占用空间为2字节 */
        SMALL_INT(2),
        /** 大小在-8388608~8388607之间的整数，占用空间为3字节 */
        MEDIUM_INT(3),
        /** int类型 */
        INT(4),
        ;

        private final int flag;

        private static Map<Integer, SerializableType> typeMap;
        static {
            Map<Integer, SerializableType> tmpMap = new HashMap<>();
            for (SerializableType type : SerializableType.values()) {
                tmpMap.put(type.getFlag(), type);
            }
            typeMap = tmpMap;
        }
        public static SerializableType getType(int flag) {
            return typeMap.get(flag);
        }

        SerializableType(int flag) {
            this.flag = flag;
        }

        public int getFlag() {
            return flag;
        }
    }

    private interface Serializer {
        byte[] serialize(int a);
    }

    private static Serializer tinyIntWriter = v -> {
        if (v < -128 || v > 127) {
            throw new RuntimeException("not tinyInt: " + v);
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        out.write(v);
        return out.toByteArray();
    };
    private static Serializer smallIntWriter = v -> {
        if (v < -32768 || v > 32767) {
            throw new RuntimeException("not smallInt: " + v);
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        out.write((v >>> 8) & 0xFF);
        out.write(v & 0xFF);
        return out.toByteArray();
    };
    private static Serializer mediumIntWriter = v -> {
        if (v < -8388608 || v > 8388607) {
            throw new RuntimeException("not mediumInt: " + v);
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        out.write((v >>> 16) & 0xFF);
        out.write((v >>> 8) & 0xFF);
        out.write(v & 0xFF);
        return out.toByteArray();
    };

    private static Serializer intWriter = v -> {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        out.write((v >>> 24) & 0xFF);
        out.write((v >>> 16) & 0xFF);
        out.write((v >>> 8) & 0xFF);
        out.write(v & 0xFF);
        return out.toByteArray();
    };

    private static final Map<SerializableType, Serializer> simpleWriterMap = new ConcurrentHashMap<>();
    static {
        simpleWriterMap.put(SerializableType.TINY_INT, tinyIntWriter);
        simpleWriterMap.put(SerializableType.SMALL_INT, smallIntWriter);
        simpleWriterMap.put(SerializableType.MEDIUM_INT, mediumIntWriter);
        simpleWriterMap.put(SerializableType.INT, intWriter);
    }

    public static byte[] serialize(int v) {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        Serializer serializer;
        int typeFlag;

        if(v >= -128 && v<= 127) {
            serializer = simpleWriterMap.get(SerializableType.TINY_INT);
            typeFlag = SerializableType.TINY_INT.getFlag();
        } else if(v >= -32768 && v <= 32767) {
            serializer = simpleWriterMap.get(SerializableType.SMALL_INT);
            typeFlag = SerializableType.SMALL_INT.getFlag();
        } else if(v >= -8388608 && v <= 8388607){
            serializer = simpleWriterMap.get(SerializableType.MEDIUM_INT);
            typeFlag = SerializableType.MEDIUM_INT.getFlag();
        } else {
            serializer = simpleWriterMap.get(SerializableType.INT);
            typeFlag = SerializableType.INT.getFlag();
        }
        out.write(typeFlag);
        byte[] bytes = serializer.serialize(v);
        out.write(bytes, 0, bytes.length);
        return out.toByteArray();
    }

    public interface Deserializer {
        int deserialize(InputStream in) throws IOException;
    }

    private static Deserializer tinyIntReader = in -> {
        int ch = in.read();
        if (ch < 0)
            throw new RuntimeException("deserializing");
        if ((0x80 & ch) == 0x80) {
            ch = 0xffffff00 | ch;
        }
        return ch;
    };
    private static Deserializer smallIntReader = in -> {
        int ch1 = in.read();
        int ch2 = in.read();
        if ((ch1 | ch2) < 0)
            throw new RuntimeException("deserializing");
        int ch = (ch1 << 8) + ch2;
        if ((0x8000 & ch) == 0x8000) {
            ch = 0xffff0000 | ch;
        }
        return ch;
    };
    private static Deserializer mediumIntReader = in -> {
        int ch1 = in.read();
        int ch2 = in.read();
        int ch3 = in.read();
        if ((ch1 | ch2 | ch3) < 0)
            throw new RuntimeException("deserializing");
        int ch = (ch1 << 16) + (ch2 << 8) + (ch3);
        if ((0x800000 & ch) == 0x800000) {
            ch = 0xff000000 | ch;
        }
        return ch;
    };

    private static Deserializer intReader = in -> {
        int ch1 = in.read();
        int ch2 = in.read();
        int ch3 = in.read();
        int ch4 = in.read();
        if ((ch1 | ch2 | ch3 | ch4) < 0)
            throw new RuntimeException("deserializing");
        return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + ch4);
    };

    private static final Map<SerializableType, Deserializer> simpleReaderMap = new ConcurrentHashMap<>();
    static {
        simpleReaderMap.put(SerializableType.TINY_INT, tinyIntReader);
        simpleReaderMap.put(SerializableType.SMALL_INT, smallIntReader);
        simpleReaderMap.put(SerializableType.MEDIUM_INT, mediumIntReader);
        simpleReaderMap.put(SerializableType.INT, intReader);
    }

    public static int read(InputStream in) throws IOException {
        int flag = in.read();
        SerializableType type = SerializableType.getType(flag);
        Deserializer deserializer = simpleReaderMap.get(type);

        if(deserializer == null) {
            throw new RuntimeException("wrong flag: " + flag);
        }
        return deserializer.deserialize(in);
    }
}