package electroblob.wizardry.loot;

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

import org.apache.commons.lang3.ArrayUtils;

import com.google.gson.JsonArray;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSyntaxException;

import electroblob.wizardry.Wizardry;
import electroblob.wizardry.constants.Element;
import electroblob.wizardry.constants.Tier;
import electroblob.wizardry.item.ItemScroll;
import electroblob.wizardry.item.ItemSpellBook;
import electroblob.wizardry.spell.Spell;
import electroblob.wizardry.util.WizardryUtilities;
import net.minecraft.item.ItemStack;
import net.minecraft.util.JsonUtils;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.storage.loot.LootContext;
import net.minecraft.world.storage.loot.conditions.LootCondition;
import net.minecraft.world.storage.loot.functions.LootFunction;

/** Loot function that allows spell books and scrolls to select a random spell based on the standard weighting.
 * Automatically discounts continuous spells when the item in question is a scroll. Can be used as-is with no
 * parameters, but several optional parameters are available for those wishing to customise further:
 * <p>
 * - <b>spells</b>: A list of spells to choose from. Defaults to all enabled spells.<br>
 * - <b>ignore_weighting</b>: true to ignore the standard weighting and just pick a completely random spell. Defaults to
 * false.<br>
 * - <b>tiers</b>: A list of tiers to choose from. Defaults to all tiers.<br>
 * - <b>elements</b>: A list of elements to choose from. Defaults to all elements.
 * <p>
 * This class is effectively a loot table-friendly replacement for the standard weighting method in WizardryUtilities
 * which was the basis of all the old loot systems (not counting wizard trades, which were - and still are - completely
 * separate).
 * <p>
 * Since spells are stored as metadata, this <i>could</i> be done by having an entry for each tier and letting it pick a
 * random spell from that tier by setting the metadata to a random value in the range of values that correspond to that
 * tier. However, this creates a two-fold problem: firstly, not all spells are in tier order, and secondly, if spells are
 * added via addon mods the entries would have to be updated manually with the new numbers.
 * <p>
 * (This reasoning is similar to that for the enchant_randomly function in vanilla Minecraft, since you can specify NBT
 * data in loot tables, but using NBT in this way would be incredibly verbose and inflexible, hence the loot function.)
 * @see WizardryUtilities#getStandardWeightedRandomSpellId(Random, boolean)
 * @author Electroblob
 * @since Wizardry 1.2
 */
/* 
 * You could even use the yet more long-winded method of adding each spell as an individual entry, which would be 
 * stupidly long but would allow precise control over each individual spell... I'll leave that for pack makers to do
 * if they have the patience!
 * */
public class RandomSpell extends LootFunction {

    private final List<Spell> spells;
    private final boolean ignoreWeighting;
    private final List<Tier> tiers;
    private final List<Element> elements;
	
	protected RandomSpell(LootCondition[] conditions, List<Spell> spells, boolean ignoreWeighting, List<Tier> tiers, List<Element> elements){
		super(conditions);
		this.spells = spells;
		this.ignoreWeighting = ignoreWeighting;
		this.tiers = tiers;
		this.elements = elements;
	}

	@Override
	public ItemStack apply(ItemStack stack, Random random, LootContext context){
		
		if(!(stack.getItem() instanceof ItemSpellBook) && !(stack.getItem() instanceof ItemScroll))
			Wizardry.logger.warn("Applying the random_spell loot function to an item that isn't a spell book or scroll.");

		Tier tier;
		Element element;
		
		if(ignoreWeighting){
			if(tiers == null || tiers.isEmpty()){
				tier = Tier.values()[random.nextInt(Tier.values().length)];
			}else{
				tier = tiers.get(random.nextInt(tiers.size()));
			}
		}else{
			if(tiers == null || tiers.isEmpty()){
				tier = Tier.getWeightedRandomTier(random);
			}else{
				tier = Tier.getWeightedRandomTier(random, tiers.toArray(new Tier[0]));
			}
		}
		
		// Elements aren't weighted
		if(elements == null || elements.isEmpty()){
			// Element can only be MAGIC if tier is BASIC
			if(tier == Tier.BASIC){
				element = Element.values()[random.nextInt(Element.values().length)];
			}else{
				Element[] elements = ArrayUtils.removeElement(Element.values(), Element.MAGIC);
				element = elements[random.nextInt(elements.length)];
			}
		}else{
			// In theory, swapping this line to the commented one should make absolutely no difference.
			element = elements.get(random.nextInt(tiers.size()));
			//element = null;
		}
		
		// Here's a thought: does randomly selecting the element beforehand (as opposed to leaving it null and letting
		// the spell randomiser use any element) change the overall outcome at all?
		List<Spell> spellsList = Spell.getSpells(new Spell.TierElementFilter(tier, element));
		if(stack.getItem() instanceof ItemScroll) spellsList.retainAll(Spell.getSpells(Spell.nonContinuousSpells));
		
		// Ensures the tier chosen actually has spells in it, and if not uses BASIC instead. BASIC always has at least
		// the NONE spell since this spell cannot be disabled.
		// NOTE: Commented out for now because it will interfere with the ability to specify tiers and elements.
		// To be honest, I may as well just say that if you disable enough spells to make this important, you deserve
		// less loot!
		/*
		if(spells.isEmpty()){
			spellsList = Spell.getSpells(new Spell.TierElementFilter(EnumTier.BASIC, null));
			if(stack.getItem() instanceof ItemScroll) spellsList.retainAll(Spell.getSpells(Spell.nonContinuousSpells));
		}
		*/
		
		if(spells != null && !spells.isEmpty()){
			spellsList.retainAll(spells);
		}
		
		if(spellsList.isEmpty()){
			Wizardry.logger.warn("Tried to apply the random_spell loot function to an item, but no enabled spells"
					+ "matched the criteria specified. Substituting placeholder (metadata 0) item.");
			stack.setItemDamage(0);
		}else{
			stack.setItemDamage(spellsList.get(random.nextInt(spellsList.size())).id());
		}
		
		return stack;
	}
	
	public static class Serializer extends LootFunction.Serializer<RandomSpell>{
		
        public Serializer(){
            super(new ResourceLocation(Wizardry.MODID, "random_spell"), RandomSpell.class);
        }

        public void serialize(JsonObject object, RandomSpell function, JsonSerializationContext serializationContext){
        	
            if(function.spells != null && !function.spells.isEmpty()){
            	
                JsonArray jsonarray = new JsonArray();

                for(Spell spell : function.spells){
                    jsonarray.add(new JsonPrimitive(spell.getRegistryName().toString()));
                }

                object.add("spells", jsonarray);
            }
            
            object.addProperty("ignore_weighting", function.ignoreWeighting);
            
            if(function.tiers != null && !function.tiers.isEmpty()){
            	
                JsonArray jsonarray = new JsonArray();

                for(Tier tier : function.tiers){
                    jsonarray.add(new JsonPrimitive(tier.getUnlocalisedName()));
                }

                object.add("tiers", jsonarray);
            }
            
            if(function.elements != null && !function.elements.isEmpty()){
            	
                JsonArray jsonarray = new JsonArray();

                for(Element element : function.elements){
                    jsonarray.add(new JsonPrimitive(element.getUnlocalisedName()));
                }

                object.add("elements", jsonarray);
            }
        }

        public RandomSpell deserialize(JsonObject object, JsonDeserializationContext deserializationContext, LootCondition[] conditions){
        	
            List<Spell> spells = null;
            List<Tier> tiers = null;
            List<Element> elements = null;

            if(object.has("spells")){
            	
            	// Vanilla Minecraft calls Lists.<T>newArrayList() here, which is completely pointless.
                spells = new ArrayList<Spell>();

                // Importantly, it is necessary to specify a default (the new JsonArray) here because otherwise the
                // parameter will be mandatory, and the game will crash if it isn't present.
                for (JsonElement element : JsonUtils.getJsonArray(object, "spells", new JsonArray())){
                	
                    String string = JsonUtils.getString(element, "spell");
                    
                    Spell spell = Spell.get(string);

                    if(spell == null){
                        throw new JsonSyntaxException("Unknown spell \'" + string + "\'");
                    }

                    spells.add(spell);
                }
            }
            
            boolean ignoreWeighting = JsonUtils.getBoolean(object, "ignore_weighting", false);
            
            if(object.has("tiers")){
            	
            	// Vanilla Minecraft calls Lists.<T>newArrayList() here, which is completely pointless.
                tiers = new ArrayList<Tier>();

                jsonarray:
                for(JsonElement element : JsonUtils.getJsonArray(object, "tiers", new JsonArray())){
                	
                    String string = JsonUtils.getString(element, "tier");
                    
                	// IDEA: If it is necessary to get tiers by name elsewhere in the future, move this to EnumTier. 
                    for(Tier tier : Tier.values()){
                    	if(tier.getUnlocalisedName().equals(string)){
                            tiers.add(tier);
                    		continue jsonarray;
                    	}
                    }
                    // If the string does not match any of the tiers, throws an exception.
                    throw new JsonSyntaxException("Unknown tier \'" + string + "\'");
                }
            }
            
            if(object.has("elements")){
            	
            	// Vanilla Minecraft calls Lists.<T>newArrayList() here, which is completely pointless.
                elements = new ArrayList<Element>();

                jsonarray:
                for(JsonElement jelement : JsonUtils.getJsonArray(object, "elements", new JsonArray())){
                	
                    String string = JsonUtils.getString(jelement, "element");
                    
                    // IDEA: If it is necessary to get elements by name elsewhere in the future, move this to EnumElement. 
                    for(Element element : Element.values()){
                    	if(element.getUnlocalisedName().equals(string)){
                            elements.add(element);
                    		continue jsonarray;
                    	}
                    }
                    // If the string does not match any of the elements, throws an exception.
                    throw new JsonSyntaxException("Unknown element \'" + string + "\'");
                }
            }

            return new RandomSpell(conditions, spells, ignoreWeighting, tiers, elements);
        }
    }

}