package me.km.world;

import java.util.ArrayList;
import java.util.function.Consumer;
import me.km.KajetansMod;
import me.km.utils.ReflectionUtils;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.IWorld;
import net.minecraft.world.ServerWorld;
import net.minecraft.world.dimension.DimensionType;
import net.minecraftforge.common.DimensionManager;
import net.minecraftforge.common.ModDimension;
import net.minecraftforge.registries.ClearableRegistry;

public class WorldManager
{
    public static final ModDimension MOD_DIMENSION = new ModOverworldDimension().setRegistryName(KajetansMod.MODID, "mod_dimension");
    
    // -------------------------------------------------------------------------
    // unsafe stuff
    // -------------------------------------------------------------------------
    
    public static void registerUnsafe(int id, String name)
    {
        DimensionManager.registerDimensionInternal(id, new ResourceLocation(name), MOD_DIMENSION, null, true);
    }
    
    public static void reset()
    {
        ClearableRegistry<DimensionType> reg = (ClearableRegistry<DimensionType>) DimensionManager.getRegistry();
        reg.clear();
        reg.register(DimensionType.OVERWORLD.getId() + 1, new ResourceLocation("minecraft", "overworld"), DimensionType.OVERWORLD);
        reg.register(DimensionType.NETHER.getId() + 1, new ResourceLocation("minecraft", "the_nether"), DimensionType.NETHER);
        reg.register(DimensionType.THE_END.getId() + 1, new ResourceLocation("minecraft", "the_end"), DimensionType.THE_END);
    }
    
    private static ResourceLocation getRegistry(DimensionType type)
    {
        ResourceLocation rl = type.getRegistryName();
        if(rl != null)
        {
            return rl;
        }
        rl = DimensionManager.getRegistry().getKey(type);
        if(rl == null)
        {
            return null;
        }
        type.setRegistryName(rl);
        return rl;
    }
    
    public static void forEachType(Consumer<DimensionType> c)
    {
        DimensionManager.getRegistry().iterator().forEachRemaining((type) -> 
        {
            getRegistry(type);
            c.accept(type);
        });
    }
    
    private static DimensionType getType(ResourceLocation rl)
    {
        return DimensionManager.getRegistry().getOrDefault(rl);
    }
    
    private static ServerWorld getWorld(DimensionType type, boolean force)
    {
        return DimensionManager.getWorld(KajetansMod.server, type, force, force);
    }
    
    private static boolean containsRegistry(ResourceLocation rl)
    {
        return DimensionManager.getRegistry().getOrDefault(rl) != null;
    }
    
    private static void unregister(ResourceLocation rl, DimensionType removeType)
    {
        // unregister the id
        try
        {
            // data might not be set
            DimensionManager.unregisterDimension(removeType.getId() + 1);
        }
        catch(Exception ex)
        {
        }
        // remove entry in "savedEntries"
        ReflectionUtils.removeDimensionSaveEntry(rl);
        // remove the registry
        ClearableRegistry<DimensionType> reg = (ClearableRegistry<DimensionType>) DimensionManager.getRegistry();
        ArrayList<ResourceLocation> regs = new ArrayList<>();
        ArrayList<DimensionType> types = new ArrayList<>();
        for(DimensionType type : reg)
        {
            if(type == removeType)
            {
                continue;
            }
            types.add(type);
            regs.add(reg.getKey(type));
        }
        reg.clear();
        for(int i = 0; i < regs.size(); i++)
        {
            DimensionType type = types.get(i);
            reg.register(type.getId() + 1, regs.get(i), type);
        }
    }
    
    // -------------------------------------------------------------------------
    // normal stuff
    // -------------------------------------------------------------------------
    
    private static ServerWorld getOverworld()
    {
        return KajetansMod.server.getWorld(DimensionType.OVERWORLD);
    }
    
    public static String getName(IWorld ws)
    {
        if(ws == null)
        {
            return "null";
        }
        DimensionType type = ws.getDimension().getType();
        if(type == DimensionType.NETHER)
        {
            return ws.getWorldInfo().getWorldName() + "_nether";
        }
        else if(type == DimensionType.THE_END)
        {
            return ws.getWorldInfo().getWorldName() + "_end";
        }
        ResourceLocation rl = getRegistry(type);
        return rl == null ? "null" : rl.getPath();
    }

    public static ServerWorld get(String name)
    {
        ServerWorld w = getOverworld();
        String domain;
        if(w.getWorldInfo().getWorldName().startsWith(name))
        {
            domain = "minecraft";
        }
        else
        {
            domain = KajetansMod.MODID;
        }
        DimensionType type = getType(new ResourceLocation(domain, name));
        if(type == null)
        {
            return null;
        }
        return getWorld(type, true);
    }

    public static boolean register(String name)
    {
        ResourceLocation rl = new ResourceLocation(KajetansMod.MODID, name);
        if(containsRegistry(rl))
        {
            return false;
        }
        DimensionManager.registerDimension(rl, MOD_DIMENSION, null, true);
        return true;
    }
    
    public static boolean unregister(String name)
    {
        ResourceLocation rl = new ResourceLocation(KajetansMod.MODID, name);
        DimensionType removeType = getType(rl);
        if(removeType == null)
        {
            return false;
        }
        ServerWorld ws = getWorld(removeType, false);
        if(ws != null)
        {
            return false;
        }
        unregister(rl, removeType);
        return true;
    }
}