Support MyPet 4 entity lookup while retaining MyPet 3 compatibility

pom.xml

@@ -176,11 +176,9 @@
 		<!-- MyPet -->
 		<dependency>
 			<groupId>de.keyle</groupId>
-			<artifactId>mypet</artifactId>
-			<version>3.11-SNAPSHOT</version>
-			<scope>system</scope>
-			<!-- Temporary solution for replacing repository -->
-			<systemPath>${basedir}/libs/mypet-3.12.jar</systemPath>
+			<artifactId>mypet-api</artifactId>
+			<version>4.0.0</version>
+			<scope>provided</scope>
 		</dependency>
 		<!-- PyroFishingPro -->
 		<dependency>
@@ -272,10 +270,10 @@
 			<url>https://repo.codemc.io/repository/EvenMoreFish/</url>
 		</repository>
 		<!-- MyPet -->
-		<!--		<repository>-->
-		<!--			<id>mypet-repo</id>-->
-		<!--			<url>https://repo.mypet-plugin.de/</url>-->
-		<!--		</repository>-->
+		<repository>
+			<id>mypet-releases</id>
+			<url>https://repo.userderezzed.dev/releases</url>
+		</repository>
 	</repositories>
 	<!-- Builds Plugin -->
 	<build>

src/main/java/com/gamingmesh/jobs/hooks/MyPet/MyPetManager.java

@@ -1,48 +1,113 @@
 package com.gamingmesh.jobs.hooks.MyPet;
 
+import java.lang.reflect.Method;
 import java.util.UUID;
 
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 
 import de.Keyle.MyPet.MyPetApi;
-import de.Keyle.MyPet.api.entity.MyPet;
-import de.Keyle.MyPet.api.entity.MyPetBukkitEntity;
-import de.Keyle.MyPet.api.player.MyPetPlayer;
-import de.Keyle.MyPet.api.repository.PlayerManager;
+import de.Keyle.MyPet.api.entity.Pet;
 
 public class MyPetManager {
 
-    private final PlayerManager mp = MyPetApi.getPlayerManager();
+    private final boolean legacyApi;
+    private final LegacyApi legacy;
+
+    public MyPetManager() {
+        boolean legacyApi = false;
+        LegacyApi legacy = null;
+
+        try {
+            MyPetApi.class.getMethod("getPetManager");
+        } catch (NoSuchMethodException ignored) {
+            legacyApi = true;
+            legacy = LegacyApi.create();
+        }
+
+        this.legacyApi = legacyApi;
+        this.legacy = legacy;
+    }
 
     public boolean isMyPet(Entity entity, Player owner) {
-	if (owner == null) {
-	    return entity instanceof MyPetBukkitEntity;
-	}
+        UUID petOwner = getOwner(entity);
+        return petOwner != null && (owner == null || petOwner.equals(owner.getUniqueId()));
+    }
+
+    public UUID getOwnerOfPet(Entity entity) {
+        return getOwner(entity);
+    }
 
-	if (!mp.isMyPetPlayer(owner)) {
-	    return false;
-	}
+    private UUID getOwner(Entity entity) {
+        if (legacyApi) {
+            return legacy == null ? null : legacy.getOwner(entity);
+        }
+        return ModernApi.getOwner(entity);
+    }
 
-	MyPetPlayer myPetPlayer = mp.getMyPetPlayer(owner);
-	if (!myPetPlayer.hasMyPet()) {
-	    return false;
-	}
+    private static final class ModernApi {
 
-	java.util.Optional<MyPetBukkitEntity> opt = myPetPlayer.getMyPet().getEntity();
-	return opt.isPresent() && opt.get().getType() == entity.getType();
+        private static UUID getOwner(Entity entity) {
+            Pet pet = MyPetApi.getPetManager().getPetFromEntity(entity);
+            return pet == null || pet.getOwner() == null ? null : pet.getOwner().getUniqueId();
+        }
     }
 
-    public UUID getOwnerOfPet(Entity ent) {
-	if (!(ent instanceof MyPetBukkitEntity))
-	    return null;
+    private static final class LegacyApi {
+
+        private final Class<?> petEntityClass;
+        private final Method getMyPet;
+        private final Method getOwner;
+        private final Method getPlayer;
+
+        private LegacyApi(Class<?> petEntityClass, Method getMyPet, Method getOwner, Method getPlayer) {
+            this.petEntityClass = petEntityClass;
+            this.getMyPet = getMyPet;
+            this.getOwner = getOwner;
+            this.getPlayer = getPlayer;
+        }
+
+        private static LegacyApi create() {
+            try {
+                ClassLoader classLoader = MyPetApi.class.getClassLoader();
+                Class<?> petEntityClass = Class.forName("de.Keyle.MyPet.api.entity.MyPetBukkitEntity", false,
+                    classLoader);
+                Class<?> myPetClass = Class.forName("de.Keyle.MyPet.api.entity.MyPet", false, classLoader);
+                Class<?> myPetPlayerClass = Class.forName("de.Keyle.MyPet.api.player.MyPetPlayer", false,
+                    classLoader);
+
+                return new LegacyApi(
+                    petEntityClass,
+                    petEntityClass.getMethod("getMyPet"),
+                    myPetClass.getMethod("getOwner"),
+                    myPetPlayerClass.getMethod("getPlayer"));
+            } catch (ReflectiveOperationException e) {
+                MyPetApi.getLogger().warning("Jobs could not initialize its MyPet 3 integration: " + e.getMessage());
+                return null;
+            }
+        }
+
+        private UUID getOwner(Entity entity) {
+            if (!petEntityClass.isInstance(entity)) {
+                return null;
+            }
+
+            try {
+                Object pet = getMyPet.invoke(entity);
+                if (pet == null) {
+                    return null;
+                }
 
-	MyPet myPet = ((MyPetBukkitEntity) ent).getMyPet();
+                Object owner = getOwner.invoke(pet);
+                if (owner == null) {
+                    return null;
+                }
 
-	try {
-	    return myPet.getOwner().getPlayer().getUniqueId();
-	} catch (Exception e) {
-	    return null;
-	}
+                Object player = getPlayer.invoke(owner);
+                return player instanceof Player ? ((Player) player).getUniqueId() : null;
+            } catch (ReflectiveOperationException | ClassCastException e) {
+                return null;
+            }
+        }
     }
 }