refactor: improve HttpService robustness and add localhost detection

- Add UrlUtils.isLocalhost() supporting IPv6 localhost variants
- Skip starting mod HTTP server when endpoint is localhost
- Add MetricsHandler for /api/metrics endpoint
- Add reinitialize() for dynamic endpoint changes
- Remove shutdownNow() calls to avoid forced thread termination
- Add endpoint change callback support in ConfigAccess
- Improve getNetworkUrl() to handle trailing slash correctly

Author: WhatDamon

src/main/java/org/damon233/performtrackermod/PerformTracker.java

@@ -65,13 +65,22 @@ public void onInitialize() {
 			} else {
 				// Network was disabled - stop server and clear HttpService
 				if (httpService != null) {
+					httpService.stop();
 					httpService.stopServer();
 					httpService = null;
 					LOGGER.info("HttpService unloaded due to network being disabled.");
 				}
 			}
 		});
 
+		// Register callback for network endpoint changes
+		ConfigAccess.setOnNetworkEndpointChanged(() -> {
+			if (httpService != null && ConfigAccess.isNetworkEnabled()) {
+				httpService.reinitialize(ConfigAccess.getNetworkUrl());
+				LOGGER.info("HttpService reinitialized with new endpoint: {}", ConfigAccess.getNetworkUrl());
+			}
+		});
+		
 		ServerLifecycleEvents.SERVER_STOPPING.register(server -> {
 			if (httpService != null) {
 				httpService.stopServer();

src/main/java/org/damon233/performtrackermod/config/ConfigAccess.java

@@ -147,7 +147,11 @@ public static String getNetworkEndpoint() {
     }
 
     public static String getNetworkUrl() {
-        return getNetworkEndpoint() + API_PATH;
+        String endpoint = getNetworkEndpoint();
+        if (endpoint.endsWith("/")) {
+            return endpoint + API_PATH.substring(1);
+        }
+        return endpoint + API_PATH;
     }
 
     public static int getLocalServerPort() {
@@ -245,30 +249,45 @@ public static void setNetworkEnabled(boolean enabled) {
         if (configData != null) {
             configData.networkEnabled = enabled;
             save();
-            notifyNetworkEnabledChanged(enabled);
+            notifyNetworkEnabledChanged();
         }
     }
 
     public static void setNetworkEndpoint(String endpoint) {
         if (configData != null) {
             String validated = validateNetworkEndpoint(endpoint);
+            String oldEndpoint = configData.networkEndpoint;
             configData.networkEndpoint = validated != null ? validated : DEFAULT_NETWORK_ENDPOINT;
             save();
+            if (configData.networkEnabled && !configData.networkEndpoint.equals(oldEndpoint)) {
+                notifyNetworkEndpointChanged();
+            }
         }
     }
 
     private static Runnable networkEnabledCallback;
+    private static Runnable networkEndpointCallback;
 
     public static void setOnNetworkEnabledChanged(Runnable callback) {
         networkEnabledCallback = callback;
     }
+    
+    public static void setOnNetworkEndpointChanged(Runnable callback) {
+        networkEndpointCallback = callback;
+    }
 
-    private static void notifyNetworkEnabledChanged(boolean enabled) {
+    private static void notifyNetworkEnabledChanged() {
         if (networkEnabledCallback != null) {
             networkEnabledCallback.run();
         }
     }
 
+    private static void notifyNetworkEndpointChanged() {
+        if (networkEndpointCallback != null) {
+            networkEndpointCallback.run();
+        }
+    }
+
     public static String validateNetworkEndpoint(String endpoint) {
         if (endpoint == null || endpoint.isBlank()) {
             return null;

src/main/java/org/damon233/performtrackermod/network/HttpService.java

@@ -22,10 +22,12 @@
 import org.damon233.performtrackermod.collector.SystemInfoCollector;
 import org.damon233.performtrackermod.config.ConfigAccess;
 import org.damon233.performtrackermod.data.SystemInfo;
+import org.damon233.performtrackermod.utils.UrlUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.InetSocketAddress;
 import java.net.URI;
@@ -85,6 +87,18 @@ public void initialize(String remoteUrl) {
                 .build();
     }
 
+    public void reinitialize(String remoteUrl) {
+        boolean wasRunning = serverRunning.get();
+        if (wasRunning) {
+            stopServer();
+        }
+        stopSender();
+        initialize(remoteUrl);
+        if (wasRunning) {
+            tryStartServer();
+        }
+    }
+    
     public synchronized void start() {
         startSender();
     }
@@ -97,12 +111,19 @@ public synchronized boolean tryStartServer() {
     }
 
     private boolean startServerInternal() {
+        String bindHost = ConfigAccess.getLocalServerHost();
+        
+        if (UrlUtils.isLocalhost(bindHost)) {
+            LOGGER.info("HttpService server not started: endpoint is localhost, assuming external server handles requests");
+            return false;
+        }
+        
         try {
-            String bindHost = ConfigAccess.getLocalServerHost();
             server = HttpServer.create(new InetSocketAddress(bindHost, localPort), 0);
             server.setExecutor(serverExecutor);
 
             server.createContext("/api/deviceinfo", new DeviceInfoHandler());
+            server.createContext("/api/metrics", new MetricsHandler());
 
             server.start();
             serverRunning.set(true);
@@ -128,7 +149,7 @@ public synchronized void stop() {
     public synchronized void stopServer() {
         if (server != null && serverRunning.compareAndSet(true, false)) {
             server.stop(0);
-            serverExecutor.shutdownNow();
+            server = null;
             LOGGER.info("HttpService server stopped");
         }
     }
@@ -140,7 +161,6 @@ private void stopSender() {
                 sendQueue.poll();
                 dropped++;
             }
-            senderExecutor.shutdownNow();
             LOGGER.info("HttpService sender stopped, {} items dropped", dropped);
         }
     }
@@ -238,4 +258,41 @@ private void sendResponse(HttpExchange exchange, int statusCode, String body) {
             }
         }
     }
+
+    private static class MetricsHandler implements HttpHandler {
+        @Override
+        public void handle(HttpExchange exchange) {
+            if (!"POST".equalsIgnoreCase(exchange.getRequestMethod())) {
+                sendResponse(exchange, 405, "{\"error\":\"Method not allowed\"}");
+                return;
+            }
+            
+            try {
+                int contentLength = Integer.parseInt(exchange.getRequestHeaders().getFirst("Content-Length"));
+                if (contentLength > 0) {
+                    try (InputStream is = exchange.getRequestBody()) {
+                        byte[] body = is.readAllBytes();
+                        LOGGER.debug("Received metrics payload: {} bytes", body.length);
+                    }
+                }
+            } catch (Exception e) {
+                LOGGER.debug("Failed to read metrics payload: {}", e.getMessage());
+            }
+            
+            sendResponse(exchange, 200, "{\"status\":\"ok\"}");
+        }
+        
+        private void sendResponse(HttpExchange exchange, int statusCode, String body) {
+            try {
+                exchange.getResponseHeaders().set("Content-Type", "application/json");
+                byte[] bytes = body.getBytes(StandardCharsets.UTF_8);
+                exchange.sendResponseHeaders(statusCode, bytes.length);
+                try (OutputStream os = exchange.getResponseBody()) {
+                    os.write(bytes);
+                }
+            } catch (IOException e) {
+                LOGGER.debug("Failed to send response: {}", e.getMessage());
+            }
+        }
+    }
 }

src/main/java/org/damon233/performtrackermod/utils/UrlUtils.java

@@ -19,6 +19,10 @@
 import java.net.URI;
 
 public class UrlUtils {
+    private static final String[] LOCALHOST_HOSTS = {
+        "localhost", "127.0.0.1", "::1", "0:0:0:0:0:0:0:1"
+    };
+    
     public static int parsePort(String url) {
         try {
             URI uri = URI.create(url);
@@ -42,4 +46,17 @@ public static String parseHost(String url) {
         }
         return "localhost";
     }
+    
+    public static boolean isLocalhost(String host) {
+        if (host == null) {
+            return true;
+        }
+        String lowerHost = host.toLowerCase();
+        for (String localhost : LOCALHOST_HOSTS) {
+            if (localhost.equals(lowerHost)) {
+                return true;
+            }
+        }
+        return false;
+    }
 }