Add utilities to detect and replace broken links.

application/src/main/java/org/togetherjava/tjbot/features/utils/LinkDetection.java

@@ -4,14 +4,27 @@
 import com.linkedin.urls.detection.UrlDetector;
 import com.linkedin.urls.detection.UrlDetectorOptions;
 
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.CompletableFuture;
 
 /**
  * Utility class to detect links.
  */
 public class LinkDetection {
+    private static final HttpClient HTTP_CLIENT =
+            HttpClient.newBuilder().followRedirects(HttpClient.Redirect.NORMAL).build();
+
+    /**
+     * Default filters used when extracting links: skip suppressed URLs and non-http schemes.
+     */
+    private static final Set<LinkFilter> DEFAULT_EXTRACT_FILTERS =
+            Set.of(LinkFilter.SUPPRESSED, LinkFilter.NON_HTTP_SCHEME);
 
     /**
      * Possible ways to filter a link.
@@ -55,7 +68,120 @@ public static List<String> extractLinks(String content, Set<LinkFilter> filter)
      * @return true if the content contains at least one link
      */
     public static boolean containsLink(String content) {
-        return !(new UrlDetector(content, UrlDetectorOptions.BRACKET_MATCH).detect().isEmpty());
+        return !new UrlDetector(content, UrlDetectorOptions.BRACKET_MATCH).detect().isEmpty();
+    }
+
+    /**
+     * Checks whether the given URL is considered broken.
+     *
+     * <p>
+     * A link is considered broken if:
+     * <ul>
+     * <li>An HTTP request fails</li>
+     * <li>The HTTP response status code is outside the 200–399 range</li>
+     * </ul>
+     *
+     * <p>
+     * Notes:
+     * <ul>
+     * <li>Status code {@code 200} is considered valid, even if the response body is empty</li>
+     * <li>The response body content is not inspected</li>
+     * </ul>
+     *
+     * @param url the URL to check
+     * @return a future completing with {@code true} if the link is broken
+     * @throws IllegalArgumentException if the given URL is not a valid URI
+     */
+
+
+    public static CompletableFuture<Boolean> isLinkBroken(String url) {
+        // Quick check with HEAD "cheaper". If HEAD indicates failure some servers don't implement
+        // HEAD properly,
+        // fall back to GET to confirm the resource status.
+        HttpRequest headCheckRequest = HttpRequest.newBuilder(URI.create(url))
+            .method("HEAD", HttpRequest.BodyPublishers.noBody())
+            .build();
+
+        return HTTP_CLIENT.sendAsync(headCheckRequest, HttpResponse.BodyHandlers.discarding())
+            .thenApply(response -> {
+                int status = response.statusCode();
+                return status < 200 || status >= 400;
+            })
+            .exceptionally(_ -> true)
+            .thenCompose(result -> {
+                if (!result) {
+                    return CompletableFuture.completedFuture(false);
+                }
+                HttpRequest getFallbackRequest =
+                        HttpRequest.newBuilder(URI.create(url)).GET().build();
+                return HTTP_CLIENT
+                    .sendAsync(getFallbackRequest, HttpResponse.BodyHandlers.discarding())
+                    .thenApply(resp -> resp.statusCode() >= 400)
+                    .exceptionally(ignored -> true); // still never null
+            });
+    }
+
+    /**
+     * Replaces all broken links in the given text with the provided replacement string.
+     *
+     * <p>
+     * The link checks are performed asynchronously.
+     * </p>
+     *
+     * <p>
+     * Example:
+     *
+     * <pre>{@code
+     * replaceDeadLinks("""
+     *         Test
+     *         http://deadlink/1
+     *         http://workinglink/1
+     *         """, "broken")
+     * }</pre>
+     *
+     * <p>
+     * Results in:
+     *
+     * <pre>{@code
+     * Test
+     * broken
+     * http://workinglink/1
+     * }</pre>
+     *
+     * @param text the input text containing URLs
+     * @param replacement the string to replace broken links with
+     * @return a future containing the modified text
+     */
+    public static CompletableFuture<String> replaceDeadLinks(String text, String replacement) {
+        List<String> links = extractLinks(text, DEFAULT_EXTRACT_FILTERS);
+
+        if (links.isEmpty()) {
+            return CompletableFuture.completedFuture(text);
+        }
+
+        List<CompletableFuture<Optional<String>>> deadLinkFutures = links.stream()
+            .distinct()
+            .map(link -> isLinkBroken(link)
+                .thenApply(isBroken -> isBroken ? Optional.of(link) : Optional.<String>empty()))
+            .toList();
+
+
+        return CompletableFuture.allOf(deadLinkFutures.toArray(CompletableFuture[]::new))
+            .thenApply(_ -> deadLinkFutures.stream()
+                .map(CompletableFuture::join)
+                .flatMap(Optional::stream)
+                .toList())
+            .thenApply(deadLinks -> {
+                StringBuilder sb = new StringBuilder(text);
+                for (String deadLink : deadLinks) {
+                    int idx = sb.indexOf(deadLink);
+                    while (idx != -1) {
+                        sb.replace(idx, idx + deadLink.length(), replacement);
+                        idx = sb.indexOf(deadLink, idx + replacement.length());
+                    }
+                }
+                return sb.toString();
+            });
     }
 
     private static Optional<String> toLink(Url url, Set<LinkFilter> filter) {
@@ -76,7 +202,6 @@ private static Optional<String> toLink(Url url, Set<LinkFilter> filter) {
             // Remove trailing punctuation
             link = link.substring(0, link.length() - 1);
         }
-
         return Optional.of(link);
     }