public static <T> Optional<T> safeCast(Object obj, Class<T> clazz) {
    return clazz.isInstance(obj) ? Optional.of(clazz.cast(obj)) : Optional.empty();
}

public static <T> T measureTime(String label, Supplier<T> supplier) {
    long start = System.nanoTime();
    T result = supplier.get();
    long duration = System.nanoTime() - start;
    System.out.printf("[%s] Duration: %d ms%n", label, duration / 1_000_000);
    return result;
}

@SuppressWarnings("unchecked")
public static <T extends Serializable> T deepCopy(T object) {
    try (
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos)
    ) {
        oos.writeObject(object);
        try (
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais)
        ) {
            return (T) ois.readObject();
        }
    } catch (IOException | ClassNotFoundException e) {
        throw new RuntimeException("Deep copy failed", e);
    }
}

public static List<Path> findFiles(Path root, Predicate<Path> filter) throws IOException {
    try (Stream<Path> stream = Files.walk(root)) {
        return stream.filter(Files::isRegularFile).filter(filter).collect(Collectors.toList());
    }
}

public static <T> T retry(int attempts, Duration delay, Supplier<T> task) {
    for (int i = 1; i <= attempts; i++) {
        try {
            return task.get();
        } catch (Exception e) {
            if (i == attempts) throw e;
            try { Thread.sleep(delay.toMillis()); } catch (InterruptedException ie) { Thread.currentThread().interrupt(); }
        }
    }
    throw new RuntimeException("Retry failed");
}

public static String toQueryString(Map<String, String> params) {
    return params.entrySet().stream()
        .map(e -> URLEncoder.encode(e.getKey(), StandardCharsets.UTF_8) + "=" +
                  URLEncoder.encode(e.getValue(), StandardCharsets.UTF_8))
        .collect(Collectors.joining("&"));
}

public static <T, K> Map<K, List<T>> groupBy(Collection<T> items, Function<T, K> classifier) {
    return items.stream().collect(Collectors.groupingBy(classifier));
}

public static boolean waitFor(Predicate<Void> condition, Duration timeout, Duration interval) {
    long deadline = System.currentTimeMillis() + timeout.toMillis();
    while (System.currentTimeMillis() < deadline) {
        if (condition.test(null)) return true;
        try { Thread.sleep(interval.toMillis()); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
    }
    return false;
}

@SafeVarargs
public static <T> Optional<T> firstNonNull(Supplier<T>... suppliers) {
    for (Supplier<T> supplier : suppliers) {
        T value = supplier.get();
        if (value != null) return Optional.of(value);
    }
    return Optional.empty();
}

public static <E extends Enum<E>> Map<String, E> enumMap(Class<E> enumClass) {
    return Arrays.stream(enumClass.getEnumConstants())
                 .collect(Collectors.toMap(Enum::name, Function.identity()));
}