public class Ipv4PrefixDemo {
    private record Prefix(long network, int length) {
        static Prefix parse(String value) {
            String[] parts = value.split("/", -1);
            if (parts.length != 2 || !parts[1].matches("[0-9]{1,2}")) {
                throw new IllegalArgumentException("invalid CIDR");
            }
            int length = Integer.parseInt(parts[1]);
            if (length > 32) throw new IllegalArgumentException("invalid prefix length");
            return new Prefix(address(parts[0]) & mask(length), length);
        }

        boolean contains(long target) {
            return (target & mask(length)) == network;
        }
    }

    private static long address(String text) {
        String[] parts = text.split("\\.", -1);
        if (parts.length != 4) throw new IllegalArgumentException("invalid IPv4");
        long result = 0;
        for (String part : parts) {
            if (!part.matches("0|[1-9][0-9]{0,2}")) throw new IllegalArgumentException("invalid octet");
            int value = Integer.parseInt(part);
            if (value > 255) throw new IllegalArgumentException("octet exceeds 255");
            result = (result << 8) | value;
        }
        return result;
    }

    private static long mask(int length) {
        return length == 0 ? 0 : (0xffff_ffffL << (32 - length)) & 0xffff_ffffL;
    }

    private static Prefix longest(String target, String... candidates) {
        long numeric = address(target);
        Prefix selected = null;
        for (String candidate : candidates) {
            Prefix prefix = Prefix.parse(candidate);
            if (prefix.contains(numeric) && (selected == null || prefix.length > selected.length)) {
                selected = prefix;
            }
        }
        return selected;
    }

    private static void check(boolean result) {
        if (!result) throw new IllegalStateException("prefix assertion failed");
    }

    public static void main(String[] args) {
        check(Prefix.parse("192.168.10.34/20").network == address("192.168.0.0"));
        check(Prefix.parse("192.168.10.34/20").contains(address("192.168.15.255")));
        check(!Prefix.parse("192.168.10.34/20").contains(address("192.168.16.0")));
        check(Prefix.parse("0.0.0.0/0").contains(address("255.255.255.255")));
        check(Prefix.parse("10.0.0.0/31").contains(address("10.0.0.1")));
        check(Prefix.parse("10.0.0.1/32").contains(address("10.0.0.1")));
        check(!Prefix.parse("10.0.0.1/32").contains(address("10.0.0.0")));
        String[] routes = {"0.0.0.0/0", "10.20.0.0/16", "10.20.30.0/24"};
        check(longest("10.20.30.8", routes).length == 24);
        check(longest("10.20.40.8", routes).length == 16);
        check(longest("198.51.100.8", routes).length == 0);
        check(longest("198.51.100.8", "10.20.0.0/16") == null);
        for (String invalid : new String[]{"256.1.1.1/24", "01.1.1.1/24", "1.2.3/24", "1.2.3.4/33", "1.2.3.4/-1"}) {
            try {
                Prefix.parse(invalid);
                throw new IllegalStateException("invalid input accepted");
            } catch (IllegalArgumentException expected) {
                check(true);
            }
        }
        System.out.println("/20 normalization, /0 /31 /32 containment: PASS");
        System.out.println("longest prefix /24 /16 /0, no match, invalid inputs: PASS");
    }
}
