package de.zootaxz.zevolution.common.block;


import de.zootaxz.zevolution.ZCreativeTabs;
import de.zootaxz.zevolution.ZRegistry;
import de.zootaxz.zevolution.core.block.BlockBase;
import de.zootaxz.zevolution.core.block.IBlockMeta;
import de.zootaxz.zevolution.core.block.ItemBlock;
import net.minecraft.block.material.Material;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyEnum;
import net.minecraft.block.state.BlockState;
import net.minecraft.block.state.IBlockState;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumWorldBlockLayer;
import net.minecraft.util.IStringSerializable;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

import java.util.List;
import java.util.Random;

public class BlockOre extends BlockBase implements IBlockMeta{

    public enum Variant implements IStringSerializable {
        UNKNOWN(0, "Unknown", 1, 1, 1, 1, 0xFF0000),
        MANGANESE(1, "Manganese", 5, 2, 1, 4, 0x635762),
        NICKEL(2, "Nickel", 5, 2, 1, 4, 0x747752),
        COBALT(3, "Cobalt", 5, 2, 1, 4, 0x170F87),
        TUNGSTEN(4, "Tungsten", 5, 2, 1, 4, 0x3C3B3A),
        MOLYBDENUM(5, "Molybdenum", 5, 2, 1, 4, 0xD2E2FF),
        VANADIUM(6, "Vanadium", 5, 2, 1, 4, 0xACF2A4),
        COPPER(7, "Copper", 5, 2, 1, 4, 0xF2BE6A),
        SILVER(8, "Silver", 5, 2, 1, 4, 0xEEEEEE),
        LEAD(9, "Lead", 5, 2, 1, 4, 0x97A1D0),
        TIN(10, "Tin", 5, 2, 1, 4, 0xD1D8BF),
        ZINC(11, "Zinc", 5, 2, 1, 4, 0xD0CCB4),
        ALUMINUM(12, "Aluminum", 5, 2, 1, 4, 0xBEBAB8),
        MAGNESIUM(13, "Magnesium", 5, 2, 1, 4, 0xAFB493),
        BERYLLIUM(14, "Beryllium", 5, 2, 1, 4, 0xACA351),
        LITHIUM(15, "Lithium", 5, 2, 1, 4, 0xF7D4B2),
        MITHRIL(16, "Mithril", 5, 2, 1, 4, 0x9DF2F7);

        protected final int id;
        protected final String name;
        protected final float hardness;
        protected final int harvestLevel;
        protected final int quantityDropMin;
        protected final int quantityDropMax;
        protected final int color;

        Variant(int id, String name, float hardness, int harvestLevel, int quantityDropMin, int quantityDropMax, int color) {
            this.id = id;
            this.name = name;
            this.hardness = hardness;
            this.harvestLevel = harvestLevel;
            this.quantityDropMin = quantityDropMin;
            this.quantityDropMax = quantityDropMax;
            this.color = color;
        }

        public static Variant byID(int meta){
            for(Variant variant : Variant.values()){
                if (variant.id == meta){
                    return variant;
                }
            }
            return Variant.UNKNOWN;
        }

        public String getName() {
            return this.name;
        }
    }

    public enum Type implements IStringSerializable{
        ORE(0, "Ore"),
        BLOCK(1, "Block");

        protected final int id;
        protected final String name;
        Type(int id, String name){
            this.id = id;
            this.name = name;
        }

        public String getName(){
            return this.name;
        }

        public static Type byID(int id){
            for(Type type : Type.values()){
                if (type.id == id){
                    return type;
                }
            }
            return Type.ORE;
        }
    }

    private static final PropertyEnum PROPERTY_VARIANT = PropertyEnum.create("variant", Variant.class);
    private static final PropertyEnum PROPERTY_TYPE = PropertyEnum.create("type", Type.class);

    public BlockOre(){
        super(Material.rock);
        this.setUnlocalizedName("blockOre");
        this.setCreativeTab(ZCreativeTabs.blocks);
        ZRegistry.registerBlock(this, ItemBlock.class);
    }

    @SideOnly(Side.CLIENT)
    @Override
    public EnumWorldBlockLayer getBlockLayer() {
        return EnumWorldBlockLayer.CUTOUT;
    }

    @Override
    public int damageDropped(IBlockState state) {
        Variant variant = (Variant)state.getValue(PROPERTY_VARIANT);
        Type type = (Type)state.getValue(PROPERTY_TYPE);
        int meta = encryptBlockData(variant, type);
        System.out.println("ID: " + meta + " Variant: " + variant.name + " Type: " + type.name);
        return meta;
    }

    @Override
    @SideOnly(Side.CLIENT)
    public void getSubBlocks(Item item, CreativeTabs tab, List list) {
        for (Variant variant : Variant.values()) {
            for(Type type : Type.values()){
                list.add(new ItemStack(item, 1, encryptBlockData(variant, type)));
            }
        }
    }

    @Override
    public IBlockState getStateFromMeta(int meta) {
        BlockData blockData = this.decryptBlockData(meta);
        return this.getDefaultState().withProperty(PROPERTY_VARIANT, blockData.variant).withProperty(PROPERTY_TYPE, blockData.type);
    }

    @Override
    public int getMetaFromState(IBlockState state) {
        Type type = (Type)state.getValue(PROPERTY_TYPE);
        Variant variant = (Variant)state.getValue(PROPERTY_VARIANT);
        return encryptBlockData(variant, type);
    }

    @Override
    protected BlockState createBlockState() {
        return new BlockState(this, new IProperty[] {PROPERTY_VARIANT, PROPERTY_TYPE});
    }

    @Override
    public IBlockState onBlockPlaced(World worldIn, BlockPos pos, EnumFacing blockFaceClickedOn, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer) {
        return getStateFromMeta(meta);
    }


    @Override
    public String getMetaName(int meta) {
        BlockData blockData = this.decryptBlockData(meta);
        return blockData.variant.getName() + blockData.type.getName();
    }


    @Override
    public int getColorFromItemStack(ItemStack itemStack, int renderPass) {
        return getColor(itemStack.getItemDamage(), renderPass);
    }

    @SideOnly(Side.CLIENT)
    @Override
    public int colorMultiplier(IBlockAccess blockAccess, BlockPos pos, int renderPass) {
        int meta = this.getMetaFromState(blockAccess.getBlockState(pos));
        return getColor(meta, renderPass);
    }

    private int getColor(int meta, int renderPass){
        BlockData blockData =  this.decryptBlockData(meta);
        if ((renderPass == 1 && blockData.type == Type.ORE) || (renderPass == 0 && blockData.type == Type.BLOCK)){
            return blockData.variant.color;
        }
        return 16777215;
    }


    @Override
    public String getHarvestTool(IBlockState state) {
        return "pickaxe";
    }


    @Override
    public int getHarvestLevel(IBlockState state) {
        BlockData blockData = this.decryptBlockData(this.getMetaFromState(state));
        return blockData.variant.harvestLevel;
    }

    @Override
    public float getBlockHardness(World world, BlockPos pos) {
        IBlockState state = world.getBlockState(pos);
        if (state.getBlock() == this){
            BlockData metaData = this.decryptBlockData(this.getMetaFromState(state));
            return metaData.variant.hardness;
        }
        return 0f;
    }

    @Override
    public Item getItemDropped(IBlockState state, Random random, int fortune){
        return new ItemStack(this).getItem();
    }

    @Override
    public int quantityDropped(IBlockState state, int fortune, Random random) {
        BlockData blockData = this.decryptBlockData(this.getMetaFromState(state));
        if (blockData.variant.quantityDropMin == blockData.variant.quantityDropMax)
            return blockData.variant.quantityDropMin;
        int quantity = blockData.variant.quantityDropMin + (fortune == 0 ? 0 : random.nextInt(fortune));
        return quantity > blockData.variant.quantityDropMax ? blockData.variant.quantityDropMin : quantity;
    }



    private int encryptBlockData(Variant variant, Type type){
        return (variant.id << 4) | type.id;
    }

    private BlockData decryptBlockData(int meta){
        Variant variant = Variant.byID(meta >> 4);
        Type type = Type.byID(meta & 0xF);
        return new BlockData(variant, type);
    }

    private class BlockData {
        public final Variant variant;
        public final Type type;

        public BlockData(Variant variant, Type type){
            this.variant = variant;
            this.type = type;
        }
    }
}