package net.mcreator.phayriosisreborn.config;

import net.minecraft.world.level.Level;
import net.minecraft.world.level.LevelAccessor;
import net.mcreator.phayriosisreborn.network.PhayriosisrebornModVariables;

/** Ephemeral Create World draft. The server-side SavedData remains authoritative after world creation. */
public final class PhayriosisPendingWorldSettings {
    private static final long MAX_NEW_WORLD_GAME_TIME = 1200L;

    public static boolean active = false;
    public static boolean draftInitialized = false;

    // Meteor section.
    public static boolean meteorEnabled;
    public static double meteorMinimumDay;
    public static double meteorMinimumPhase;
    public static double meteorCheckIntervalTicks;
    public static double meteorChance;
    public static double meteorMinDistance;
    public static double meteorMaxDistance;
    public static boolean meteorInfectionEnabled;

    // Infection Difficulty section.
    // 0=Easy, 1=Normal, 2=Advanced, 3=Hard, 4=Nightmare.
    public static int difficultyMode;
    public static boolean nightmareModeEnabled;
    public static double blockSpreadSpeed;
    public static double maxInfectableHardness;

    // Infection Config section.
    public static boolean blockSpreadEnabled;
    public static boolean conversionsEnabled;
    public static boolean playerConversionEnabled;
    public static boolean parasiteSpawningEnabled;
    public static boolean dimensionalSpawningEnabled;

    // Advanced section.
    public static boolean phaseFreezeEnabled;

    private PhayriosisPendingWorldSettings() {}

    public static synchronized void beginDraft() {
        if (!draftInitialized) resetDraftToDefaults();
        active = false;
    }

    public static synchronized void resetDraftToDefaults() {
        PhayriosisFileConfig.ensureLoaded();
        resetMeteorDefaults();
        resetDifficultyDefaults();
        resetInfectionDefaults();
        phaseFreezeEnabled = PhayriosisFileConfig.useConfigDefaultsForNewWorlds ? PhayriosisFileConfig.phaseFreezeEnabled : false;
        draftInitialized = true;
        active = false;
    }

    public static void resetMeteorDefaults() {
        PhayriosisFileConfig.ensureLoaded();
        if (!PhayriosisFileConfig.useConfigDefaultsForNewWorlds) {
            meteorEnabled = false; meteorMinimumDay = 7.0D; meteorMinimumPhase = 1.0D;
            meteorCheckIntervalTicks = 3600.0D; meteorChance = 0.5D;
            meteorMinDistance = 210.0D; meteorMaxDistance = 250.0D; meteorInfectionEnabled = true;
            return;
        }
        meteorEnabled = PhayriosisFileConfig.meteorEnabled;
        meteorMinimumDay = PhayriosisFileConfig.meteorMinimumDay;
        meteorMinimumPhase = PhayriosisFileConfig.meteorMinimumPhase;
        meteorCheckIntervalTicks = PhayriosisFileConfig.meteorCheckIntervalTicks;
        meteorChance = PhayriosisFileConfig.meteorChance;
        meteorMinDistance = PhayriosisFileConfig.meteorMinDistance;
        meteorMaxDistance = PhayriosisFileConfig.meteorMaxDistance;
        meteorInfectionEnabled = PhayriosisFileConfig.meteorInfectionEnabled;
    }

    public static void resetDifficultyDefaults() {
        PhayriosisFileConfig.ensureLoaded();
        if (!PhayriosisFileConfig.useConfigDefaultsForNewWorlds) {
            difficultyMode = 1; nightmareModeEnabled = false; blockSpreadSpeed = 3.0D; maxInfectableHardness = 2.9D;
            return;
        }
        difficultyMode = PhayriosisFileConfig.difficultyMode;
        nightmareModeEnabled = difficultyMode == 4;
        blockSpreadSpeed = PhayriosisFileConfig.blockSpreadSpeed;
        maxInfectableHardness = PhayriosisFileConfig.maxInfectableHardness;
    }

    public static void resetInfectionDefaults() {
        PhayriosisFileConfig.ensureLoaded();
        if (!PhayriosisFileConfig.useConfigDefaultsForNewWorlds) {
            blockSpreadEnabled = true; conversionsEnabled = true; playerConversionEnabled = true;
            parasiteSpawningEnabled = false; dimensionalSpawningEnabled = true;
            return;
        }
        blockSpreadEnabled = PhayriosisFileConfig.blockSpreadEnabled;
        conversionsEnabled = PhayriosisFileConfig.conversionsEnabled;
        playerConversionEnabled = PhayriosisFileConfig.playerConversionEnabled;
        parasiteSpawningEnabled = PhayriosisFileConfig.parasiteSpawningEnabled;
        dimensionalSpawningEnabled = PhayriosisFileConfig.dimensionalSpawningEnabled;
    }

    public static synchronized void arm() {
        beginDraft();
        active = true;
    }

    public static synchronized void cancelAll() {
        active = false;
        draftInitialized = false;
    }

    /** Applies the draft once, only to a genuinely fresh world. */
    public static synchronized boolean consumeInto(LevelAccessor world) {
        if (!active) return false;
        if (!(world instanceof Level level)) return false;
        if (level.m_46467_() > MAX_NEW_WORLD_GAME_TIME) return false;

        PhayriosisWorldSettings settings = PhayriosisWorldSettings.get(world);
        if (settings.initialized || settings.worldCreationConfigured) return false;

        settings.meteorEnabled = meteorEnabled;
        settings.meteorMinimumDay = meteorMinimumDay;
        settings.meteorMinimumPhase = meteorMinimumPhase;
        settings.meteorCheckIntervalTicks = meteorCheckIntervalTicks;
        settings.meteorChance = meteorChance;
        settings.meteorMinDistance = meteorMinDistance;
        settings.meteorMaxDistance = meteorMaxDistance;
        settings.meteorInfectionEnabled = meteorInfectionEnabled;

        settings.infectionDifficultyMode = difficultyMode;
        settings.nightmareModeEnabled = difficultyMode == 4;
        settings.blockSpreadSpeed = blockSpreadSpeed;
        settings.maxInfectableHardness = maxInfectableHardness;
        settings.blockSpreadEnabled = blockSpreadEnabled;
        settings.conversionsEnabled = conversionsEnabled;
        settings.playerConversionEnabled = playerConversionEnabled;
        settings.parasiteSpawningEnabled = parasiteSpawningEnabled;
        settings.dimensionalSpawningEnabled = dimensionalSpawningEnabled;
        settings.phaseFreezeEnabled = phaseFreezeEnabled;

        settings.schemaVersion = PhayriosisWorldSettings.CURRENT_SCHEMA;
        settings.initialized = true;
        settings.worldCreationConfigured = true;
        settings.m_77762_();

        // Legacy runtime procedures still read MapVariables directly. Mirror the world-creation choices there.
        PhayriosisrebornModVariables.MapVariables legacy = PhayriosisrebornModVariables.MapVariables.get(world);
        if (legacy != null) {
            legacy.blockspread = blockSpreadEnabled;
            legacy.conversions = conversionsEnabled;
            legacy.playerconversion = playerConversionEnabled;
            legacy.doparasitesspawn = parasiteSpawningEnabled;
            legacy.doparasitesspawndimension = dimensionalSpawningEnabled;
            legacy.nightmaremode = difficultyMode == 4;
            legacy.blockspreadspeed = blockSpreadSpeed;
            legacy.maxhardness = maxInfectableHardness;
            legacy.phasefrozen = phaseFreezeEnabled;
            legacy.syncData(world);
        }

        active = false;
        draftInitialized = false;
        System.out.println("[Phayriosis Settings] applied Create World profile to new world");
        return true;
    }

    // Meteor labels/cycles.
    public static String enabledLabel() { return meteorEnabled ? "Meteor Event: ON" : "Meteor Event: OFF"; }
    public static String dayLabel() { return "Earliest Day: " + (int)meteorMinimumDay; }
    public static String phaseLabel() { return "Minimum Phase: " + (int)meteorMinimumPhase; }
    public static String chanceLabel() { return "Event Chance: " + (int)Math.round(meteorChance * 100.0D) + "%"; }
    public static String intervalLabel() { return "Check Interval: " + (int)Math.round(meteorCheckIntervalTicks / 20.0D) + "s"; }
    public static String distanceLabel() { return "Impact Distance: " + (int)meteorMinDistance + "-" + (int)meteorMaxDistance; }
    public static String infectionLabel() { return meteorInfectionEnabled ? "Impact Infection: ON" : "Impact Infection: OFF"; }
    public static void cycleDay() { if (meteorMinimumDay < 1.0D) meteorMinimumDay = 3.0D; else if (meteorMinimumDay < 5.0D) meteorMinimumDay = 7.0D; else if (meteorMinimumDay < 10.0D) meteorMinimumDay = 14.0D; else meteorMinimumDay = 0.0D; }
    public static void cyclePhase() { meteorMinimumPhase += 1.0D; if (meteorMinimumPhase > 4.0D) meteorMinimumPhase = 1.0D; }
    public static void cycleChance() { if (meteorChance < 0.15D) meteorChance = 0.25D; else if (meteorChance < 0.35D) meteorChance = 0.5D; else if (meteorChance < 0.65D) meteorChance = 0.75D; else if (meteorChance < 0.9D) meteorChance = 1.0D; else meteorChance = 0.10D; }
    public static void cycleInterval() { if (meteorCheckIntervalTicks < 2000.0D) meteorCheckIntervalTicks = 3600.0D; else if (meteorCheckIntervalTicks < 5000.0D) meteorCheckIntervalTicks = 6000.0D; else if (meteorCheckIntervalTicks < 9000.0D) meteorCheckIntervalTicks = 12000.0D; else meteorCheckIntervalTicks = 1200.0D; }
    public static void cycleDistance() { if (meteorMinDistance < 200.0D) { meteorMinDistance = 210.0D; meteorMaxDistance = 250.0D; } else if (meteorMinDistance < 240.0D) { meteorMinDistance = 260.0D; meteorMaxDistance = 320.0D; } else { meteorMinDistance = 180.0D; meteorMaxDistance = 220.0D; } }

    // Infection Difficulty labels/cycles.
    public static String difficultyLabel() { return "Difficulty: " + difficultyName(); }
    public static String difficultyName() {
        switch (difficultyMode) {
            case 0: return "Easy";
            case 2: return "Advanced";
            case 3: return "Hard";
            case 4: return "Nightmare";
            default: return "Normal";
        }
    }
    public static void cycleDifficulty() {
        difficultyMode++;
        if (difficultyMode > 4) difficultyMode = 0;
        nightmareModeEnabled = difficultyMode == 4;
    }
    public static String nightmareLabel() { return difficultyMode == 4 ? "Nightmare Mode: ON" : "Nightmare Mode: OFF"; }
    public static String spreadSpeedLabel() { return "Base Spread Setting: " + (int)blockSpreadSpeed + "/5"; }
    public static String hardnessLabel() { return "Max Infectable Hardness: " + formatHardness(maxInfectableHardness); }
    public static void cycleSpreadSpeed() { blockSpreadSpeed += 1.0D; if (blockSpreadSpeed > 5.0D) blockSpreadSpeed = 1.0D; }
    public static void cycleHardness() {
        if (maxInfectableHardness < 2.0D) maxInfectableHardness = 2.9D;
        else if (maxInfectableHardness < 4.0D) maxInfectableHardness = 5.0D;
        else if (maxInfectableHardness < 8.0D) maxInfectableHardness = 12.0D;
        else maxInfectableHardness = 1.5D;
    }
    private static String formatHardness(double value) { return value == Math.rint(value) ? Integer.toString((int)value) : Double.toString(value); }

    // Infection Config labels.
    public static String blockSpreadLabel() { return blockSpreadEnabled ? "Block Infection: ON" : "Block Infection: OFF"; }
    public static String conversionsLabel() { return conversionsEnabled ? "Mob Conversions: ON" : "Mob Conversions: OFF"; }
    public static String playerConversionLabel() { return playerConversionEnabled ? "Player Conversion: ON" : "Player Conversion: OFF"; }
    public static String spawningLabel() { return parasiteSpawningEnabled ? "Natural Infected Spawns: ON" : "Natural Infected Spawns: OFF"; }
    public static String dimensionSpawningLabel() { return dimensionalSpawningEnabled ? "Dimensional Spawning: ON" : "Dimensional Spawning: OFF"; }

    // Advanced labels.
    public static String phaseFreezeLabel() { return phaseFreezeEnabled ? "Phase Progression: FROZEN" : "Phase Progression: NORMAL"; }
}
