Backend: More /shdebug (#2691)

Co-authored-by: hannibal2 <24389977+hannibal00212@users.noreply.github.com>
Co-authored-by: CalMWolfs <94038482+CalMWolfs@users.noreply.github.com>

src/main/java/at/hannibal2/skyhanni/data/HypixelData.kt

@@ -195,6 +195,11 @@ object HypixelData {
     @SubscribeEvent
     fun onDebugDataCollect(event: DebugDataCollectEvent) {
         event.title("Server ID")
+        if (!LorenzUtils.inSkyBlock) {
+            event.addIrrelevant("not in sb")
+            return
+        }
+
         val id = serverId
         if (id == null) {
             event.addData {

src/main/java/at/hannibal2/skyhanni/tweaker/DownloadSourceChecker.java

@@ -1,5 +1,7 @@
 package at.hannibal2.skyhanni.tweaker;
 
+import at.hannibal2.skyhanni.utils.OSUtils;
+
 import javax.swing.JFrame;
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
@@ -32,7 +34,7 @@ public class DownloadSourceChecker {
     };
 
     public static void init() {
-        if (!TweakerUtils.isOnWindows()) return;
+        if (!OSUtils.INSTANCE.isWindows()) return;
         URI host = getDangerousHost();
         if (host != null) {
             openMenu(host);

src/main/java/at/hannibal2/skyhanni/tweaker/TweakerUtils.java

@@ -11,10 +11,6 @@
 
 public class TweakerUtils {
 
-    public static boolean isOnWindows() {
-        return System.getProperty("os.name").toLowerCase().contains("win");
-    }
-
     public static void openUrl(String url) {
         try {
             Desktop.getDesktop().browse(new URI(url));

src/main/java/at/hannibal2/skyhanni/utils/ComputerEnvDebug.kt

@@ -0,0 +1,107 @@
+package at.hannibal2.skyhanni.utils
+
+import at.hannibal2.skyhanni.events.DebugDataCollectEvent
+import at.hannibal2.skyhanni.skyhannimodule.SkyHanniModule
+import at.hannibal2.skyhanni.test.command.ErrorManager
+import at.hannibal2.skyhanni.utils.RegexUtils.matchMatcher
+import at.hannibal2.skyhanni.utils.system.PlatformUtils
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
+
+@SkyHanniModule
+object ComputerEnvDebug {
+
+    @SubscribeEvent
+    fun onDebugDataCollect(event: DebugDataCollectEvent) {
+        os(event)
+        java(event)
+        launcher(event)
+    }
+
+    private fun launcher(event: DebugDataCollectEvent) {
+        event.title("Computer Minecraft Launcher")
+
+        val firstStack = getFirstStack() ?: run {
+            event.addData("Could not load data!")
+            return
+        }
+
+        val (launcher, relevant) = findLauncher(firstStack)
+
+        launcher?.let {
+            if (relevant) {
+                event.addData(it)
+            } else {
+                event.addIrrelevant(it)
+            }
+            return
+        }
+
+        event.addData {
+            add("Unknown launcher!")
+            add("firstStack: '$firstStack'")
+        }
+    }
+
+    // TODO put into repo
+    private fun findLauncher(firstStack: String): Pair<String?, Boolean> {
+        if (firstStack.contains("net.fabricmc.devlaunchinjector.Main.main")) {
+            return Pair("Dev Env", false)
+        }
+        if (firstStack.contains("net.minecraft.launchwrapper.Launch.main")) {
+            return Pair("Vanilla Launcher", false)
+        }
+        if (firstStack.contains("org.prismlauncher.EntryPoint.main")) {
+            return Pair("Prism", false)
+        }
+        if (firstStack.contains("net.digitalingot.vendor.")) {
+            return Pair("Feather Client", true)
+        }
+        return Pair(null, true)
+    }
+
+    private fun getFirstStack(): String? {
+        val firstStack = try {
+            Thread.currentThread().stackTrace.last().toString()
+        } catch (e: Exception) {
+            ErrorManager.logErrorWithData(e, "Failed loading current thread stack trace info")
+            null
+        }
+        return firstStack
+    }
+
+    private fun java(event: DebugDataCollectEvent) {
+        event.title("Computer Java Version")
+        val version = System.getProperty("java.version")
+        val pattern = "1\\.8\\.0_(?<update>.*)".toPattern()
+        pattern.matchMatcher(version) {
+            group("update").toIntOrNull()?.let {
+                val devEnvironment = PlatformUtils.isDevEnvironment
+                if (it < 300 && !devEnvironment) {
+                    event.addData("Old update: $it")
+                } else {
+                    if (devEnvironment) {
+                        event.addIrrelevant("Update version: $it (dev env)")
+                    } else {
+                        event.addIrrelevant("New update: $it")
+                    }
+                }
+                return
+            }
+        }
+        event.addData("Unknwon java version: '$version'")
+    }
+
+    private fun os(event: DebugDataCollectEvent) {
+        event.title("Computer Operating System")
+        val osType = OSUtils.getOperatingSystem()
+        val exactName = OSUtils.getOperatingSystemRaw()
+        if (osType != OSUtils.OperatingSystem.UNKNOWN) {
+            event.addIrrelevant {
+                add("OS type: $osType")
+                add("Exact name: $exactName")
+            }
+        } else {
+            event.addData("Unknwon OS: '$exactName'")
+        }
+    }
+}

src/main/java/at/hannibal2/skyhanni/utils/ComputerTimeOffset.kt

@@ -112,11 +112,16 @@ object ComputerTimeOffset {
     @SubscribeEvent
     fun onDebugCollect(event: DebugDataCollectEvent) {
         event.title("Time Offset")
-        val relevant = offsetMillis?.absoluteValue?.let { it < 100.milliseconds } ?: true
+        val offset = offsetMillis ?: run {
+            event.addIrrelevant("not calculated yet")
+            return
+        }
+
+        val relevant = offset.absoluteValue > 500.milliseconds
         if (relevant) {
-            event.addData(offsetMillis.toString())
+            event.addData(offset.toString())
         } else {
-            event.addIrrelevant(offsetMillis.toString())
+            event.addIrrelevant(offset.toString())
         }
     }
 }

src/main/java/at/hannibal2/skyhanni/utils/OSUtils.kt

@@ -7,15 +7,37 @@ import java.net.URI
 
 object OSUtils {
 
+    enum class OperatingSystem {
+        LINUX,
+        SOLARIS,
+        WINDOWS,
+        MACOS,
+        UNKNOWN,
+    }
+
+    fun getOperatingSystemRaw(): String = System.getProperty("os.name")
+
+    fun getOperatingSystem(): OperatingSystem {
+        val osName = getOperatingSystemRaw().lowercase()
+        return when {
+            osName.contains("win") -> OperatingSystem.WINDOWS
+            osName.contains("mac") -> OperatingSystem.MACOS
+            osName.contains("solaris") || osName.contains("sunos") -> OperatingSystem.SOLARIS
+            osName.contains("linux") || osName.contains("unix") -> OperatingSystem.LINUX
+
+            else -> OperatingSystem.UNKNOWN
+        }
+    }
+
     val isWindows: Boolean
     val isMac: Boolean
     val isLinux: Boolean
 
     init {
-        val os = System.getProperty("os.name")
-        isWindows = os.contains("win", ignoreCase = true)
-        isMac = os.contains("mac", ignoreCase = true)
-        isLinux = os.contains("linux", ignoreCase = true)
+        val os = getOperatingSystem()
+        isWindows = os == OperatingSystem.WINDOWS
+        isMac = os == OperatingSystem.MACOS
+        isLinux = os == OperatingSystem.LINUX
     }
 
     @JvmStatic