package io.gitlab.jfronny.respackopts;

import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;
import me.shedaniel.clothconfig2.api.ConfigBuilder;
import me.shedaniel.clothconfig2.api.ConfigCategory;
import me.shedaniel.clothconfig2.api.ConfigEntryBuilder;
import net.minecraft.client.gui.screen.FatalErrorScreen;
import net.minecraft.client.gui.screen.Screen;
import net.minecraft.text.*;
import net.minecraft.util.Language;

import java.util.HashMap;
import java.util.Map;

public class GuiFactory {
    public void buildCategory(JsonObject source, String screenId, ConfigCategory config, ConfigEntryBuilder entryBuilder) {
        if (!Respackopts.boolVals.containsKey(screenId))
            Respackopts.boolVals.put(screenId, new HashMap<>());
        if (!Respackopts.numVals.containsKey(screenId))
            Respackopts.numVals.put(screenId, new HashMap<>());
        if (!Respackopts.strVals.containsKey(screenId))
            Respackopts.strVals.put(screenId, new HashMap<>());
        String b = "respackopts.field." + screenId;
        for (Map.Entry<String, JsonElement> entry : source.entrySet()) {
            String n = entry.getKey();
            if (n.contains(":") || n.contains(".")) {
                System.err.println(n + " contains invalid characters");
                continue;
            }
            JsonElement e = entry.getValue();
            if (e.isJsonPrimitive()) {
                JsonPrimitive p = e.getAsJsonPrimitive();
                if (p.isBoolean()) {
                    boolean defaultValue = p.getAsBoolean();
                    boolean currentValue = defaultValue;
                    if (Respackopts.boolVals.get(screenId).containsKey(n))
                        currentValue = Respackopts.boolVals.get(screenId).get(n);
                    else
                        Respackopts.boolVals.get(screenId).put(n, defaultValue);
                    config.addEntry(entryBuilder.startBooleanToggle(getText(n, b), currentValue)
                            .setDefaultValue(defaultValue)
                            .setSaveConsumer(v -> {
                                Respackopts.updateShaders();
                                Respackopts.boolVals.get(screenId).put(n, v);
                            })
                            .build());
                }
                else if (p.isNumber()) {
                    double defaultValue = p.getAsDouble();
                    double currentValue = defaultValue;
                    if (Respackopts.numVals.get(screenId).containsKey(n))
                        currentValue = Respackopts.numVals.get(screenId).get(n);
                    else
                        Respackopts.numVals.get(screenId).put(n, defaultValue);
                    config.addEntry(entryBuilder.startDoubleField(getText(n, b), currentValue)
                            .setDefaultValue(defaultValue)
                            .setSaveConsumer(v -> {
                                Respackopts.updateShaders();
                                Respackopts.numVals.get(screenId).put(n, v);
                            })
                            .build());
                }
                else if (p.isString()) {
                    String defaultValue = p.getAsString();
                    String currentValue = defaultValue;
                    if (Respackopts.strVals.get(screenId).containsKey(n))
                        currentValue = Respackopts.strVals.get(screenId).get(n);
                    else
                        Respackopts.strVals.get(screenId).put(n, defaultValue);
                    config.addEntry(entryBuilder.startStrField(getText(n, b), currentValue)
                            .setDefaultValue(defaultValue)
                            .setSaveConsumer(v -> {
                                Respackopts.updateShaders();
                                Respackopts.strVals.get(screenId).put(n, v);
                            })
                            .build());
                }
            }
            else {
                System.err.println("[respackopts] Unsupported non-primitive datatype");
            }
        }
    }

    public Screen buildGui(JsonObject source, String resourcepackid, Screen parent, Runnable respackReload) {
        try {
            ConfigBuilder builder;
            builder = ConfigBuilder.create()
                    .setParentScreen(parent)
                    .setTitle(getText(resourcepackid, "respackopts.title"));
            ConfigEntryBuilder entryBuilder = builder.entryBuilder();
            builder.setSavingRunnable(respackReload);
            ConfigCategory config = builder.getOrCreateCategory(getText(resourcepackid, "respackopts.category"));
            buildCategory(source, resourcepackid, config, entryBuilder);
            return builder.build();
        }
        catch (Throwable t) {
            t.printStackTrace();
            return new FatalErrorScreen(new TranslatableText("respackopts.loadFailed"), new TranslatableText("respackopts.loadError"));
        }
    }

    private Text getText(String key, String idPrefix) {
        String k = idPrefix + "." + key;
        if (Language.getInstance().hasTranslation(k)) return new TranslatableText(k);
        else return new LiteralText(key);
    }
}