import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;

public class ModEntityHelper {
    public Map<Class<? extends Entity>, EntityEntry> entityMap;
    private Map<Integer, Class<? extends Entity>> trackerIdMap;

    public ModEntityHelper() {
        entityMap = new HashMap<Class<? extends Entity>, EntityEntry>();
        trackerIdMap = new HashMap<Integer, Class<? extends Entity>>();
    }

    public void registerEntity(EntityEntry entry, int entityId) {
        entityMap.put(entry.entityClass, entry);
        trackerIdMap.put(entry.trackerId, entry.entityClass);
        registerEntity(entry.entityClass, entityId);
    }

    public void registerEntity(EntityEntry entry) {
        registerEntity(entry, ModLoader.getUniqueEntityId());
    }

    public void registerEntity(EntityEntry entry, int entityId,
            int weighedProb, int min, int max, EnumCreatureType creatureType,
            BiomeGenBase... biome) {
        registerEntity(entry, entityId);
        registerEntity(entry.entityClass, entityId, weighedProb, min, max,
                creatureType, biome);
    }

    public void registerEntity(EntityEntry entry, int weighedProb, int min,
            int max, EnumCreatureType creatureType, BiomeGenBase... biome) {
        registerEntity(entry, ModLoader.getUniqueEntityId(), weighedProb, min,
                max, creatureType, biome);
    }

    public void registerEntity(Class<? extends Entity> entityClass, int entityId) {
        ModLoader.registerEntityID(entityClass, entityClass.getSimpleName(),
                entityId);
    }

    public void registerEntity(Class<? extends Entity> entityClass) {
        registerEntity(entityClass, ModLoader.getUniqueEntityId());
    }

    public void registerEntity(Class<? extends Entity> entityClass,
            int entityId, int weighedProb, int min, int max,
            EnumCreatureType creatureType, BiomeGenBase... biome) {
        registerEntity(entityClass, entityId);
        ModLoader.addSpawn(entityClass, weighedProb, min, max, creatureType,
                biome);
    }

    public void registerEntity(Class<? extends Entity> entityClass,
            int weighedProb, int min, int max, EnumCreatureType creatureType,
            BiomeGenBase... biome) {
        registerEntity(entityClass, ModLoader.getUniqueEntityId(), weighedProb,
                min, max, creatureType, biome);
    }

    public void addEntityToTracker(EntityTracker tracker, Entity entity) {
        EntityEntry entry = entityMap.get(entity.getClass());
        if (entry == null)
            return;

        tracker.addEntityToTracker(entity, entry.blocksDistanceThreshold,
                entry.updateFrequency, entry.trackFrequency);
    }

    public Packet getPacketForThisEntity(EntityTrackerEntry trackerEntry) {
        EntityEntry entry = entityMap.get(trackerEntry.myEntity.getClass());
        if (entry == null)
            return null;

        // if (trackerEntry.myEntity instanceof EntityItemInfo) {
                // return new Packet23VehicleSpawn(trackerEntry.myEntity,
                // entry.trackerId);
                // }

        return new Packet23VehicleSpawn(trackerEntry.myEntity, entry.trackerId);

    }

    public Object handleVehicleSpawn(World worldClient,
            Packet23VehicleSpawn packet, double x, double y, double z) {
        EntityEntry entry = entityMap.get(trackerIdMap.get(packet.type));
        if (entry == null)
            return null;

        // if (entry.entityClass == EntityItemInfo.class) {
                // return new EntityItemInfo(worldClient, x, y, z);
                // }

        try {
            return entry.entityClass.getConstructor(World.class, Double.TYPE,
                    Double.TYPE, Double.TYPE).newInstance(worldClient, x, y, z);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        return null;

    }

    public static class EntityEntry {
        private static int trackerIdIncrement = 100;

        public final Class<? extends Entity> entityClass;
        public final int trackerId;
        public final int blocksDistanceThreshold;
        public final int updateFrequency;
        public final boolean trackFrequency;

        public EntityEntry(Class<? extends Entity> entityClass,
                int blocksDistanceThreshold, int updateFrequency,
                boolean trackFrequency) {
            this.entityClass = entityClass;
            this.blocksDistanceThreshold = blocksDistanceThreshold;
            this.updateFrequency = updateFrequency;
            this.trackFrequency = trackFrequency;
            this.trackerId = trackerIdIncrement++;
        }

    }

}