This should fix all issues regarding the "latest" version for all server types

src/main/java/net/knarcraft/minecraftserverlauncher/server/ServerVersionContainer.java

@@ -1,9 +1,19 @@
 package net.knarcraft.minecraftserverlauncher.server;
 
+import net.knarcraft.minecraftserverlauncher.Main;
+import net.knarcraft.minecraftserverlauncher.utility.CommonFunctions;
+
+import java.io.*;
+import java.util.HashMap;
 import java.util.Map;
 
+/**
+ * This class acts as a container for all "latest" server versions
+ */
 public class ServerVersionContainer implements java.io.Serializable {
 
+    private static ServerVersionContainer serverVersionContainer;
+    private String versionFile = Main.getApplicationWorkDirectory() + File.separator + "files" + File.separator + "versions.csv";
     private String vanillaVersion;
     private String snapshotVersion;
     private String bungeeVersion;
@@ -11,10 +21,157 @@ public class ServerVersionContainer implements java.io.Serializable {
     private String travertineVersion;
     private Map<String, String> spongeVanillaVersions;
 
-    public ServerVersionContainer() {
-
+    /**
+     * Initializes a new server version container
+     */
+    private ServerVersionContainer() {
+        spongeVanillaVersions = new HashMap<>();
+        loadState();
     }
 
+    /**
+     * Gives a server version container instance
+     *
+     * @return <p>A server version container instance</p>
+     */
+    public static ServerVersionContainer getInstance() {
+        if (serverVersionContainer == null) {
+            serverVersionContainer = new ServerVersionContainer();
+        }
+        return serverVersionContainer;
+    }
+
+    /**
+     * Resets the state of the server version container
+     */
+    public void reset() {
+        this.vanillaVersion = null;
+        this.snapshotVersion = null;
+        this.bungeeVersion = null;
+        this.waterfallVersion = null;
+        this.travertineVersion = null;
+        this.spongeVanillaVersions = new HashMap<>();
+    }
+
+    @Override
+    public String toString() {
+        return "vanillaVersion;" + vanillaVersion + "\n" +
+                "snapshotVersion;" + snapshotVersion + "\n" +
+                "bungeeVersion;" + bungeeVersion + "\n" +
+                "waterfallVersion;" + waterfallVersion + "\n" +
+                "travertineVersion;" + travertineVersion + "\n" +
+                "spongeVanillaVersions;" +
+                mapToString(spongeVanillaVersions);
+    }
+
+    /**
+     * Formats a map to a string given a map
+     *
+     * @param targetMap <p>The map to format</p>
+     * @return <p>A string representing the map</p>
+     */
+    private String mapToString(Map<?, ?> targetMap) {
+        StringBuilder stringBuilder = new StringBuilder();
+        int mapSize = targetMap.keySet().size();
+        int mapIndex = 0;
+        for (Object key : targetMap.keySet()) {
+            stringBuilder.append(key).append("!").append(targetMap.get(key));
+            if (mapIndex < mapSize) {
+                stringBuilder.append(",");
+            }
+            mapIndex++;
+        }
+        return stringBuilder.toString();
+    }
+
+    /**
+     * Tries to save the state of this server version container
+     */
+    public void saveState() {
+        PrintWriter file;
+        try {
+            file = new PrintWriter(versionFile);
+            file.println(this.toString());
+            file.close();
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Loads the object state from the save file
+     */
+    private void loadState() {
+        BufferedReader reader;
+        if (!new File(versionFile).exists()) {
+            return;
+        }
+        try {
+            reader = new BufferedReader(new InputStreamReader(new FileInputStream(versionFile)));
+            String currentData = CommonFunctions.readBufferedReader(reader);
+            for (String line : currentData.split("\n")) {
+                parseSaveLine(line);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Parses one line in the version save file and updates the appropriate variable
+     *
+     * @param line <p>The line from the save file to parse</p>
+     */
+    private void parseSaveLine(String line) {
+        String[] lineData = line.split(";");
+        if (lineData.length != 2) {
+            return;
+        }
+        String variableKey = lineData[0];
+        String variableValue = lineData[1];
+        switch (variableKey) {
+            case "vanillaVersion":
+                vanillaVersion = variableValue;
+                break;
+            case "snapshotVersion":
+                snapshotVersion = variableValue;
+                break;
+            case "bungeeVersion":
+                bungeeVersion = variableValue;
+                break;
+            case "waterfallVersion":
+                waterfallVersion = variableValue;
+                break;
+            case "travertineVersion":
+                travertineVersion = variableValue;
+                break;
+            case "spongeVanillaVersions":
+                parseSpongeVanillaVersions(variableValue);
+                break;
+            default:
+                throw new IllegalArgumentException("Invalid key encountered in the server version file.");
+        }
+    }
+
+    /**
+     * Reads spongeVanilla versions from a text string and updates the version map
+     *
+     * @param data <p>The data string to parse</p>
+     */
+    private void parseSpongeVanillaVersions(String data) {
+        String[] versions = data.split(",");
+        for (String version : versions) {
+            String[] versionData = version.split("!");
+            spongeVanillaVersions.put(versionData[0], versionData[1]);
+        }
+    }
+
+
+    /**
+     * Gets the current vanilla version
+     *
+     * @return <p>The current vanilla version</p>
+     */
     public String getVanillaVersion() {
         return this.vanillaVersion;
     }
@@ -23,65 +180,126 @@ public class ServerVersionContainer implements java.io.Serializable {
      * Sets the vanilla server version
      *
      * @param newVersion <p>The new vanilla server version</p>
-     * @return <p>This object</p>
      */
-    public ServerVersionContainer setVanillaVersion(String newVersion) {
+    public void setVanillaVersion(String newVersion) {
         this.vanillaVersion = newVersion;
-        return this;
+        saveState();
     }
 
+    /**
+     * Gets the current snapshot version
+     *
+     * @return <p>The current snapshot version</p>
+     */
     public String getSnapshotVersion() {
         return this.snapshotVersion;
     }
 
-    public ServerVersionContainer setSnapshotVersion(String newVersion) {
+    /**
+     * Sets the snapshot server version
+     *
+     * @param newVersion <p>The new snapshot server version</p>
+     */
+    public void setSnapshotVersion(String newVersion) {
         this.snapshotVersion = newVersion;
-        return this;
+        saveState();
     }
 
+    /**
+     * Gets the current bungee version
+     *
+     * @return <p>The current bungee version</p>
+     */
     public String getBungeeVersion() {
         return this.bungeeVersion;
     }
 
-    public ServerVersionContainer setBungeeVersion(String newVersion) {
+    /**
+     * Sets the bungee server version
+     *
+     * @param newVersion <p>The new bungee server version</p>
+     */
+    public void setBungeeVersion(String newVersion) {
         this.bungeeVersion = newVersion;
-        return this;
+        saveState();
     }
 
+    /**
+     * Gets the current waterfall version
+     *
+     * @return <p>The current waterfall version</p>
+     */
     public String getWaterfallVersion() {
         return this.waterfallVersion;
     }
 
-    public ServerVersionContainer setWaterfallVersion(String newVersion) {
+    /**
+     * Sets the waterfall server version
+     *
+     * @param newVersion <p>The new waterfall server version</p>
+     */
+    public void setWaterfallVersion(String newVersion) {
         this.waterfallVersion = newVersion;
-        return this;
+        saveState();
     }
 
+    /**
+     * Gets the current travertine server version
+     *
+     * @return <p>The current travertine version</p>
+     */
     public String getTravertineVersion() {
         return this.travertineVersion;
     }
 
-    public ServerVersionContainer setTravertineVersion(String newVersion) {
+    /**
+     * Sets the travertine server version
+     *
+     * @param newVersion <p>The new travertine server version</p>
+     */
+    public void setTravertineVersion(String newVersion) {
         this.travertineVersion = newVersion;
-        return this;
+        saveState();
     }
 
+    /**
+     * Gets the entire sponge vanilla version map
+     *
+     * @return <p>The entire sponge vanilla version map</p>
+     */
     public Map<String, String> getSpongeVanillaVersions() {
         return this.spongeVanillaVersions;
     }
 
+    /**
+     * Gets a specific sponge vanilla version
+     *
+     * @param versionKey <p>The version to check current version of</p>
+     * @return <p>The current sponge vanilla version</p>
+     */
     public String getSpongeVanillaVersion(String versionKey) {
         return spongeVanillaVersions.get(versionKey);
     }
 
-    public ServerVersionContainer setSpongeVanillaVersion(Map<String, String> newVersions) {
+    /**
+     * Replaces the entire sponge vanilla version map
+     *
+     * @param newVersions <p>The new version map to use</p>
+     */
+    public void setSpongeVanillaVersion(Map<String, String> newVersions) {
         this.spongeVanillaVersions = newVersions;
-        return this;
+        saveState();
     }
 
-    public ServerVersionContainer setSpongeVanillaVersion(String mapKey, String newValue) {
+    /**
+     * Sets the current version for a given sponge vanilla version
+     *
+     * @param mapKey   <p>The version key to set version for</p>
+     * @param newValue <p>The new current version</p>
+     */
+    public void setSpongeVanillaVersion(String mapKey, String newValue) {
         spongeVanillaVersions.put(mapKey, newValue);
-        return this;
+        saveState();
     }
 
 }