package com.boydti.fawe.bukkit.v0;

import com.boydti.fawe.FaweCache;
import com.boydti.fawe.bukkit.util.BukkitReflectionUtils;
import com.boydti.fawe.util.ReflectionUtils;
import com.sk89q.jnbt.ByteArrayTag;
import com.sk89q.jnbt.ByteTag;
import com.sk89q.jnbt.CompoundTag;
import com.sk89q.jnbt.DoubleTag;
import com.sk89q.jnbt.EndTag;
import com.sk89q.jnbt.FloatTag;
import com.sk89q.jnbt.IntArrayTag;
import com.sk89q.jnbt.IntTag;
import com.sk89q.jnbt.ListTag;
import com.sk89q.jnbt.LongTag;
import com.sk89q.jnbt.NBTConstants;
import com.sk89q.jnbt.ShortTag;
import com.sk89q.jnbt.StringTag;
import com.sk89q.jnbt.Tag;
import com.sk89q.worldedit.blocks.BaseBlock;
import com.sk89q.worldedit.bukkit.adapter.BukkitImplAdapter;
import com.sk89q.worldedit.entity.BaseEntity;
import com.sk89q.worldedit.internal.Constants;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import javax.annotation.Nullable;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Biome;
import org.bukkit.entity.Entity;
import org.bukkit.event.entity.CreatureSpawnEvent;

public class FaweAdapter_All implements BukkitImplAdapter {

    private final Class<?> classCraftBlock;
    private final Method biomeToBiomeBase;
    private final Class<?> classBiomeBase;
    private final Method biomeBaseToTypeId;
    private final Method getBiome;
    private final Method biomeBaseToBiome;
    private final Class<?> classCraftWorld;
    private final Method getHandleWorld;
    private final Class<?> classWorld;
    private final Method getTileEntity1;
    private final Method getTileEntity2;
    private final Class<?> classNBTTagCompound;
    private final Constructor<?> newNBTTagCompound;
    private final Class<?> classTileEntity;
    private final Class<?> classCraftEntity;
    private final Method getHandleEntity;
    private final Class<?> classNBTTagInt;
    private final Class<?> classNBTBase;
    private final Constructor<?> newNBTTagInt;
    private final Method setNBTTagCompound;
    private Class<?> classEntity;
    private Method getBukkitEntity;
    private Method addEntity;
    private Method setLocation;
    private Class<?> classEntityTypes;
    private Method getEntityId;
    private Method createEntityFromId;
    private Method readTagIntoEntity;
    private Method readEntityIntoTag;
    private Constructor<?> newMinecraftKey;
    private Class<?> classMinecraftKey;
    private Method readTagIntoTileEntity;
    private Method readTileEntityIntoTag;
    private Class<?> classBlockPosition;
    private Constructor<?> newBlockPosition;

    private Map<Class<? extends Tag>, NMSTagConstructor> WEToNMS = new ConcurrentHashMap<>();
    private Map<Class, WETagConstructor> NMSToWE = new ConcurrentHashMap<>();
    private Map<Class<? extends Tag>, Integer> TagToId = new ConcurrentHashMap<>();

    public FaweAdapter_All() throws Throwable {
        BukkitReflectionUtils.init();
        classCraftWorld = BukkitReflectionUtils.getCbClass("CraftWorld");
        classCraftBlock = BukkitReflectionUtils.getCbClass("block.CraftBlock");
        classCraftEntity = BukkitReflectionUtils.getCbClass("entity.CraftEntity");
        classBiomeBase = BukkitReflectionUtils.getNmsClass("BiomeBase");
        classWorld = BukkitReflectionUtils.getNmsClass("World");
        classTileEntity = BukkitReflectionUtils.getNmsClass("TileEntity");

        biomeToBiomeBase = ReflectionUtils.setAccessible(classCraftBlock.getDeclaredMethod("biomeToBiomeBase", Biome.class));
        biomeBaseToBiome = ReflectionUtils.setAccessible(classCraftBlock.getDeclaredMethod("biomeBaseToBiome", classBiomeBase));
        getBiome = ReflectionUtils.setAccessible(classBiomeBase.getDeclaredMethod("getBiome", int.class));
        biomeBaseToTypeId = ReflectionUtils.findMethod(classBiomeBase, int.class, classBiomeBase);
        getHandleWorld = ReflectionUtils.setAccessible(classCraftWorld.getDeclaredMethod("getHandle"));
        getHandleEntity = ReflectionUtils.setAccessible(classCraftEntity.getDeclaredMethod("getHandle"));
        try {
            classBlockPosition = BukkitReflectionUtils.getNmsClass("BlockPosition");
        } catch (Throwable ignore) {
        }
        if (classBlockPosition != null) {
            getTileEntity1 = classWorld.getDeclaredMethod("getTileEntity", classBlockPosition);
            getTileEntity2 = null;
            newBlockPosition = ReflectionUtils.setAccessible(classBlockPosition.getConstructor(int.class, int.class, int.class));
        } else {
            getTileEntity1 = null;
            getTileEntity2 = ReflectionUtils.setAccessible(classWorld.getDeclaredMethod("getTileEntity", int.class, int.class, int.class));
        }

        classNBTTagCompound = BukkitReflectionUtils.getNmsClass("NBTTagCompound");
        classNBTBase = BukkitReflectionUtils.getNmsClass("NBTBase");
        classNBTTagInt = BukkitReflectionUtils.getNmsClass("NBTTagInt");
        newNBTTagInt = ReflectionUtils.setAccessible(classNBTTagInt.getConstructor(int.class));
        setNBTTagCompound = ReflectionUtils.setAccessible(classNBTTagCompound.getDeclaredMethod("set", String.class, classNBTBase));
        newNBTTagCompound = ReflectionUtils.setAccessible(classNBTTagCompound.getConstructor());
        try {
            readTileEntityIntoTag = ReflectionUtils.setAccessible(classTileEntity.getDeclaredMethod("save", classNBTTagCompound));
        } catch (Throwable ignore) {
            readTileEntityIntoTag = ReflectionUtils.findMethod(classTileEntity, classNBTTagCompound, classNBTTagCompound);
            if (readTileEntityIntoTag == null) {
                readTileEntityIntoTag = ReflectionUtils.findMethod(classTileEntity, 1, Void.TYPE, classNBTTagCompound);
            }
        }


        try {
            readTagIntoTileEntity = ReflectionUtils.setAccessible(classTileEntity.getDeclaredMethod("load", classNBTTagCompound));
        } catch (Throwable ignore) {
            readTagIntoTileEntity = ReflectionUtils.findMethod(classTileEntity, 0, Void.TYPE, classNBTTagCompound);
        }


        List<String> nmsClasses = Arrays.asList("NBTTagCompound", "NBTTagByte", "NBTTagByteArray", "NBTTagDouble", "NBTTagFloat", "NBTTagInt", "NBTTagIntArray", "NBTTagList", "NBTTagEnd", "NBTTagString", "NBTTagShort", "NBTTagLong");
        List<Class<? extends Tag>> weClasses = Arrays.asList(CompoundTag.class, ByteTag.class, ByteArrayTag.class, DoubleTag.class, FloatTag.class, IntTag.class, IntArrayTag.class, ListTag.class, EndTag.class, StringTag.class, ShortTag.class, LongTag.class);
        int[] ids = new int[]{10, 1, 7, 6, 5, 3, 11, 9, 0, 8, 2, 4};

        int noMods = Modifier.STATIC;
        int hasMods = 0;
        for (int i = 0; i < nmsClasses.size(); i++) {
            Class<?> nmsClass = BukkitReflectionUtils.getNmsClass(nmsClasses.get(i));
            Class<? extends Tag> weClass = weClasses.get(i);
            TagToId.put(weClass, ids[i]);

            Constructor nmsConstructor = ReflectionUtils.setAccessible(nmsClass.getDeclaredConstructor());

            if (weClass == EndTag.class) {
                NMSToWE.put(nmsClass, value -> new EndTag());
                WEToNMS.put(weClass, value -> nmsConstructor.newInstance());
            } else if (weClass == CompoundTag.class) {
                Field mapField = ReflectionUtils.findField(nmsClass, Map.class, hasMods, noMods);
                Constructor<? extends Tag> weConstructor = ReflectionUtils.setAccessible(CompoundTag.class.getConstructor(Map.class));

                NMSToWE.put(nmsClass, value -> {
                    Map<String, Object> map = (Map) mapField.get(value);
                    Map<String, Tag> weMap = new HashMap<String, Tag>();
                    for (Map.Entry<String, Object> entry : map.entrySet()) {
                        weMap.put(entry.getKey(), toNative(entry.getValue()));
                    }
                    return new CompoundTag(weMap);
                });

                WEToNMS.put(weClass, value -> {
                    Map<String, Tag> map = ReflectionUtils.getMap(((CompoundTag) value).getValue());
                    Object nmsTag = nmsConstructor.newInstance();
                    Map<String, Object> nmsMap = (Map<String, Object>) mapField.get(nmsTag);
                    for (Map.Entry<String, Tag> entry : map.entrySet()) {
                        nmsMap.put(entry.getKey(), fromNative(entry.getValue()));
                    }
                    return nmsTag;
                });
            } else if (weClass == ListTag.class) {
                Field listField = ReflectionUtils.findField(nmsClass, List.class, hasMods, noMods);
                Field typeField = ReflectionUtils.findField(nmsClass, byte.class, hasMods, noMods);
                Constructor<? extends Tag> weConstructor = ReflectionUtils.setAccessible(ListTag.class.getConstructor(Class.class, List.class));

                NMSToWE.put(nmsClass, tag -> {
                    int type = ((Number) typeField.get(tag)).intValue();
                    List list = (List) listField.get(tag);

                    Class<? extends Tag> weType = NBTConstants.getClassFromType(type);
                    ArrayList<Tag> weList = new ArrayList<>();
                    for (Object nmsTag : list) {
                        weList.add(toNative(nmsTag));
                    }
                    return new ListTag(weType, weList);
                });
                WEToNMS.put(weClass, tag -> {
                    ListTag lt = (ListTag) tag;
                    List<Tag> list = ReflectionUtils.getList(lt.getValue());
                    Class<? extends Tag> type = lt.getType();

                    int typeId = TagToId.get(type);
                    Object nmsTagList = nmsConstructor.newInstance();
                    typeField.set(nmsTagList, (byte) typeId);
                    ArrayList<Object> nmsList = (ArrayList<Object>) listField.get(nmsTagList);
                    for (Tag weTag : list) {
                        nmsList.add(fromNative(weTag));
                    }
                    return nmsTagList;
                });
            } else {
                Field typeField = ReflectionUtils.findField(nmsClass, null, hasMods, noMods);
                Constructor<? extends Tag> weConstructor = ReflectionUtils.setAccessible(weClass.getConstructor(typeField.getType()));

                NMSToWE.put(nmsClass, tag -> {
                    Object value = typeField.get(tag);
                    return weConstructor.newInstance(value);
                });

                WEToNMS.put(weClass, tag -> {
                    Object nmsTag = nmsConstructor.newInstance();
                    typeField.set(nmsTag, tag.getValue());
                    return nmsTag;
                });
            }
        }
        try {
            classEntity = BukkitReflectionUtils.getNmsClass("Entity");
            classEntityTypes = BukkitReflectionUtils.getNmsClass("EntityTypes");

            getBukkitEntity = ReflectionUtils.setAccessible(classEntity.getDeclaredMethod("getBukkitEntity"));
            addEntity = ReflectionUtils.setAccessible(classWorld.getDeclaredMethod("addEntity", classEntity, CreatureSpawnEvent.SpawnReason.class));
            setLocation = ReflectionUtils.setAccessible(classEntity.getDeclaredMethod("setLocation", double.class, double.class, double.class, float.class, float.class));

            try {
                classMinecraftKey = BukkitReflectionUtils.getNmsClass("MinecraftKey");
                newMinecraftKey = classMinecraftKey.getConstructor(String.class);
            } catch (Throwable ignore) {
            }
            if (classMinecraftKey != null) {
                getEntityId = ReflectionUtils.findMethod(classEntityTypes, classMinecraftKey, classEntity);
                createEntityFromId = ReflectionUtils.findMethod(classEntityTypes, classEntity, classMinecraftKey, classWorld);
            } else {
                getEntityId = ReflectionUtils.findMethod(classEntityTypes, String.class, classEntity);
                createEntityFromId = ReflectionUtils.findMethod(classEntityTypes, classEntity, String.class, classWorld);
            }

            noMods = Modifier.ABSTRACT | Modifier.PROTECTED | Modifier.PRIVATE;
            try {
                readEntityIntoTag = classEntity.getDeclaredMethod("save", classNBTTagCompound);
            } catch (Throwable ignore) {
                readEntityIntoTag = ReflectionUtils.findMethod(classEntity, classNBTTagCompound, classNBTTagCompound);
                if (readEntityIntoTag == null) {
                    readEntityIntoTag = ReflectionUtils.findMethod(classEntity, 0, 0, noMods, Void.TYPE, classNBTTagCompound);
                }
            }
            ReflectionUtils.setAccessible(readEntityIntoTag);
            readTagIntoEntity = ReflectionUtils.findMethod(classEntity, 1, 0, noMods, Void.TYPE, classNBTTagCompound);
            if (readTagIntoEntity == null) {
                readTagIntoEntity = ReflectionUtils.findMethod(classEntity, 0, 0, noMods, Void.TYPE, classNBTTagCompound);
            }
        } catch (Throwable e) {
            e.printStackTrace();
            classEntity = null;
        }
    }

    @Nullable
    @Override
    public BaseEntity getEntity(Entity entity) {
        try {
            if (classEntity == null) return null;
            Object nmsEntity = getHandleEntity.invoke(entity);

            String id = getEntityId(nmsEntity);

            if (id != null) {
                Object tag = newNBTTagCompound.newInstance();
                readEntityIntoTag.invoke(nmsEntity, tag);
                return new BaseEntity(id, (CompoundTag) toNative(tag));
            }
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        return null;
    }

    private String getEntityId(Object entity) throws InvocationTargetException, IllegalAccessException {
        Object res = getEntityId.invoke(null, entity);
        return res == null ? null : res.toString();
    }

    private Object createEntityFromId(String id, Object world) throws InvocationTargetException, IllegalAccessException, InstantiationException {
        if (classMinecraftKey != null) {
            Object key = newMinecraftKey.newInstance(id);
            return createEntityFromId.invoke(null, key, world);
        } else {
            return createEntityFromId.invoke(null, id, world);
        }
    }

    @Nullable
    @Override
    public Entity createEntity(Location location, BaseEntity state) {
        try {
            if (classEntity == null) return null;
            World world = location.getWorld();
            Object nmsWorld = getHandleWorld.invoke(world);

            Object createdEntity = createEntityFromId(state.getTypeId(), nmsWorld);

            if (createdEntity != null) {
                CompoundTag nativeTag = state.getNbtData();
                Map<String, Tag> rawMap = ReflectionUtils.getMap(nativeTag.getValue());
                for (String name : Constants.NO_COPY_ENTITY_NBT_FIELDS) {
                    rawMap.remove(name);
                }
                if (nativeTag != null) {
                    Object tag = fromNative(nativeTag);
                    readTagIntoEntity.invoke(createdEntity, tag);
                }

                setLocation.invoke(createdEntity, location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());

                addEntity.invoke(nmsWorld, createdEntity, CreatureSpawnEvent.SpawnReason.CUSTOM);
                return (Entity) getBukkitEntity.invoke(createdEntity);
            }
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        return null;
    }

    public Tag toNative(Object nmsTag) {
        try {
            return NMSToWE.get(nmsTag.getClass()).construct(nmsTag);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public Object fromNative(Tag tag) {
        try {
            return WEToNMS.get(tag.getClass()).construct(tag);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public int getBlockId(Material material) {
        return material.getId();
    }

    @Override
    public Material getMaterial(int id) {
        return Material.getMaterial(id);
    }

    @Override
    public int getBiomeId(Biome biome) {
        try {
            Object biomeBase = biomeToBiomeBase.invoke(null, biome);
            if (biomeBase != null) return (int) biomeBaseToTypeId.invoke(null, biomeBase);
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        return 0;
    }

    @Override
    public Biome getBiome(int id) {
        try {
            Object biomeBase = getBiome.invoke(null, id);
            if (biomeBase != null) return (Biome) biomeBaseToBiome.invoke(null, biomeBase);
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        return Biome.OCEAN;
    }

    @Override
    public BaseBlock getBlock(Location location) {
        try {
            World craftWorld = location.getWorld();
            int x = location.getBlockX();
            int y = location.getBlockY();
            int z = location.getBlockZ();

            org.bukkit.block.Block bukkitBlock = location.getBlock();
            BaseBlock block = FaweCache.getBlock(bukkitBlock.getTypeId(), bukkitBlock.getData());

            // Read the NBT data
            Object nmsWorld = getHandleWorld.invoke(craftWorld);
            Object tileEntity = getTileEntity(nmsWorld, x, y, z);

            if (tileEntity != null) {
                block = new BaseBlock(block);
                Object tag = newNBTTagCompound.newInstance();
                readTileEntityIntoTag.invoke(tileEntity, tag);
                block.setNbtData((CompoundTag) toNative(tag));
            }
            return block;
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
    }

    public Object getTileEntity(Object nmsWorld, int x, int y, int z) {
        try {
            if (getTileEntity1 != null) {
                Object pos = newBlockPosition.newInstance(x, y, z);
                return getTileEntity1.invoke(nmsWorld, pos);
            } else {
                return getTileEntity2.invoke(nmsWorld, x, y, z);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public boolean setBlock(Location location, BaseBlock block, boolean notifyAndLight) {
        World craftWorld = location.getWorld();
        int x = location.getBlockX();
        int y = location.getBlockY();
        int z = location.getBlockZ();

        boolean changed = location.getBlock().setTypeIdAndData(block.getId(), (byte) block.getData(), notifyAndLight);

        CompoundTag nativeTag = block.getNbtData();
        if (nativeTag != null) {
            try {
                Object nmsWorld = getHandleWorld.invoke(craftWorld);
                Object tileEntity = getTileEntity(nmsWorld, x, y, z);
                if (tileEntity != null) {
                    Object tag = fromNative(nativeTag);

                    setNBTTagCompound.invoke(tag, "x", newNBTTagInt.newInstance(x));
                    setNBTTagCompound.invoke(tag, "y", newNBTTagInt.newInstance(y));
                    setNBTTagCompound.invoke(tag, "z", newNBTTagInt.newInstance(z));
                    readTagIntoTileEntity.invoke(tileEntity, tag); // Load data
                }
            } catch (Throwable e) {
                throw new RuntimeException(e);
            }
        }

        return changed;
    }

    private interface NMSTagConstructor {
        Object construct(Tag value) throws Exception;
    }

    private interface WETagConstructor {
        Tag construct(Object value) throws Exception;
    }
}