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 {

    private static ServerVersionContainer serverVersionContainer;
    private final String versionFile = Main.getApplicationWorkDirectory() + File.separator + "files" + File.separator + "versions.csv";
    private String vanillaVersion;
    private String snapshotVersion;
    private String bungeeVersion;
    private Map<String, String> waterfallVersions;
    private Map<String, String> travertineVersions;
    private Map<String, String> spongeVanillaVersions;
    private Map<String, String> spongeForgeVersions;
    private String downloadedBuildToolsVersion;

    /**
     * Initializes a new server version container
     */
    private ServerVersionContainer() {
        this.waterfallVersions = new HashMap<>();
        this.travertineVersions = new HashMap<>();
        this.spongeVanillaVersions = new HashMap<>();
        this.spongeForgeVersions = 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
     */
    void reset() {
        this.vanillaVersion = null;
        this.snapshotVersion = null;
        this.bungeeVersion = null;
        this.waterfallVersions = new HashMap<>();
        this.travertineVersions = new HashMap<>();
        this.spongeVanillaVersions = new HashMap<>();
        this.spongeForgeVersions = new HashMap<>();
        this.downloadedBuildToolsVersion = null;
    }

    @Override
    public String toString() {
        return "vanillaVersion;" + vanillaVersion + "\n" +
                "snapshotVersion;" + snapshotVersion + "\n" +
                "bungeeVersion;" + bungeeVersion + "\n" +
                "waterfallVersions;" + mapToString(waterfallVersions) + "\n" +
                "travertineVersions;" + mapToString(travertineVersions) + "\n" +
                "spongeVanillaVersions;" + mapToString(spongeVanillaVersions) + "\n" +
                "spongeForgeVersions;" + mapToString(spongeForgeVersions) + "\n" +
                "downloadedBuildToolsVersion;" + downloadedBuildToolsVersion;
    }

    /**
     * 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
     */
    void saveState() {
        File saveFile = new File(versionFile);
        PrintWriter file;
        try {
            if (!saveFile.exists()) {
                if (!saveFile.getParentFile().exists() && !saveFile.getParentFile().mkdirs()) {
                    throw new FileNotFoundException("Unable to create folder for version file");
                }
                if (!saveFile.createNewFile()) {
                    throw new FileNotFoundException("Unable to create version file");
                }
            }
            file = new PrintWriter(versionFile);
            file.println(this);
            file.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * Loads the object state from the save file
     */
    private void loadState() {
        if (!new File(versionFile).exists()) {
            return;
        }
        try (BufferedReader 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 "waterfallVersions":
                parseVersionsToMap(waterfallVersions, variableValue);
                break;
            case "travertineVersions":
                parseVersionsToMap(travertineVersions, variableValue);
                break;
            case "spongeVanillaVersions":
                parseVersionsToMap(spongeVanillaVersions, variableValue);
                break;
            case "spongeForgeVersions":
                parseVersionsToMap(spongeForgeVersions, variableValue);
                break;
            case "downloadedBuildToolsVersion":
                downloadedBuildToolsVersion = variableValue;
                break;
            default:
                throw new IllegalArgumentException("Invalid key encountered in the server version file.");
        }
    }

    /**
     * Reads versions from a text string and updates the version map
     *
     * @param targetMap <p>The map to update</p>
     * @param data <p>The data string to parse</p>
     */
    private void parseVersionsToMap(Map<String,String> targetMap, String data) {
        String[] versions = data.split(",");
        for (String version : versions) {
            String[] versionData = version.split("!");
            targetMap.put(versionData[0], versionData[1]);
        }
    }


    /**
     * Gets the current vanilla version
     *
     * @return <p>The current vanilla version</p>
     */
    public String getVanillaVersion() {
        return this.vanillaVersion;
    }

    /**
     * Sets the vanilla server version
     *
     * @param newVersion <p>The new vanilla server version</p>
     */
    public void setVanillaVersion(String newVersion) {
        this.vanillaVersion = newVersion;
        saveState();
    }

    /**
     * Gets the current snapshot version
     *
     * @return <p>The current snapshot version</p>
     */
    public String getSnapshotVersion() {
        return this.snapshotVersion;
    }

    /**
     * Sets the snapshot server version
     *
     * @param newVersion <p>The new snapshot server version</p>
     */
    public void setSnapshotVersion(String newVersion) {
        this.snapshotVersion = newVersion;
        saveState();
    }

    /**
     * Gets the current bungee version
     *
     * @return <p>The current bungee version</p>
     */
    public String getBungeeVersion() {
        return this.bungeeVersion;
    }

    /**
     * Sets the bungee server version
     *
     * @param newVersion <p>The new bungee server version</p>
     */
    public void setBungeeVersion(String newVersion) {
        this.bungeeVersion = newVersion;
        saveState();
    }

    /**
     * Gets a specific waterfall version
     *
     * @param versionKey <p>The version to check current version of</p>
     * @return <p>The current waterfall version</p>
     */
    public String getWaterfallVersion(String versionKey) {
        return this.waterfallVersions.get(versionKey);
    }

    /**
     * Sets the current version for a given waterfall version
     *
     * @param mapKey   <p>The version key to set version for</p>
     * @param newValue <p>The new current version</p>
     */
    public void setWaterfallVersion(String mapKey, String newValue) {
        this.waterfallVersions.put(mapKey, newValue);
        saveState();
    }

    /**
     * Gets a specific travertine version
     *
     * @param versionKey <p>The version to check current version of</p>
     * @return <p>The current travertine version</p>
     */
    public String getTravertineVersion(String versionKey) {
        return this.travertineVersions.get(versionKey);
    }

    /**
     * Sets the current version for a given travertine version
     *
     * @param mapKey   <p>The version key to set version for</p>
     * @param newValue <p>The new current version</p>
     */
    public void setTravertineVersion(String mapKey, String newValue) {
        this.travertineVersions.put(mapKey, newValue);
        saveState();
    }

    /**
     * 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);
    }

    /**
     * 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);
        saveState();
    }

    /**
     * Gets a specific sponge forge version
     *
     * @param versionKey <p>The version to check current version of</p>
     * @return <p>The current sponge forge version</p>
     */
    public String getSpongeForgeVersion(String versionKey) {
        return spongeForgeVersions.get(versionKey);
    }

    /**
     * Sets the current version for a given sponge forge version
     *
     * @param mapKey   <p>The version key to set version for</p>
     * @param newValue <p>The new current version</p>
     */
    public void setSpongeForgeVersion(String mapKey, String newValue) {
        spongeForgeVersions.put(mapKey, newValue);
        saveState();
    }

    /**
     * Gets the version of the downloaded BuildTools file
     *
     * @return <p>The version of the downloaded BuildTools file</p>
     */
    public String getDownloadedBuildToolsVersion() {
        return this.downloadedBuildToolsVersion;
    }

    /**
     * Sets the version of the downloaded BuildTools file
     *
     * @param newValue <p>The new version</p></p>
     */
    public void setDownloadedBuildToolsVersion(String newValue) {
        this.downloadedBuildToolsVersion = newValue;
        saveState();
    }

}