Respackopts/src/main/java/io/gitlab/jfronny/respackopts/Respackopts.java

package io.gitlab.jfronny.respackopts;

import com.google.gson.Gson;
import io.gitlab.jfronny.respackopts.data.Config;
import io.gitlab.jfronny.respackopts.data.Respackmeta;
import net.fabricmc.api.ClientModInitializer;
import net.fabricmc.api.EnvType;
import net.fabricmc.api.Environment;
import net.fabricmc.loader.api.FabricLoader;

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashMap;

@Environment(EnvType.CLIENT)
public class Respackopts implements ClientModInitializer {
    public static HashMap<String, HashMap<String, Boolean>> boolVals;
    public static HashMap<String, HashMap<String, Double>> numVals;
    public static HashMap<String, HashMap<String, String>> strVals;
    public static Gson g = new Gson();
    public static GuiFactory factory = new GuiFactory();
    public static final Integer metaVersion = 1;
    public static HashMap<String, Respackmeta> resPackMetas = new HashMap<>();
    public static final String ID = "respackopts";
    static final Path p = FabricLoader.getInstance().getConfigDir().resolve("respackopts");
    @Override
    public void onInitializeClient() {
        load();
        Respackopts.updateShaders();
    }

    public static void save() {
        deNull();
        try {
            Files.createDirectories(p);
        } catch (IOException e) {
            e.printStackTrace();
        }
        for (String s : resPackMetas.keySet()) {
            s = resPackMetas.get(s).id;
            Config cfg = new Config();
            if (boolVals.containsKey(s))
                cfg.bools = boolVals.get(s);
            if (numVals.containsKey(s))
                cfg.doubles = numVals.get(s);
            if (strVals.containsKey(s))
                cfg.strings = strVals.get(s);
            Path q = p.resolve(s + ".json");
            try {
                Writer writer = Files.newBufferedWriter(q);
                g.toJson(cfg, writer);
                writer.flush();
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void load() {
        try {
            for (String s : resPackMetas.keySet()) {
                s = resPackMetas.get(s).id;
                Path q = p.resolve(s + ".json");
                if (Files.exists(q)) {
                    try {
                        Reader reader = Files.newBufferedReader(q);
                        Config c = g.fromJson(reader, Config.class);
                        reader.close();
                        if (c.bools != null)
                            boolVals.put(s, c.bools);
                        if (c.doubles != null)
                            numVals.put(s, c.doubles);
                        if (c.strings != null)
                            strVals.put(s, c.strings);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
        deNull();
    }

    public static void deNull() {
        if (boolVals == null)
            boolVals = new HashMap<>();
        if (numVals == null)
            numVals = new HashMap<>();
        if (strVals == null)
            strVals = new HashMap<>();
    }

    public static void updateShaders() {
        StringBuilder sb = new StringBuilder();
        numVals.forEach((s, v) -> v.forEach((s1, v1) -> {
            sb.append("\n");
            sb.append("#define ");
            sb.append(s);
            sb.append("_");
            sb.append(s1);
            sb.append(" ");
            sb.append(v1);
        }));
        boolVals.forEach((s, v) -> v.forEach((s1, v1) -> {
            if (v1) {
                sb.append("\n");
                sb.append("#define ");
                sb.append(s);
                sb.append("_");
                sb.append(s1);
            }
        }));
        System.out.println(sb.toString());
    }
}