FFmpegConvert/src/main/java/net/knarcraft/ffmpegconverter/config/ConfigHandler.java

package net.knarcraft.ffmpegconverter.config;

import net.knarcraft.ffmpegconverter.utility.FileHelper;
import net.knarcraft.ffmpegconverter.utility.OutputUtil;
import org.apache.commons.configuration2.Configuration;
import org.apache.commons.configuration2.PropertiesConfiguration;
import org.apache.commons.configuration2.builder.FileBasedConfigurationBuilder;
import org.apache.commons.configuration2.builder.fluent.Configurations;
import org.apache.commons.configuration2.ex.ConfigurationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
 * A handler for dealing with configurations
 */
public class ConfigHandler {

    private final File configFolder = new File("conf").getAbsoluteFile();
    private final Configurations configurations = new Configurations();
    private final File settingsFile = new File(configFolder, "config.properties");
    private FileBasedConfigurationBuilder<PropertiesConfiguration> builder = configurations.propertiesBuilder(settingsFile);
    private final Map<ConfigKey<?>, Object> optionValues = new HashMap<>();

    /**
     * Gets the current value of a configuration option
     *
     * @param key <p>The configuration key to get the value of</p>
     * @return <p>The current value</p>
     */
    @Nullable
    public Object getValue(@NotNull ConfigKey<?> key) {
        return optionValues.get(key);
    }

    /**
     * Gets a writable configuration used for changing settings
     *
     * @return <p>A writable properties configuration</p>
     */
    @NotNull
    public PropertiesConfiguration getWritableConfiguration() {
        try {
            return builder.getConfiguration();
        } catch (ConfigurationException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Writes the writable configuration to disk
     */
    public void writeConfiguration() {
        OutputUtil.printDebug("Preparing to save config");
        if (!configFolder.exists() && !configFolder.mkdir()) {
            throw new RuntimeException("Unable to create config folder. Make sure to run this .jar file from a " +
                    "writable directory!");
        }
        try {
            if (!settingsFile.exists() && !settingsFile.createNewFile()) {
                OutputUtil.println("Failed to create configuration file.");
            }
        } catch (IOException e) {
            OutputUtil.println("Failed to create configuration file.");
        }
        try {
            builder.save();
        } catch (ConfigurationException e) {
            throw new RuntimeException(e);
        }
        OutputUtil.printDebug("Saved available hardware encoder handler");
    }

    /**
     * Loads the saved configuration file
     */
    public void load() throws IOException {
        optionValues.clear();
        Configuration configuration;
        if (!settingsFile.exists()) {
            configuration = new PropertiesConfiguration();
            BufferedReader reader = FileHelper.getBufferedReaderForInternalFile("/conf/config.properties");
            Map<String, String> entries = FileHelper.readKeyValuePairs(reader, "=");
            for (Map.Entry<String, String> entry : entries.entrySet()) {
                configuration.setProperty(entry.getKey(), entry.getValue());
            }
        } else {
            try {
                configuration = configurations.properties(settingsFile);
            } catch (ConfigurationException e) {
                throw new RuntimeException(e);
            }
        }
        // Reload contents in the builder
        builder = configurations.propertiesBuilder(settingsFile);

        for (@NotNull ConfigKey<?> key : ConfigKey.values()) {
            if (configuration.containsKey(key.toString())) {
                optionValues.put(key, configuration.get(key.getType(), key.toString()));
            } else {
                optionValues.put(key, key.getDefaultValue());
            }
        }
    }

}