package WayofTime.bloodmagic.item.armour;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import net.minecraft.client.renderer.ItemMeshDefinition;
import net.minecraft.client.renderer.block.model.ModelResourceLocation;
import net.minecraft.enchantment.Enchantment;
import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.SharedMonsterAttributes;
import net.minecraft.entity.ai.attributes.AttributeModifier;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.MobEffects;
import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.item.ItemArmor;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.potion.PotionEffect;
import net.minecraft.util.DamageSource;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.World;
import net.minecraftforge.common.ISpecialArmor;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import WayofTime.bloodmagic.BloodMagic;
import WayofTime.bloodmagic.api.Constants;
import WayofTime.bloodmagic.api.iface.IMultiWillTool;
import WayofTime.bloodmagic.api.soul.EnumDemonWillType;
import WayofTime.bloodmagic.api.soul.PlayerDemonWillHandler;
import WayofTime.bloodmagic.api.util.helper.NBTHelper;
import WayofTime.bloodmagic.client.IMeshProvider;
import WayofTime.bloodmagic.registry.ModItems;

import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;

public class ItemSentientArmour extends ItemArmor implements ISpecialArmor, IMeshProvider, IMultiWillTool
{
    public static String[] names = { "helmet", "chest", "legs", "boots" };

    public static double[] willBracket = new double[] { 30, 200, 600, 1500, 4000, 6000, 8000, 16000 };
    public static double[] consumptionPerHit = new double[] { 0.1, 0.12, 0.15, 0.2, 0.3, 0.35, 0.4, 0.5 };
    public static double[] extraProtectionLevel = new double[] { 0, 0.25, 0.5, 0.6, 0.7, 0.75, 0.85, 0.9 };
    public static double[] steadfastProtectionLevel = new double[] { 0.25, 0.5, 0.6, 0.7, 0.75, 0.85, 0.9, 0.95 };

    //public static double[] healthBonus = new double[] { 3, 6, 9, 12, 15, 20, 25, 30 };
    public static double[] knockbackBonus = new double[] { 0.2, 0.4, 0.6, 0.8, 1, 1, 1, 1 };

    public static double[] damageBoost = new double[] { 0.03, 0.06, 0.09, 0.12, 0.15, 0.18, 0.22, 0.25 };
    public static double[] attackSpeed = new double[] { -0.02, -0.04, -0.06, -0.08, -0.1, -0.12, -0.14, -0.16 };

    public static double[] speedBonus = new double[] { 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4 };

    public ItemSentientArmour(EntityEquipmentSlot armorType)
    {
        super(ItemArmor.ArmorMaterial.IRON, 0, armorType);
        setUnlocalizedName(Constants.Mod.MODID + ".sentientArmour.");
        setMaxDamage(250);
        setCreativeTab(BloodMagic.tabBloodMagic);
    }

    @Override
    public String getArmorTexture(ItemStack stack, Entity entity, EntityEquipmentSlot slot, String type)
    {
        if (this == ModItems.sentientArmourChest || this == ModItems.sentientArmourHelmet || this == ModItems.sentientArmourBoots)
        {
            switch (this.getCurrentType(stack))
            {
            case DEFAULT:
                return "bloodmagic:models/armor/sentientArmour_layer_1.png";
            case CORROSIVE:
                return "bloodmagic:models/armor/sentientArmour_corrosive_layer_1.png";
            case VENGEFUL:
                return "bloodmagic:models/armor/sentientArmour_vengeful_layer_1.png";
            case DESTRUCTIVE:
                return "bloodmagic:models/armor/sentientArmour_destructive_layer_1.png";
            case STEADFAST:
                return "bloodmagic:models/armor/sentientArmour_steadfast_layer_1.png";
            }
            return "bloodmagic:models/armor/sentientArmour_layer_1.png";
        }

        if (this == ModItems.sentientArmourLegs)
        {
            switch (this.getCurrentType(stack))
            {
            case DEFAULT:
                return "bloodmagic:models/armor/sentientArmour_layer_2.png";
            case CORROSIVE:
                return "bloodmagic:models/armor/sentientArmour_corrosive_layer_2.png";
            case VENGEFUL:
                return "bloodmagic:models/armor/sentientArmour_vengeful_layer_2.png";
            case DESTRUCTIVE:
                return "bloodmagic:models/armor/sentientArmour_destructive_layer_2.png";
            case STEADFAST:
                return "bloodmagic:models/armor/sentientArmour_steadfast_layer_2.png";
            }
            return "bloodmagic:models/armor/sentientArmour_layer_1.png";
        } else
        {
            return null;
        }
    }

    @Override
    public void onArmorTick(World world, EntityPlayer player, ItemStack stack)
    {
        if (this.armorType == EntityEquipmentSlot.CHEST)
        {
            EnumDemonWillType type = this.getCurrentType(stack);
            switch (type)
            {
            case CORROSIVE:
                if (player.isPotionActive(MobEffects.POISON))
                {
                    player.removeActivePotionEffect(MobEffects.POISON);
                }
                if (player.isPotionActive(MobEffects.WITHER))
                {
                    player.removeActivePotionEffect(MobEffects.WITHER);
                }
                break;
            default:
            }
        }
    }

    public void onPlayerAttacked(ItemStack stack, DamageSource source, EntityPlayer attackedPlayer)
    {
        if (source.getEntity() instanceof EntityLivingBase)
        {
            EntityLivingBase attacker = (EntityLivingBase) source.getEntity();
            EnumDemonWillType type = this.getCurrentType(stack);
            switch (type)
            {
            case CORROSIVE:
                if (!source.isProjectile())
                {
                    attacker.addPotionEffect(new PotionEffect(MobEffects.POISON, 100)); //TODO: customize duration
                }
                break;
            case DEFAULT:
                break;
            case DESTRUCTIVE:
                break;
            case STEADFAST:
                break;
            case VENGEFUL:
                break;
            }
        }
    }

    @Override
    public ArmorProperties getProperties(EntityLivingBase player, ItemStack stack, DamageSource source, double damage, int slot)
    {
        double armourReduction = 0.0;
        double damageAmount = 0.25;

        if (this == ModItems.sentientArmourBoots || this == ModItems.sentientArmourHelmet)
        {
            damageAmount = 3d / 20d * 0.6;
        } else if (this == ModItems.sentientArmourLegs)
        {
            damageAmount = 6d / 20d * 0.6;
        } else if (this == ModItems.sentientArmourChest)
        {
            damageAmount = 0.64;
        }

        double armourPenetrationReduction = 0;

        int maxAbsorption = 100000;

        if (source.equals(DamageSource.drown))
        {
            return new ArmorProperties(-1, 0, 0);
        }

        if (source.equals(DamageSource.outOfWorld))
        {
            return new ArmorProperties(-1, 0, 0);
        }

        if (this == ModItems.sentientArmourChest)
        {
            armourReduction = 0.24 / 0.64; // This values puts it at iron level

            ItemStack helmet = player.getItemStackFromSlot(EntityEquipmentSlot.HEAD);
            ItemStack leggings = player.getItemStackFromSlot(EntityEquipmentSlot.LEGS);
            ItemStack boots = player.getItemStackFromSlot(EntityEquipmentSlot.FEET);

            if (helmet == null || leggings == null || boots == null)
            {
                damageAmount *= (armourReduction);

                return new ArmorProperties(-1, damageAmount, maxAbsorption);
            }

            if (helmet.getItem() instanceof ItemSentientArmour && leggings.getItem() instanceof ItemSentientArmour && boots.getItem() instanceof ItemSentientArmour)
            {
                double remainder = 1; // Multiply this number by the armour upgrades for protection
                remainder *= (1 - this.getArmourModifier(stack));

                armourReduction = armourReduction + (1 - remainder) * (1 - armourReduction);
                damageAmount *= (armourReduction);

                if (source.isUnblockable())
                {
                    return new ArmorProperties(-1, damageAmount * armourPenetrationReduction, maxAbsorption);
                }

                return new ArmorProperties(-1, damageAmount, maxAbsorption);
            }
        } else
        {
            if (source.isUnblockable())
            {
                return new ArmorProperties(-1, damageAmount * armourPenetrationReduction, maxAbsorption);
            }

            return new ArmorProperties(-1, damageAmount, maxAbsorption);
        }

        return new ArmorProperties(-1, 0, 0);
    }

    @Override
    public int getArmorDisplay(EntityPlayer player, ItemStack armor, int slot)
    {
        if (armor.getItem() == ModItems.sentientArmourHelmet)
        {
            return 3;
        }

        if (armor.getItem() == ModItems.sentientArmourChest)
        {
            return 8;
        }

        if (armor.getItem() == ModItems.sentientArmourLegs)
        {
            return 6;
        }

        if (armor.getItem() == ModItems.sentientArmourBoots)
        {
            return 3;
        }

        return 5;
    }

    @Override
    public void damageArmor(EntityLivingBase entity, ItemStack stack, DamageSource source, int damage, int slot)
    {
        if (entity instanceof EntityPlayer)
        {
            EntityPlayer player = (EntityPlayer) entity;

            EnumDemonWillType type = getCurrentType(stack);

            double willRequired = this.getCostModifier(stack) * damage;
            double willLeft = PlayerDemonWillHandler.getTotalDemonWill(type, player);
            if (willLeft >= willRequired && canSustainArmour(type, willLeft))
            {
                this.setAbilitiesOfArmour(type, willLeft - willRequired, stack);
                PlayerDemonWillHandler.consumeDemonWill(type, player, willRequired);
            } else
            {
                this.revertArmour(player, stack);
            }
        }
    }

    public double getCostModifier(ItemStack stack)
    {
        NBTHelper.checkNBT(stack);
        NBTTagCompound tag = stack.getTagCompound();

        return tag.getDouble("costModifier");
    }

    public void setCostModifier(ItemStack stack, double modifier)
    {
        NBTHelper.checkNBT(stack);
        NBTTagCompound tag = stack.getTagCompound();

        tag.setDouble("costModifier", modifier);
    }

    public double getArmourModifier(ItemStack stack)
    {
        NBTHelper.checkNBT(stack);
        NBTTagCompound tag = stack.getTagCompound();

        return tag.getDouble("armourModifier");
    }

    public void setArmourModifier(ItemStack stack, double modifier)
    {
        NBTHelper.checkNBT(stack);
        NBTTagCompound tag = stack.getTagCompound();

        tag.setDouble("armourModifier", modifier);
    }

    @Override
    public String getUnlocalizedName(ItemStack stack)
    {
        return super.getUnlocalizedName(stack) + names[3 - armorType.getIndex()];
    }

    public void revertArmour(EntityPlayer player, ItemStack itemStack)
    {
        ItemStack stack = this.getContainedArmourStack(itemStack);
        player.setItemStackToSlot(armorType, stack);
    }

    @Override
    @SideOnly(Side.CLIENT)
    public ItemMeshDefinition getMeshDefinition()
    {
        return new ItemMeshDefinition()
        {
            @Override
            public ModelResourceLocation getModelLocation(ItemStack stack)
            {
                assert getCustomLocation() != null;
                EnumDemonWillType type = ((ItemSentientArmour) ModItems.sentientArmourHelmet).getCurrentType(stack);
                String additional = "_" + type.getName().toLowerCase();
                if (stack.getItem() == ModItems.sentientArmourHelmet)
                    return new ModelResourceLocation(getCustomLocation(), "armour=head" + additional);
                else if (stack.getItem() == ModItems.sentientArmourChest)
                    return new ModelResourceLocation(getCustomLocation(), "armour=body" + additional);
                else if (stack.getItem() == ModItems.sentientArmourLegs)
                    return new ModelResourceLocation(getCustomLocation(), "armour=leg" + additional);
                else
                    return new ModelResourceLocation(getCustomLocation(), "armour=feet" + additional);
            }
        };
    }

    @Override
    public ResourceLocation getCustomLocation()
    {
        return new ResourceLocation(Constants.Mod.MODID, "item/ItemSentientArmour");
    }

    @Override
    public List<String> getVariants()
    {
        List<String> ret = new ArrayList<String>();
        for (EnumDemonWillType type : EnumDemonWillType.values())
        {
            String additional = "_" + type.getName().toLowerCase();

            ret.add("armour=head" + additional);
            ret.add("armour=body" + additional);
            ret.add("armour=leg" + additional);
            ret.add("armour=feet" + additional);
        }

        return ret;
    }

    @Override
    public Multimap<String, AttributeModifier> getAttributeModifiers(EntityEquipmentSlot slot, ItemStack stack)
    {
        Multimap<String, AttributeModifier> multimap = HashMultimap.<String, AttributeModifier>create();
        if (slot == EntityEquipmentSlot.CHEST)
        {
            multimap.put(SharedMonsterAttributes.MAX_HEALTH.getAttributeUnlocalizedName(), new AttributeModifier(new UUID(0, 318145), "Armor modifier", this.getHealthBonus(stack), 0));
            multimap.put(SharedMonsterAttributes.KNOCKBACK_RESISTANCE.getAttributeUnlocalizedName(), new AttributeModifier(new UUID(0, 8145), "Armor modifier", this.getKnockbackResistance(stack), 0));
            multimap.put(SharedMonsterAttributes.MOVEMENT_SPEED.getAttributeUnlocalizedName(), new AttributeModifier(new UUID(0, 94021), "Armor modifier", this.getSpeedBoost(stack), 2));
            multimap.put(SharedMonsterAttributes.ATTACK_DAMAGE.getAttributeUnlocalizedName(), new AttributeModifier(new UUID(0, 96721), "Armor modifier", this.getDamageBoost(stack), 2));
            multimap.put(SharedMonsterAttributes.ATTACK_SPEED.getAttributeUnlocalizedName(), new AttributeModifier(new UUID(0, 73245), "Armor modifier", this.getAttackSpeedBoost(stack), 2));
        }
        return multimap;
    }

    public static void revertAllArmour(EntityPlayer player)
    {
        ItemStack[] armourInventory = player.inventory.armorInventory;
        for (ItemStack stack : armourInventory)
        {
            if (stack != null && stack.getItem() instanceof ItemSentientArmour)
            {
                ((ItemSentientArmour) stack.getItem()).revertArmour(player, stack);
            }
        }
    }

    public void setContainedArmourStack(ItemStack newArmour, ItemStack previousArmour)
    {
        if (newArmour == null || previousArmour == null)
        {
            return;
        }

        NBTTagCompound tag = new NBTTagCompound();
        previousArmour.writeToNBT(tag);

        NBTTagCompound omegaTag = newArmour.getTagCompound();
        if (omegaTag == null)
        {
            omegaTag = new NBTTagCompound();
            newArmour.setTagCompound(omegaTag);
        }

        omegaTag.setTag("armour", tag);
        Map<Enchantment, Integer> enchantmentMap = EnchantmentHelper.getEnchantments(previousArmour);
        EnchantmentHelper.setEnchantments(enchantmentMap, newArmour);
    }

    public ItemStack getContainedArmourStack(ItemStack newArmour)
    {
        NBTTagCompound omegaTag = newArmour.getTagCompound();
        if (omegaTag == null)
        {
            return null;
        }

        NBTTagCompound tag = omegaTag.getCompoundTag("armour");
        ItemStack armourStack = ItemStack.loadItemStackFromNBT(tag);

        return armourStack;
    }

    public static boolean convertPlayerArmour(EnumDemonWillType type, double will, EntityPlayer player)
    {
        if (!canSustainArmour(type, will))
        {
            return false;
        }

        ItemStack helmetStack = player.getItemStackFromSlot(EntityEquipmentSlot.HEAD);
        ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
        ItemStack leggingsStack = player.getItemStackFromSlot(EntityEquipmentSlot.LEGS);
        ItemStack bootsStack = player.getItemStackFromSlot(EntityEquipmentSlot.FEET);

        {
            ItemStack omegaHelmetStack = ((ItemSentientArmour) ModItems.sentientArmourHelmet).getSubstituteStack(type, will, helmetStack);
            ItemStack omegaChestStack = ((ItemSentientArmour) ModItems.sentientArmourChest).getSubstituteStack(type, will, chestStack);
            ItemStack omegaLeggingsStack = ((ItemSentientArmour) ModItems.sentientArmourLegs).getSubstituteStack(type, will, leggingsStack);
            ItemStack omegaBootsStack = ((ItemSentientArmour) ModItems.sentientArmourBoots).getSubstituteStack(type, will, bootsStack);

            player.setItemStackToSlot(EntityEquipmentSlot.HEAD, omegaHelmetStack);
            player.setItemStackToSlot(EntityEquipmentSlot.CHEST, omegaChestStack);
            player.setItemStackToSlot(EntityEquipmentSlot.LEGS, omegaLeggingsStack);
            player.setItemStackToSlot(EntityEquipmentSlot.FEET, omegaBootsStack);

            return true;
        }
    }

    public ItemStack getSubstituteStack(EnumDemonWillType type, double will, ItemStack previousArmour)
    {
        ItemStack newArmour = new ItemStack(this);

        this.setContainedArmourStack(newArmour, previousArmour);
        this.setAbilitiesOfArmour(type, will, newArmour);

        return newArmour;
    }

    @Override
    public EnumDemonWillType getCurrentType(ItemStack stack)
    {
        NBTHelper.checkNBT(stack);

        NBTTagCompound tag = stack.getTagCompound();

        if (!tag.hasKey(Constants.NBT.WILL_TYPE))
        {
            return EnumDemonWillType.DEFAULT;
        }

        return EnumDemonWillType.valueOf(tag.getString(Constants.NBT.WILL_TYPE));
    }

    public void setCurrentType(EnumDemonWillType type, ItemStack stack)
    {
        NBTHelper.checkNBT(stack);

        NBTTagCompound tag = stack.getTagCompound();

        tag.setString(Constants.NBT.WILL_TYPE, type.toString());
    }

    public void setAbilitiesOfArmour(EnumDemonWillType type, double willValue, ItemStack armourStack)
    {
        int willBracket = getWillBracket(willValue);
        if (willBracket >= 0)
        {
            double recurringCost = consumptionPerHit[willBracket];

            this.setCostModifier(armourStack, recurringCost);
            this.setCurrentType(type, armourStack);

            if (this.armorType == EntityEquipmentSlot.CHEST)
            {
                this.setArmourModifier(armourStack, getArmourModifier(type, willBracket));
                this.setHealthBonus(armourStack, this.getHealthModifier(type, willBracket));
                this.setKnockbackResistance(armourStack, getKnockbackModifier(type, willBracket));
                this.setSpeedBoost(armourStack, getSpeedModifier(type, willBracket));
                this.setDamageBoost(armourStack, getDamageModifier(type, willBracket));
                this.setAttackSpeedBoost(armourStack, getAttackSpeedModifier(type, willBracket));
            }
        }
    }

    public double getArmourModifier(EnumDemonWillType type, int willBracket)
    {
        switch (type)
        {
        case STEADFAST:
            return steadfastProtectionLevel[willBracket];
        default:
            return extraProtectionLevel[willBracket];
        }
    }

    public double getHealthModifier(EnumDemonWillType type, int willBracket)
    {
        switch (type)
        {
        case STEADFAST:
            //return healthBonus[willBracket];
        default:
            return 0;
        }
    }

    public double getKnockbackModifier(EnumDemonWillType type, int willBracket)
    {
        switch (type)
        {
        case STEADFAST:
            return knockbackBonus[willBracket];
        default:
            return 0;
        }
    }

    public double getSpeedModifier(EnumDemonWillType type, int willBracket)
    {
        switch (type)
        {
        case VENGEFUL:
            return speedBonus[willBracket];
        default:
            return 0;
        }
    }

    public double getDamageModifier(EnumDemonWillType type, int willBracket)
    {
        switch (type)
        {
        case DESTRUCTIVE:
            return damageBoost[willBracket];
        default:
            return 0;
        }
    }

    public double getAttackSpeedModifier(EnumDemonWillType type, int willBracket)
    {
        switch (type)
        {
        case DESTRUCTIVE:
            return attackSpeed[willBracket];
        default:
            return 0;
        }
    }

    public static boolean canSustainArmour(EnumDemonWillType type, double willValue)
    {
        return getWillBracket(willValue) >= 0;
    }

    public static int getWillBracket(double will)
    {
        int bracket = -1;

        for (int i = 0; i < willBracket.length; i++)
        {
            if (will >= willBracket[i])
            {
                bracket = i;
            }
        }

        return bracket;
    }

    public double getHealthBonus(ItemStack stack)
    {
        NBTHelper.checkNBT(stack);

        NBTTagCompound tag = stack.getTagCompound();
        return tag.getDouble(Constants.NBT.SOUL_SWORD_HEALTH);
    }

    public void setHealthBonus(ItemStack stack, double hp)
    {
        NBTHelper.checkNBT(stack);

        NBTTagCompound tag = stack.getTagCompound();

        tag.setDouble(Constants.NBT.SOUL_SWORD_HEALTH, hp);
    }

    public double getKnockbackResistance(ItemStack stack)
    {
        NBTHelper.checkNBT(stack);

        NBTTagCompound tag = stack.getTagCompound();
        return tag.getDouble("knockback");
    }

    public void setKnockbackResistance(ItemStack stack, double kb)
    {
        NBTHelper.checkNBT(stack);

        NBTTagCompound tag = stack.getTagCompound();

        tag.setDouble("knockback", kb);
    }

    public double getSpeedBoost(ItemStack stack)
    {
        NBTHelper.checkNBT(stack);

        NBTTagCompound tag = stack.getTagCompound();
        return tag.getDouble("speed");
    }

    public void setSpeedBoost(ItemStack stack, double speed)
    {
        NBTHelper.checkNBT(stack);

        NBTTagCompound tag = stack.getTagCompound();

        tag.setDouble("speed", speed);
    }

    public double getDamageBoost(ItemStack stack)
    {
        NBTHelper.checkNBT(stack);

        NBTTagCompound tag = stack.getTagCompound();
        return tag.getDouble("damage");
    }

    public void setDamageBoost(ItemStack stack, double damage)
    {
        NBTHelper.checkNBT(stack);

        NBTTagCompound tag = stack.getTagCompound();

        tag.setDouble("damage", damage);
    }

    public double getAttackSpeedBoost(ItemStack stack)
    {
        NBTHelper.checkNBT(stack);

        NBTTagCompound tag = stack.getTagCompound();
        return tag.getDouble("attackSpeed");
    }

    public void setAttackSpeedBoost(ItemStack stack, double attackSpeed)
    {
        NBTHelper.checkNBT(stack);

        NBTTagCompound tag = stack.getTagCompound();

        tag.setDouble("attackSpeed", attackSpeed);
    }
}