package electroblob.wizardry.item;

import java.util.List;

import electroblob.wizardry.SpellGlyphData;
import electroblob.wizardry.WizardData;
import electroblob.wizardry.Wizardry;
import electroblob.wizardry.constants.Constants;
import electroblob.wizardry.constants.Element;
import electroblob.wizardry.constants.Tier;
import electroblob.wizardry.entity.living.ISummonedCreature;
import electroblob.wizardry.event.SpellCastEvent;
import electroblob.wizardry.event.SpellCastEvent.Source;
import electroblob.wizardry.packet.PacketCastSpell;
import electroblob.wizardry.packet.WizardryPacketHandler;
import electroblob.wizardry.registry.WizardryAdvancementTriggers;
import electroblob.wizardry.registry.WizardryItems;
import electroblob.wizardry.registry.WizardryPotions;
import electroblob.wizardry.registry.WizardryTabs;
import electroblob.wizardry.spell.Spell;
import electroblob.wizardry.util.SpellModifiers;
import electroblob.wizardry.util.WandHelper;
import electroblob.wizardry.util.WizardryUtilities;
import net.minecraft.client.Minecraft;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.util.ITooltipFlag;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLiving;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.item.EnumAction;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.ActionResult;
import net.minecraft.util.EnumActionResult;
import net.minecraft.util.EnumHand;
import net.minecraft.util.math.RayTraceResult;
import net.minecraft.util.text.TextComponentTranslation;
import net.minecraft.world.World;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;

/**
 * This class is (literally) where the magic happens! All wand types are single instances of this class. There's a lot
 * of quite hard-to-read code in here, but unfortunately there's not much I can do about that. For this reason, I have
 * written the {@link WandHelper} class.<i> I strongly recommend you use it for interacting with wand items wherever
 * possible.</i>
 * <p>
 * It's unikely that anything in this class will be of much use externally, but should you wish to use it for whatever
 * reason (perhaps if you extend it), it works as follows:
 * <p>
 * - onItemRightClick is where non-continuous spells are cast, and it sets the item in use for continuous spells<br>
 * - onUsingTick does the casting for continuous spells<br>
 * - onUpdate deals with the cooldowns for the spells
 * 
 * @since Wizardry 1.0
 */
public class ItemWand extends Item {

	public Tier tier;
	public Element element;

	public ItemWand(Tier tier, Element element){
		super();
		setMaxStackSize(1);
		if(element == null || tier == Tier.BASIC){
			setCreativeTab(WizardryTabs.WIZARDRY);
		}
		this.tier = tier;
		this.element = element;
		setMaxDamage(this.tier.maxCharge);
	}

	@Override
	@SideOnly(Side.CLIENT)
	public boolean isFull3D(){
		return true;
	}

	@Override
	@SideOnly(Side.CLIENT)
	public FontRenderer getFontRenderer(ItemStack stack){
		return Wizardry.proxy.getFontRenderer(stack);
	}

	// Max damage is modifiable with upgrades.
	@Override
	public int getMaxDamage(ItemStack itemstack){
		// + 0.5f corrects small float errors rounding down
		return (int)(super.getMaxDamage(itemstack) * (1.0f + Constants.STORAGE_INCREASE_PER_LEVEL
				* WandHelper.getUpgradeLevel(itemstack, WizardryItems.storage_upgrade)) + 0.5f);
	}

	@Override
	public void onUpdate(ItemStack itemstack, World world, Entity entity, int slot, boolean isHeld){

		WandHelper.decrementCooldowns(itemstack);

		// Decrements wand damage (increases mana) every 1.5 seconds if it has a condenser upgrade
		if(!world.isRemote && itemstack.isItemDamaged()
				&& world.getWorldTime() % Constants.CONDENSER_TICK_INTERVAL == 0){
			// If the upgrade level is 0, this does nothing anyway.
			itemstack.setItemDamage(
					itemstack.getItemDamage() - WandHelper.getUpgradeLevel(itemstack, WizardryItems.condenser_upgrade));
		}

		if(entity instanceof EntityPlayer && this.element != null && this.element != Element.MAGIC){
			// As it stands, this will trigger every tick. Not ideal, but I can't find a way to detect if a player
			// has a certain achievement.
			// TODO: check if this is somehow triggerable via JSON conditions.
			WizardryAdvancementTriggers.element_master.triggerFor((EntityPlayer)entity);
		}
	}

	@Override
	public boolean shouldCauseReequipAnimation(ItemStack oldStack, ItemStack newStack, boolean slotChanged){

		// This method does some VERY strange things! Despite its name, it also seems to affect the updating of NBT...

		if(!oldStack.isEmpty() || !newStack.isEmpty()){
			// We only care about the situation where we specifically want the animation NOT to play.
			if(oldStack.getItem() == newStack.getItem() && !slotChanged && oldStack.getItem() instanceof ItemWand
					&& newStack.getItem() instanceof ItemWand
					&& WandHelper.getCurrentSpell(oldStack) == WandHelper.getCurrentSpell(newStack))
				return false;
		}

		return super.shouldCauseReequipAnimation(oldStack, newStack, slotChanged);
	}

	@Override
	public EnumAction getItemUseAction(ItemStack itemstack){
		return WandHelper.getCurrentSpell(itemstack).action;
	}

	@Override
	public int getMaxItemUseDuration(ItemStack stack){
		return 72000;
	}

	@SideOnly(Side.CLIENT)
	@Override
	public void addInformation(ItemStack itemstack, World world, List<String> text, ITooltipFlag advanced){
		EntityPlayerSP player = Minecraft.getMinecraft().player;
		if (player == null) { return; }
		// +0.5f is necessary due to the error in the way floats are calculated.
		if(element != null) text.add("\u00A78" + net.minecraft.client.resources.I18n.format("item." + Wizardry.MODID + ":wand.buff",
				(int)((tier.level + 1) * Constants.DAMAGE_INCREASE_PER_TIER * 100 + 0.5f) + "%",
				element.getDisplayName()));

		Spell spell = WandHelper.getCurrentSpell(itemstack);

		boolean discovered = true;
		if(Wizardry.settings.discoveryMode && !player.capabilities.isCreativeMode && WizardData.get(player) != null
				&& !WizardData.get(player).hasSpellBeenDiscovered(spell)){
			discovered = false;
		}

		text.add("\u00A77" + net.minecraft.client.resources.I18n.format("item." + Wizardry.MODID + ":wand.spell",
				discovered ? "\u00A77" + spell.getDisplayNameWithFormatting()
						: "#\u00A79" + SpellGlyphData.getGlyphName(spell, player.world)));

		text.add("\u00A79" + net.minecraft.client.resources.I18n.format("item." + Wizardry.MODID + ":wand.mana",
				(this.getMaxDamage(itemstack) - this.getDamage(itemstack)), this.getMaxDamage(itemstack)));
	}

	@Override
	public String getItemStackDisplayName(ItemStack stack){
		return (this.element == null ? "" : this.element.getFormattingCode()) + super.getItemStackDisplayName(stack);
	}

	// Continuous spells use the onUsingItemTick method instead of this one.
	/* An important thing to note about this method: it is only called on the server and the client of the player
	 * holding the item (I call this client-inconsistency). This means if you spawn particles here they will not show up
	 * on other players' screens. Instead, this must be done via packets. */
	@Override
	public ActionResult<ItemStack> onItemRightClick(World world, EntityPlayer player, EnumHand hand){

		ItemStack stack = player.getHeldItem(hand);

		// Alternate right-click function; overrides spell casting.
		if(this.selectMinionTarget(player, world)) return new ActionResult<ItemStack>(EnumActionResult.SUCCESS, stack);

		Spell spell = WandHelper.getCurrentSpell(stack);
		SpellModifiers modifiers = this.calculateModifiers(stack, spell);

		// If anything stops the spell working at this point, nothing else happens.
		if(MinecraftForge.EVENT_BUS.post(new SpellCastEvent.Pre(player, spell, modifiers, Source.WAND))){
			return new ActionResult<ItemStack>(EnumActionResult.FAIL, stack);
		}

		// This is here to start the inUse thing, otherwise the onUsingTick method will not fire.
		if(spell.isContinuous && !player.isHandActive()){
			player.setActiveHand(hand);
			// Probably ought to be here. (Does it succeed though?)
			return new ActionResult<ItemStack>(EnumActionResult.SUCCESS, stack);
		}

		// Conditions for the spell to be attempted. The tier check is a failsafe; it should never be false unless the
		// NBT is modified directly.
		if(!spell.isContinuous && spell.tier.level <= this.tier.level
		// Checks that the wand has enough mana to cast the spell
				&& spell.cost <= (stack.getMaxDamage() - stack.getItemDamage())
				// Checks that the spell is not in cooldown or that the player is in creative mode
				&& (WandHelper.getCurrentCooldown(stack) == 0 || player.capabilities.isCreativeMode)){

			// If the spell does not require a packet, the code is run in the old client-inconsistent way, since this
			// means that swingItem() doesn't need packets in order to work, improving performance.
			if(!world.isRemote){

				if(spell.cast(world, player, hand, 0, modifiers)){

					MinecraftForge.EVENT_BUS.post(new SpellCastEvent.Post(player, spell, modifiers, Source.WAND));

					// = Packets =
					if(spell.doesSpellRequirePacket()){
						// Sends a packet to all players in dimension to tell them to spawn particles.
						// Only sent if the spell succeeded, because if the spell failed, you wouldn't
						// need to spawn any particles!
						IMessage msg = new PacketCastSpell.Message(player.getEntityId(), hand, spell.id(), modifiers);
						WizardryPacketHandler.net.sendToDimension(msg, world.provider.getDimension());
					}

					player.setActiveHand(hand);

					// = Cooldown =
					// Spells only have a cooldown in survival
					if(!player.capabilities.isCreativeMode){

						float cooldownMultiplier = 1.0f
								- WandHelper.getUpgradeLevel(stack, WizardryItems.cooldown_upgrade)
										* Constants.COOLDOWN_REDUCTION_PER_LEVEL;

						if(player.isPotionActive(WizardryPotions.font_of_mana)){
							// Dividing by this rather than setting it takes upgrades and font of mana into account
							// simultaneously
							cooldownMultiplier /= 2
									+ player.getActivePotionEffect(WizardryPotions.font_of_mana).getAmplifier();
						}

						WandHelper.setCurrentCooldown(stack, (int)(spell.cooldown * cooldownMultiplier));
					}

					// = Mana cost =
					// The spell costs 20% less for every armour piece of the matching element.
					int armourPieces = getMatchingArmourCount(player, spell);

					stack.damageItem((int)(spell.cost * (1.0f - armourPieces * Constants.COST_REDUCTION_PER_ARMOUR)),
							player);

					return new ActionResult<ItemStack>(EnumActionResult.SUCCESS, stack);
				}

			}else if(!spell.doesSpellRequirePacket()){
				// Client-inconsistent spell casting. This code only runs client-side.
				if(spell.cast(world, player, hand, 0, modifiers)){
					// This is all that needs to happen, because everything above works fine on just the server side.
					MinecraftForge.EVENT_BUS.post(new SpellCastEvent.Post(player, spell, modifiers, Source.WAND));
					return new ActionResult<ItemStack>(EnumActionResult.SUCCESS, stack);
				}
			}
		}

		return new ActionResult<ItemStack>(EnumActionResult.FAIL, stack);
	}

	// For continuous spells. The count argument actually decrements by 1 each tick.
	@Override
	public void onUsingTick(ItemStack stack, EntityLivingBase user, int count){

		if(user instanceof EntityPlayer){

			EntityPlayer player = (EntityPlayer)user;

			Spell spell = WandHelper.getCurrentSpell(stack);
			SpellModifiers modifiers = this.calculateModifiers(stack, spell);
			int castingTick = stack.getMaxItemUseDuration() - count;

			if(MinecraftForge.EVENT_BUS
					.post(new SpellCastEvent.Tick(player, spell, modifiers, Source.WAND, castingTick)))
				return;

			// Continuous spells (these must check if they can be cast each tick since the mana changes)
			if(spell.isContinuous && spell.tier.level <= this.tier.level
					&& spell.cost / 5 <= (stack.getMaxDamage() - stack.getItemDamage())){

				if(spell.cast(player.world, player, player.getActiveHand(), castingTick, modifiers)){

					if(castingTick == 0)
						MinecraftForge.EVENT_BUS.post(new SpellCastEvent.Post(player, spell, modifiers, Source.WAND));

					// = Mana cost =
					// Divides the mana cost over a second appropriately; since damage is an integer it cannot
					// just be divided by 20.
					// Now does five times per second regardless of the spell cost, but each time it does 1/5 of the
					// cost per second.
					int tickNumber = (count % 20) + 1;
					// Tests if the tick counter is a multiple of 4 plus 1, i.e. is true when tickNumber = 1, 5, 9, 13
					// or 17.
					// Made a slight adjustment since the counter starts on 1 and not 4.
					if(tickNumber % 4 == 1){

						int armourPieces = getMatchingArmourCount(player, spell);

						switch(armourPieces){

						case 0:
							stack.damageItem(spell.cost / 5, player);
							break;

						case 1:
							if(tickNumber != 17) stack.damageItem(spell.cost / 5, player);
							break;

						case 2:
							if(tickNumber != 9 && tickNumber != 17) stack.damageItem(spell.cost / 5, player);
							break;

						case 3:
							if(tickNumber != 5 && tickNumber != 13 && tickNumber != 17)
								stack.damageItem(spell.cost / 5, player);
							break;

						case 4:
							if(tickNumber == 1) stack.damageItem(spell.cost / 5, player);
							break;

						}
					}
				}
			}
		}
	}

	@Override
	public boolean itemInteractionForEntity(ItemStack stack, EntityPlayer player, EntityLivingBase entity,
			EnumHand hand){

		if(player.isSneaking() && entity instanceof EntityPlayer && WizardData.get(player) != null){
			// This is one of those "the method doing the work looks as if it's just returning a value" situations.
			// ... I know, right?! I feel very programmer-y. But it's not too confusing here, and it looks neat.
			String string = WizardData.get(player).toggleAlly((EntityPlayer)entity) ? "item." + Wizardry.MODID + ":wand.addally"
					: "item." + Wizardry.MODID + ":wand.removeally";
			if(!player.world.isRemote) player.sendMessage(new TextComponentTranslation(string, entity.getName()));
			return true;
		}

		return false;
	}

	/** Returns a SpellModifiers object with the appropriate modifiers applied for the given ItemStack and Spell. */
	protected SpellModifiers calculateModifiers(ItemStack stack, Spell spell){

		SpellModifiers modifiers = new SpellModifiers();

		// Now we only need to add multipliers if they are not 1.
		int level = WandHelper.getUpgradeLevel(stack, WizardryItems.range_upgrade);
		if(level > 0)
			modifiers.set(WizardryItems.range_upgrade, 1.0f + level * Constants.RANGE_INCREASE_PER_LEVEL, true);

		level = WandHelper.getUpgradeLevel(stack, WizardryItems.duration_upgrade);
		if(level > 0)
			modifiers.set(WizardryItems.duration_upgrade, 1.0f + level * Constants.DURATION_INCREASE_PER_LEVEL, false);

		level = WandHelper.getUpgradeLevel(stack, WizardryItems.blast_upgrade);
		if(level > 0)
			modifiers.set(WizardryItems.blast_upgrade, 1.0f + level * Constants.BLAST_RADIUS_INCREASE_PER_LEVEL, true);

		// I would have liked to have made potion effects increase in strength according to the damage multiplier,
		// but the amplifier level is too discrete to make this work. For example, wither 3 for 10 seconds will kill a
		// normal mob on full 20 health, but wither 2 for the same duration only deals about 6 hearts of damage in
		// total.
		if(this.element == spell.element){
			modifiers.set(SpellModifiers.DAMAGE, 1.0f + (this.tier.level + 1) * Constants.DAMAGE_INCREASE_PER_TIER,
					true);
		}

		return modifiers;
	}

	/** Counts the number of armour pieces the given player is wearing that match the given spell's element. */
	private int getMatchingArmourCount(EntityPlayer player, Spell spell){

		int armourPieces = 0;

		for(EntityEquipmentSlot slot : WizardryUtilities.ARMOUR_SLOTS){

			ItemStack armour = player.getItemStackFromSlot(slot);

			if(armour != null && armour.getItem() instanceof ItemWizardArmour
					&& ((ItemWizardArmour)armour.getItem()).element == spell.element)
				armourPieces++;
		}

		return armourPieces;
	}

	private boolean selectMinionTarget(EntityPlayer player, World world){

		RayTraceResult rayTrace = WizardryUtilities.standardEntityRayTrace(world, player, 16);

		if(rayTrace != null && WizardryUtilities.isLiving(rayTrace.entityHit)){

			EntityLivingBase entity = (EntityLivingBase)rayTrace.entityHit;

			// Sets the selected minion's target to the right-clicked entity
			if(player.isSneaking() && WizardData.get(player) != null && WizardData.get(player).selectedMinion != null){

				ISummonedCreature minion = WizardData.get(player).selectedMinion.get();

				if(minion instanceof EntityLiving && minion != entity){
					// There is now only the new AI! (which greatly improves things)
					((EntityLiving)minion).setAttackTarget(entity);
					// Deselects the selected minion
					WizardData.get(player).selectedMinion = null;
					return true;
				}
			}
		}

		return false;
	}
}