import javax.net.ssl.SSLSocketFactory;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.UUID;

public class HttpTest {

    private static final String SPLIT = "\r\n";

    private static final String RAW_BODY = """
            豫章故郡，洪都新府。星分翼轸，地接衡庐。襟三江而带五湖，控蛮荆而引瓯越。物华天宝，龙光射牛斗之墟；人杰地灵，徐孺下陈蕃之榻。雄州雾列，俊采星驰。台隍枕夷夏之交，宾主尽东南之美。都督阎公之雅望，棨戟遥临；宇文新州之懿范，襜帷暂驻。十旬休假，胜友如云；千里逢迎，高朋满座。腾蛟起凤，孟学士之词宗；紫电青霜，王将军之武库。家君作宰，路出名区；童子何知，躬逢胜饯。
            时维九月，序属三秋。潦水尽而寒潭清，烟光凝而暮山紫。俨骖騑于上路，访风景于崇阿；临帝子之长洲，得天人之旧馆。层峦耸翠，上出重霄；飞阁流丹，下临无地。鹤汀凫渚，穷岛屿之萦回；桂殿兰宫，即冈峦之体势。
            披绣闼，俯雕甍，山原旷其盈视，川泽纡其骇瞩。闾阎扑地，钟鸣鼎食之家；舸舰弥津，青雀黄龙之舳。云销雨霁，彩彻区明。落霞与孤鹜齐飞，秋水共长天一色。渔舟唱晚，响穷彭蠡之滨；雁阵惊寒，声断衡阳之浦。
            遥襟甫畅，逸兴遄飞。爽籁发而清风生，纤歌凝而白云遏。睢园绿竹，气凌彭泽之樽；邺水朱华，光照临川之笔。四美具，二难并。穷睇眄于中天，极娱游于暇日。天高地迥，觉宇宙之无穷；兴尽悲来，识盈虚之有数。望长安于日下，目吴会于云间。地势极而南溟深，天柱高而北辰远。关山难越，谁悲失路之人？萍水相逢，尽是他乡之客。怀帝阍而不见，奉宣室以何年？
            嗟乎！时运不齐，命途多舛。冯唐易老，李广难封。屈贾谊于长沙，非无圣主；窜梁鸿于海曲，岂乏明时？所赖君子见机，达人知命。老当益壮，宁移白首之心？穷且益坚，不坠青云之志。酌贪泉而觉爽，处涸辙以犹欢。北海虽赊，扶摇可接；东隅已逝，桑榆非晚。孟尝高洁，空余报国之情；阮籍猖狂，岂效穷途之哭！
            勃，三尺微命，一介书生。无路请缨，等终军之弱冠；有怀投笔，慕宗悫之长风。舍簪笏于百龄，奉晨昏于万里。非谢家之宝树，接孟氏之芳邻。他日趋庭，叨陪鲤对；今兹捧袂，喜托龙门。杨意不逢，抚凌云而自惜；钟期既遇，奏流水以何惭？
            呜乎！胜地不常，盛筵难再；兰亭已矣，梓泽丘墟。临别赠言，幸承恩于伟饯；登高作赋，是所望于群公。敢竭鄙怀，恭疏短引；一言均赋，四韵俱成。请洒潘江，各倾陆海云尔：
            滕王高阁临江渚，佩玉鸣鸾罢歌舞。
            画栋朝飞南浦云，珠帘暮卷西山雨。
            闲云潭影日悠悠，物换星移几度秋。
            阁中帝子今何在？槛外长江空自流。\r
            \r
            """;

    public static void main(String[] args) throws Exception {
        for (int i = 0; i < 600; i++) {
            new Thread(() -> {
                try {
                    httpPostMultipartFormData(new File("/data/abc.png"));
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }).start();
        }
        System.out.println("线程启动成功");
    }

    private static void httpPostMultipartFormData(File file) throws Exception {
        String host = "172.20.103.88";
        String path = "/fuck/file2";
        int port = 8080;
        try (Socket client = newSocket(host, port);
             OutputStream os = client.getOutputStream();
             InputStream is = client.getInputStream()) {

            // 分隔符，分隔符前面必须加上--，否则不会被识别
            String boundary = UUID.randomUUID().toString().replace("-", "");

            byte[] data = writeFile(file, boundary);

            writeLine(os, "POST " + path + " HTTP/1.1");
            writeLine(os, "host:" + host + ":8080");
            writeLine(os, "Connection:keep-alive");
            writeLine(os, "Content-Type:multipart/form-data;boundary=" + boundary);
            writeLine(os, "Content-Length:" + data.length);
            writeLine(os, null);

            System.out.println("开始上传");
            // int c = 0;
            for (int i = 0; i < data.length; i++) {
                if (i != 0 && i % 100 == 0) {
                    Thread.sleep(8000L);
                    // c++;
                    // if (c == 3) {
                    //     client.close();
                    // }
                    System.out.println("睡一会儿..." + i);
                    os.flush();
                }
                os.write(data[i]);
            }
            os.flush();

            printResponse(is);
        }
    }

    private static byte[] writeFile(File file, String boundary) throws IOException {
        String mimeType = Files.probeContentType(file.toPath());

        ByteArrayOutputStream os = new ByteArrayOutputStream();
        writeLine(os, "--" + boundary);
        writeLine(os, "Content-Disposition: form-data; name=\"file\"; filename=\"abc.png\"");
        writeLine(os, "Content-Type: " + mimeType);
        writeLine(os, null);

        try (InputStream is = new FileInputStream(file)) {
            byte[] bytes = new byte[1024];
            int len;
            while ((len = is.read(bytes)) != -1) {
                os.write(bytes, 0, len);
            }
        }
        writeLine(os, null);
        writeLine(os, "--" + boundary + "--");
        return os.toByteArray();
    }

    // private static class MultipartFile {
    //     private String header;
    //     private String contentType;
    //     private File file;
    //     private String boundary;
    //
    //     public MultipartFile(File file) {
    //         this.file = file;
    //         this.header = buildHeader();
    //     }
    //
    //     private String buildHeader() {
    //         this.header = new StringBuilder()
    //                 .append("--" + boundary).append(SPLIT)
    //                 .append("Content-Disposition: form-data; name=\"file\"; filename=\"" + file.getName() + "\"").append(SPLIT)
    //                 .toString();
    //     }
    // }

    // private static void httpPostChunked(byte[] data, int segment) throws IOException {
    //     try (Socket client = newSocket("misc.test.com", 443);
    //          OutputStream os = client.getOutputStream();
    //          InputStream is = client.getInputStream()) {
    //
    //         writeLine(os, "POST /dump.htm HTTP/1.1");
    //         writeLine(os, "host:misc.test.com");
    //         writeLine(os, "Connection:close");
    //         writeLine(os, "Transfer-Encoding: chunked");
    //         writeLine(os, null);
    //
    //         int len = data.length / segment;
    //         for (int i = 0; i < segment; i++) {
    //             int size = len;
    //             if (i == segment - 1) {
    //                 size = data.length - (i * len);
    //             }
    //             writeLine(os, Integer.toString(size, 16));
    //             os.write(data, len * i, size);
    //             writeLine(os, null);
    //         }
    //         writeLine(os, "0");
    //         writeLine(os, null);
    //         printResponse(is);
    //     }
    // }

    private static void writeLine(OutputStream os, String str) throws IOException {
        byte[] data;
        if (str != null) {
            data = (str + SPLIT).getBytes(StandardCharsets.UTF_8);
        } else {
            data = SPLIT.getBytes(StandardCharsets.UTF_8);
        }
        os.write(data);
    }

    private static void httpPost(byte[] body) throws Exception {
        String host = "nginx-test.test.cn";
        // String path = "/test/file.htm";
        // String path = "/fuck/file2";
        String path = "/api/test/sleep.htm?ms=100";
        int port = 8080;

        try (Socket client = newSocket(host, port);
             OutputStream os = client.getOutputStream();
             InputStream is = client.getInputStream()) {
            writeLine(os, "POST " + path + " HTTP/1.1");
            writeLine(os, "host:" + host);
            writeLine(os, "Connection:close");
            writeLine(os, "Content-Type:text/plain;charset=utf-8");
            writeLine(os, "Content-Length:" + body.length);
            writeLine(os, null);
            os.flush();

            System.out.println("开始上传");
            for (int i = 0; i < body.length; i++) {
                if (i != 0 && i % 100 == 0) {
                    Thread.sleep(300L);
                    System.out.println("睡一会儿..." + i);
                    os.flush();
                }
                os.write(body[i]);
            }
            os.flush();
            // os.write(body);

            printResponse(is);
        }
    }


    private static Socket newSocket(String host, int port) {
        try {
            if (port == 443) {
                return SSLSocketFactory.getDefault().createSocket(host, port);
            } else {
                return new Socket(host, port);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private static void printResponse(InputStream is) throws IOException {
        System.out.println("\n-----输出内容-----\n");
        int length;
        byte[] buffer = new byte[1024];
        while ((length = is.read(buffer)) != -1) {
            System.out.print(new String(buffer, 0, length));
        }
    }
}

/**
 * 参见文档: <a href="https://zh.wikipedia.org/wiki/%E6%B1%89%E5%AD%97%E5%86%85%E7%A0%81%E6%89%A9%E5%B1%95%E8%A7%84%E8%8C%83">汉字内码扩展规范</a>
 * <p>
 * GBK/1:GB2312非汉字符号: A1~A9, A1~FE
 * GBK/2:GB2312汉字: B0~F7, A1~FE
 * GBK/3:扩充汉字: 81~A0, 40~FE (7F除外)
 * GBK/4:扩充汉字: AA~FE, 40~A0 (7F除外)
 * GBK/5:扩充非汉字: A8~A9, 40~A0 (7F除外)
 *
 * @author Gao Youbo
 * @since 2022-08-23 16:34
 */
public class GBK {
    private static final Charset CHARSET = Charset.forName("GBK");

    /**
     * 获取所有GBK编码字符
     */
    public static List<String> getGBK() {
        List<String> words = new ArrayList<>();
        byte[] bytes = new byte[2];

        // GBK/1:GB2312非汉字符号
        for (int b1 = 0xA1; b1 <= 0xA9; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 0xA1; b2 <= 0xFE; b2++) {
                bytes[1] = (byte) b2;
                words.add(new String(bytes, CHARSET));
            }
        }

        // GBK/2:GB2312汉字
        for (int b1 = 0xB0; b1 <= 0xF7; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 0xA1; b2 <= 0xFE; b2++) {
                bytes[1] = (byte) b2;
                words.add(new String(bytes, CHARSET));
            }
        }

        // GBK/3:扩充汉字
        for (int b1 = 0x81; b1 <= 0xA0; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 0x40; b2 <= 0xFE; b2++) {
                bytes[1] = (byte) b2;
                if (b2 != 0x7F) {
                    words.add(new String(bytes, CHARSET));
                }
            }
        }

        // GBK/4:扩充汉字
        for (int b1 = 0xAA; b1 <= 0xFE; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 0x40; b2 <= 0xA0; b2++) {
                bytes[1] = (byte) b2;
                if (b2 != 0x7F) {
                    words.add(new String(bytes, CHARSET));
                }
            }
        }

        // GBK/5:扩充非汉字
        for (int b1 = 0xA8; b1 <= 0xA9; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 0x40; b2 <= 0xA0; b2++) {
                bytes[1] = (byte) b2;
                if (b2 != 0x7F) {
                    words.add(new String(bytes, CHARSET));
                }
            }
        }

        return words;
    }

    public static boolean isGBK(String str) {
        boolean isGBK = false;
        char[] chars = str.toCharArray();
        for (char c : chars) {
            byte[] bytes = String.valueOf(c).getBytes(CHARSET);
            if (bytes.length == 2) { // GBK 编码为两个字节
                int b1 = bytes[0] & 0xff;
                int b2 = bytes[1] & 0xff;
                if (b1 >= 0xA1 && b1 <= 0xA9 && b2 >= 0xA1 & b2 <= 0xFE) {
                    isGBK = true;
                    break;
                }

                if (b1 >= 0xB0 && b1 <= 0xF7 && b2 >= 0xA1 & b2 <= 0xFE) {
                    isGBK = true;
                    break;
                }

                if (b1 >= 0x81 && b1 <= 0xA0 && b2 >= 0x40 & b2 <= 0xFE && b2 != 0x7F) {
                    isGBK = true;
                    break;
                }

                if (b1 >= 0xAA && b1 <= 0xFE && b2 >= 0x40 & b2 <= 0xA0 && b2 != 0x7F) {
                    isGBK = true;
                    break;
                }

                if (b1 >= 0xA8 && b1 <= 0xA9 && b2 >= 0x40 & b2 <= 0xA0 && b2 != 0x7F) {
                    isGBK = true;
                    break;
                }
            }
        }
        return isGBK;
    }
}

/**
 * @author Gao Youbo
 * @since 2022-08-19 10:28
 */
public class Base128 {
    private static final char[] DEFAULT_CHAR_TABLE = {
            '0', '1', '2', '3', '4', '5', '6', '7',
            '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
            'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
            'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
            'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
            'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
            'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
            'u', 'v', 'w', 'x', 'y', 'z', '-', '_',

            'α', 'β', 'γ', 'δ', 'ε', 'ζ', 'η', 'θ',
            'ι', 'κ', 'λ', 'μ', 'ν', 'ξ', 'ο', 'π',
            'ρ', 'ς', 'σ', 'τ', 'υ', 'φ', 'χ', 'ψ',
            'ω', 'à', 'á', 'â', 'ã', 'ä', 'å', 'æ',
            'ç', 'è', 'é', 'ê', 'ë', 'ì', 'í', 'î',
            'ï', 'ð', 'ñ', 'ò', 'ó', 'ô', 'õ', 'ö',
            '÷', 'ø', 'ù', 'ú', 'û', 'ü', 'ý', 'þ',
            'ÿ', 'Ā', 'ā', 'Ă', 'ă', 'Ą', 'ą', 'Ć',
    };

    private final char[] charTable;
    private final HashMap<Character, Integer> indexTable;

    public Base128() {
        this(DEFAULT_CHAR_TABLE);
    }

    public Base128(char[] charTable) {
        this.charTable = charTable;
        this.indexTable = new HashMap<>(charTable.length);
        for (int j = 0; j < charTable.length; j++) {
            indexTable.put(charTable[j], j);
        }
    }

    private String encodeToString(byte[] data) {
        if (data == null || data.length == 0) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        int tail = 0;
        for (int i = 0; i < data.length; i++) {
            int mov = (i % 7 + 1);
            int curr = 0xFF & data[i];
            int code = tail + (curr >> mov);
            sb.append(charTable[code]);
            tail = (0xFF & (curr << (8 - mov))) >> 1;
            if (mov == 7) {
                sb.append(charTable[tail]);
                tail = 0;
            }
        }
        sb.append(charTable[tail]);
        return sb.toString();
    }

    private byte[] decode(String str) {
        if (StringUtils.isBlank(str)) {
            return new byte[]{};
        }
        int length = (int) Math.floor(str.length() * 0.875);
        byte[] result = new byte[length];
        int idx = 0;
        int head = indexTable.get(str.charAt(0)) << 1;
        for (int i = 1; i < str.length(); ) {
            int mod = i % 8;
            int code = indexTable.get(str.charAt(i++));
            result[idx++] = (byte) (0xFF & (head + (code >> (7 - mod))));
            if (mod == 7) {
                head = 0xFF & (indexTable.get(str.charAt(i++)) << 1);
            } else {
                head = 0xFF & (code << (mod + 1));
            }
        }
        return result;
    }
}

private static final Charset CHARSET = Charset.forName("GB2312");

    /**
     * 获取GB2312所有汉字
     * “高位字节”的范围是0xB0-0xF7，“低位字节”的范围是0xA0-0xFE
     */
    private static List<String> getGB2312() {
        List<String> words = new ArrayList<>();
        byte[] bytes = new byte[2];
        for (int b1 = 176; b1 < 248; b1++) {
            bytes[0] = (byte) b1;
            for (int b2 = 161; b2 < 255; b2++) {
                bytes[1] = (byte) b2;
                words.add(new String(bytes, CHARSET));
            }
        }
        return words;
    }

    /**
     * 对于gb2312来讲,首字节码位从0×81至0×FE，尾字节码位分别是0×40至0×FE
     */
    public static boolean isGB2312(String str) {
        boolean isGB2312 = false;
        char[] chars = str.toCharArray();
        for (char c : chars) {
            byte[] bytes = ("" + c).getBytes(CHARSET);
            if (bytes.length == 2) {
                int[] ints = new int[2];
                ints[0] = bytes[0] & 0xff;
                ints[1] = bytes[1] & 0xff;
                if (ints[0] >= 0x81 && ints[0] <= 0xFE && ints[1] >= 0x40 && ints[1] <= 0xFE) {
                    isGB2312 = true;
                    break;
                }
            }
        }
        return isGB2312;
    }

public class IpMatcher {
    public static boolean matchIPV4(String ip, String cidr) {
        String[] ips = ip.split("\\.");
        if (ips.length != 4) {
            return false;
        }
        int ipAddr = (Integer.parseInt(ips[0]) << 24)
                | (Integer.parseInt(ips[1]) << 16)
                | (Integer.parseInt(ips[2]) << 8) | Integer.parseInt(ips[3]);
        int type = Integer.parseInt(cidr.replaceAll(".*/", ""));
        int mask = 0xFFFFFFFF << (32 - type);
        String cidrIp = cidr.replaceAll("/.*", "");
        String[] cidrIps = cidrIp.split("\\.");
        int cidrIpAddr = (Integer.parseInt(cidrIps[0]) << 24)
                | (Integer.parseInt(cidrIps[1]) << 16)
                | (Integer.parseInt(cidrIps[2]) << 8)
                | Integer.parseInt(cidrIps[3]);
        return (ipAddr & mask) == (cidrIpAddr & mask);
    }

    public static void main(String[] args) {
        System.out.println(matchIPV4("172.16.0.1", "172.16.0.0/20"));
    }
}