IMetal

package com.genuineflix.metal.api;

import java.util.List;

import net.minecraft.block.Block;
import net.minecraft.item.Item;
import net.minecraft.nbt.NBTTagCompound;

public interface IMetal extends SaveableData, LoadableData<IMetal> {

    public String getName();

    public String getDisplayName();

    public Block getOre();

    public Block getBlock();

    public Item getIngot();

    public Item getNugget();

    public Item getDust();

    public Generation getGeneration();

    public List<Compound> getCompounds();

    public void setGeneration(Generation generation);

    public void setCompounds(Compound... components);

    public boolean isComposite();

    public static class Generation implements SaveableData, LoadableData<Generation> {

        public float rarity;
        public float depth;
        public int nodes;
        public int size;
        public float spread;
        public float hardness;
        public float resistance;
        private boolean generate;

        public Generation() {}

        public Generation(final float rarity, final float depth, final int nodes, final int size, final float spread, final float hardness, final float resistance) {
            this(rarity, depth, nodes, size, spread, hardness, resistance, false);
        }

        public Generation(final float rarity, final float depth, final int nodes, final int size, final float spread, final float hardness, final float resistance, final boolean generate) {
            this.rarity = rarity;
            this.depth = depth;
            this.nodes = nodes;
            this.size = size;
            this.spread = spread;
            this.hardness = hardness;
            this.resistance = resistance;
            this.generate = generate;
        }

        public boolean canGenerate() {
            return generate;
        }

        public void setGenerate(final boolean generate) {
            this.generate = generate;
        }

        @Override
        public NBTTagCompound save(final NBTTagCompound compound) {
            compound.setFloat("rarity", rarity);
            compound.setFloat("depth", depth);
            compound.setInteger("nodes", nodes);
            compound.setInteger("size", size);
            compound.setFloat("spread", spread);
            compound.setFloat("hardness", hardness);
            compound.setFloat("resistance", resistance);
            compound.setBoolean("generate", generate);
            return compound;
        }

        @Override
        public Generation load(final NBTTagCompound compound) {
            rarity = compound.getFloat("rarity");
            depth = compound.getFloat("depth");
            nodes = compound.getInteger("nodes");
            size = compound.getInteger("size");
            spread = compound.getFloat("spread");
            hardness = compound.getFloat("hardness");
            resistance = compound.getFloat("resistance");
            generate = compound.hasKey("generate") && compound.getBoolean("generate");
            return this;
        }
    }

    public static class Compound implements SaveableData, LoadableData<Compound> {

        public IMetal metal;
        public int factor;

        public Compound() {}

        public Compound(final IMetal metal) {
            this(metal, 1);
        }

        public Compound(final IMetal metal, final int factor) {
            this.metal = metal;
            this.factor = factor;
        }

        @Override
        public boolean equals(final Object obj) {
            if (super.equals(obj))
                return true;
            return obj instanceof Compound && metal.equals(((Compound) obj).metal);
        }

        @Override
        public NBTTagCompound save(final NBTTagCompound compound) {
            compound.setString("class", metal.getClass().getName());
            compound.setTag("metal", metal.save(new NBTTagCompound()));
            compound.setInteger("factor", factor);
            return compound;
        }

        @SuppressWarnings("unchecked")
        @Override
        public Compound load(final NBTTagCompound compound) {
            try {
                metal = ((Class<IMetal>) ClassLoader.getSystemClassLoader().loadClass(compound.getString("class"))).newInstance().load(compound.getCompoundTag("metal"));
                factor = compound.getInteger("factor");
                return this;
            }
            catch (final Exception e) {}
            return null;
        }
    }
}

interface LoadableData<T> {

    public T load(NBTTagCompound compound);
}

interface SaveableData {

    public NBTTagCompound save(NBTTagCompound compound);
}