package mineplex.game.clans.items;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.craftbukkit.v1_8_R3.inventory.CraftItemStack;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.plugin.java.JavaPlugin;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import mineplex.core.MiniPlugin;
import mineplex.core.account.CoreClientManager;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilPlayer;
import mineplex.core.common.util.UtilServer;
import mineplex.core.donation.DonationManager;
import mineplex.core.packethandler.IPacketHandler;
import mineplex.core.packethandler.PacketHandler;
import mineplex.core.packethandler.PacketInfo;
import mineplex.game.clans.items.attributes.AttributeContainer;
import mineplex.game.clans.items.attributes.AttributeType;
import mineplex.game.clans.items.attributes.ItemAttribute;
import mineplex.game.clans.items.attributes.armor.ConqueringArmorAttribute;
import mineplex.game.clans.items.attributes.armor.LavaAttribute;
import mineplex.game.clans.items.attributes.armor.PaddedAttribute;
import mineplex.game.clans.items.attributes.armor.ReinforcedAttribute;
import mineplex.game.clans.items.attributes.armor.SlantedAttribute;
import mineplex.game.clans.items.attributes.bow.HeavyArrowsAttribute;
import mineplex.game.clans.items.attributes.bow.HuntingAttribute;
import mineplex.game.clans.items.attributes.bow.InverseAttribute;
import mineplex.game.clans.items.attributes.bow.LeechingAttribute;
import mineplex.game.clans.items.attributes.bow.RecursiveAttribute;
import mineplex.game.clans.items.attributes.bow.ScorchingAttribute;
import mineplex.game.clans.items.attributes.bow.SlayingAttribute;
import mineplex.game.clans.items.attributes.weapon.ConqueringAttribute;
import mineplex.game.clans.items.attributes.weapon.FlamingAttribute;
import mineplex.game.clans.items.attributes.weapon.FrostedAttribute;
import mineplex.game.clans.items.attributes.weapon.HasteAttribute;
import mineplex.game.clans.items.attributes.weapon.JaggedAttribute;
import mineplex.game.clans.items.attributes.weapon.SharpAttribute;
import mineplex.game.clans.items.commands.GearCommand;
import mineplex.game.clans.items.economy.GoldToken;
import mineplex.game.clans.items.generation.Weight;
import mineplex.game.clans.items.generation.WeightSet;
import mineplex.game.clans.items.legendaries.AlligatorsTooth;
import mineplex.game.clans.items.legendaries.GiantsBroadsword;
import mineplex.game.clans.items.legendaries.HyperBlade;
import mineplex.game.clans.items.legendaries.LegendaryItem;
import mineplex.game.clans.items.legendaries.MagneticBlade;
import mineplex.game.clans.items.legendaries.WindBlade;
import mineplex.game.clans.items.smelting.SmeltingListener;
import mineplex.game.clans.items.ui.GearShop;
import mineplex.serverdata.serialization.RuntimeTypeAdapterFactory;
import net.minecraft.server.v1_8_R3.Packet;
import net.minecraft.server.v1_8_R3.PacketPlayOutChat;
import net.minecraft.server.v1_8_R3.PacketPlayOutSetSlot;
import net.minecraft.server.v1_8_R3.PacketPlayOutWindowItems;

/**
 * Manages creation and retrieval of associated {@link PlayerGear}s with online
 * players, as well as offering methods for parsing and handling
 * {@link CustomItem}s.
 * 
 * @author MrTwiggy
 * 		
 */
public class GearManager extends MiniPlugin implements IPacketHandler, Runnable
{
	private static final String ITEM_SERIALIZATION_TAG = "-JSON-";
	private static Gson _gson;
	private static GearManager _instance; // Singleton instance
	
	private Map<String, PlayerGear> _playerGears; // Mapping of player names
													// (key) to cached gear set
													// (value).
	private WeightSet<Integer> _attributeWeights; // Weightings for randomly
													// selecting number of
													// attributes (1, 2, 3)
	private WeightSet<ItemType> _typeWeights; // Weightings for randomly
												// selecting item type
												// (legendary/weapon/armor/bow)
	private Set<String> _creativePlayers; // Set of names for all players
	// currently in Creative gamemode
	
	// Legendary generation
	private WeightSet<Class<? extends LegendaryItem>> _legendaryWeights;
	
	// Weapon generation
	private WeightSet<Material> _weaponTypes;
	
	// Armor generation
	private WeightSet<Material> _armorTypes;
	
	// Attribute generation
	private WeightSet<Class<? extends ItemAttribute>> _weaponAttributes;
	private WeightSet<Class<? extends ItemAttribute>> _armorAttributes;
	private WeightSet<Class<? extends ItemAttribute>> _bowAttributes;
	
	private GearShop _shop;
	
	public GearManager(JavaPlugin plugin, PacketHandler packetHandler, CoreClientManager clientManager, DonationManager donationManager)
	{
		super("CustomGear", plugin);
		
		_instance = this;
		
		_shop = new GearShop(this, clientManager, donationManager);
		
		_creativePlayers = new HashSet<String>();
		_playerGears = new HashMap<String, PlayerGear>();
		// TODO: Introduce configurable non-hardcoded values for generation
		// weights?
		_attributeWeights = new WeightSet<Integer>(new Weight<Integer>(3, 3), new Weight<Integer>(20, 2), new Weight<Integer>(77, 1));
		_typeWeights = new WeightSet<ItemType>(new Weight<ItemType>(10, ItemType.LEGENDARY), new Weight<ItemType>(45, ItemType.ARMOR), new Weight<ItemType>(23, ItemType.WEAPON), new Weight<ItemType>(22, ItemType.BOW));
		
		// Weapon-based attributes
		_weaponAttributes = new WeightSet<Class<? extends ItemAttribute>>(FrostedAttribute.class, SharpAttribute.class, JaggedAttribute.class, HasteAttribute.class, FlamingAttribute.class, ConqueringAttribute.class);
		
		// Armor-based attributes
		_armorAttributes = new WeightSet<Class<? extends ItemAttribute>>(SlantedAttribute.class, ReinforcedAttribute.class, ConqueringArmorAttribute.class, PaddedAttribute.class, LavaAttribute.class);
		
		// Bow-based attributes
		_bowAttributes = new WeightSet<Class<? extends ItemAttribute>>(HeavyArrowsAttribute.class, HuntingAttribute.class, InverseAttribute.class, LeechingAttribute.class, RecursiveAttribute.class, ScorchingAttribute.class, SlayingAttribute.class);
		
		// Weapon material types
		_weaponTypes = new WeightSet<Material>(Material.DIAMOND_SWORD, Material.GOLD_SWORD, Material.IRON_SWORD, Material.DIAMOND_AXE, Material.GOLD_AXE, Material.IRON_AXE);
		
		// Armor material types
		_armorTypes = new WeightSet<Material>(Material.DIAMOND_HELMET, Material.DIAMOND_CHESTPLATE, Material.DIAMOND_LEGGINGS, Material.DIAMOND_BOOTS, Material.IRON_HELMET, Material.IRON_CHESTPLATE, Material.IRON_LEGGINGS, Material.IRON_BOOTS, Material.GOLD_HELMET, Material.GOLD_CHESTPLATE, Material.GOLD_LEGGINGS, Material.GOLD_BOOTS);
		
		// TODO: Initialize list of attributes and types
		
		// Initialize various LegendaryItem types
		_legendaryWeights = new WeightSet<Class<? extends LegendaryItem>>(AlligatorsTooth.class, WindBlade.class, GiantsBroadsword.class, HyperBlade.class, MagneticBlade.class);
		// TODO: Add rest of legendaries, find better way?
		
		// Register listeners
		UtilServer.getServer().getPluginManager().registerEvents(new ItemListener(getPlugin()), getPlugin());
		UtilServer.getServer().getPluginManager().registerEvents(new SmeltingListener(), getPlugin());
		
		// Initialize attribute types factory for JSON handling of polymorphism.
		RuntimeTypeAdapterFactory<ItemAttribute> attributeFactory = RuntimeTypeAdapterFactory.of(ItemAttribute.class);
		
		for (Class<? extends ItemAttribute> attributeType : _armorAttributes.elements())
		{
			attributeFactory.registerSubtype(attributeType);
		}
		for (Class<? extends ItemAttribute> attributeType : _weaponAttributes.elements())
		{
			attributeFactory.registerSubtype(attributeType);
		}
		for (Class<? extends ItemAttribute> attributeType : _bowAttributes.elements())
		{
			attributeFactory.registerSubtype(attributeType);
		}
		
		// Initialize legendary item type factory for JSON handling of
		// polymorphism.
		RuntimeTypeAdapterFactory<CustomItem> customItemType = RuntimeTypeAdapterFactory.of(CustomItem.class);
		customItemType.registerSubtype(CustomItem.class);
		customItemType.registerSubtype(LegendaryItem.class);
		customItemType.registerSubtype(GoldToken.class);
		for (Class<? extends CustomItem> itemType : _legendaryWeights.elements())
		{
			customItemType.registerSubtype(itemType);
		}
		
		// Build GSON instance off factories for future serialization of items.
		_gson = new GsonBuilder().registerTypeAdapterFactory(attributeFactory).registerTypeAdapterFactory(customItemType).create();
		
		packetHandler.addPacketHandler(this, PacketPlayOutSetSlot.class, PacketPlayOutWindowItems.class);
		
		plugin.getServer().getScheduler().runTaskTimer(plugin, this, 1l, 1l);
	}
	
	@Override
	public void addCommands()
	{
		addCommand(new GearCommand(this));
	}
	
	public void addCreativePlayer(Player player)
	{
		_creativePlayers.add(player.getName());
		player.updateInventory();
	}
	
	public void removeCreativePlayer(Player player)
	{
		_creativePlayers.remove(player.getName());
		player.updateInventory();
	}
	
	/**
	 * Tick & update internal logic for {@link GearManager}. Called once per
	 * tick.
	 */
	@Override
	public void run()
	{
		Iterator<PlayerGear> iterator = _playerGears.values().iterator();
		while (iterator.hasNext())
		{
			PlayerGear gear = iterator.next();
			if (gear.isOnline())
			{
				gear.update();
			}
			else
			{
				iterator.remove();
			}
		}
	}
	
	/**
	 * @param player - the player whose {@link PlayerGear} set is to be fetched.
	 * @return the cached or newly instantiated {@link PlayerGear} associated
	 *         with {@code player}.
	 */
	public PlayerGear getPlayerGear(Player player)
	{
		String playerName = player.getName();
		if (!_playerGears.containsKey(playerName))
		{
			PlayerGear gear = new PlayerGear(playerName);
			_playerGears.put(playerName, gear);
		}
		
		return _playerGears.get(playerName);
	}
	
	public CustomItem generateItem()
	{
		int attributeCount = _attributeWeights.generateRandom();
		ItemType itemType = _typeWeights.generateRandom();
		
		RareItemFactory factory = RareItemFactory.begin(itemType);
		
		if (itemType == ItemType.LEGENDARY)
		{
			factory.setLegendary(_legendaryWeights.generateRandom());
		}
		else if (itemType == ItemType.ARMOR)
		{
			factory.setType(_armorTypes.generateRandom());
		}
		else if (itemType == ItemType.WEAPON)
		{
			factory.setType(_weaponTypes.generateRandom());
		}
		else if (itemType == ItemType.BOW)
		{
			factory.setType(Material.BOW);
		}
		
		if (itemType != ItemType.LEGENDARY) // Only non-legendaries have
											// attributes
		{
			AttributeContainer attributes = new AttributeContainer();
			generateAttributes(attributes, itemType, attributeCount);
			
			if (attributes.getSuperPrefix() != null)
			{
				factory.setSuperPrefix(attributes.getSuperPrefix().getClass());
			}
			if (attributes.getPrefix() != null)
			{
				factory.setPrefix(attributes.getPrefix().getClass());
			}
			if (attributes.getSuffix() != null)
			{
				factory.setSuffix(attributes.getSuffix().getClass());
			}
		}
		
		return factory.getWrapper();
	}
	
	private void generateAttributes(AttributeContainer container, ItemType type, int count)
	{
		for (int i = 0; i < count; i++)
		{
			int attempts = 0;
			Set<AttributeType> remaining = container.getRemainingTypes();
			ItemAttribute attribute = null;
			
			while (remaining.size() > 0 && attempts < 10 && attribute == null)
			{
				ItemAttribute sampleAttribute = null;
				
				switch (type)
				{
					case ARMOR:
						sampleAttribute = instantiate(_armorAttributes.generateRandom());
						break;
					case WEAPON:
						sampleAttribute = instantiate(_weaponAttributes.generateRandom());
						break;
					case BOW:
						sampleAttribute = instantiate(_bowAttributes.generateRandom());
						break;
					default:
						break;
				}
				
				if (sampleAttribute != null && remaining.contains(sampleAttribute.getType()))
				{
					attribute = sampleAttribute; // Select valid attribute to
													// add
				}
			}
			
			container.addAttribute(attribute);
		}
	}
	
	public void spawnItem(Location location)
	{
		CustomItem item = generateItem();
		location.getWorld().dropItem(location, item.toItemStack());
	}
	
	public static CustomItem parseItem(ItemStack item)
	{
		String serialization = getItemSerialization(item);
		
		if (serialization != null)
		{
			CustomItem customItem = null;
			
			try
			{
				customItem = deserialize(serialization);
			}
			catch (Exception exception)
			{
				System.out.println("==========");
				System.out.println("GearManager parse problem :");
				System.out.println(serialization);
				System.out.println("==========");
			}
			
			return customItem;
		}
		
		return null; // No serialization found in item's lore, not a custom
						// item!
	}
	
	public static boolean isCustomItem(ItemStack item)
	{
		return getItemSerialization(item) != null;
	}
	
	public static String getItemSerialization(CustomItem customItem)
	{
		String serialization = serialize(customItem);
		
		return ITEM_SERIALIZATION_TAG + serialization;
	}
	
	/**
	 * @param type - the class-type of the object to be instantiated. (must have
	 *        zero-argument constructor)
	 * @return a newly instantiated instance of {@code type} class-type.
	 *         Instantied with zero argument constructor.
	 */
	private static <T> T instantiate(Class<T> type)
	{
		try
		{
			return type.newInstance();
		}
		catch (Exception e)
		{
			return null;
		}
	}
	
	private static String getItemSerialization(ItemStack item)
	{
		if (item == null || item.getItemMeta() == null || item.getItemMeta().getLore() == null) return null;
		
		ItemMeta meta = item.getItemMeta();
		
		for (String lore : meta.getLore())
		{
			if (lore.startsWith(ITEM_SERIALIZATION_TAG)) // Found serialization
															// lore-line
			{
				int tagLength = ITEM_SERIALIZATION_TAG.length();
				String serialization = lore.substring(tagLength);
				
				return serialization;
			}
		}
		
		return null; // Unable to find any serialized lore lines, hence not a
						// CustomItem.
	}
	
	public static String serialize(CustomItem customItem)
	{
		return _gson.toJson(customItem, CustomItem.class);
	}
	
	public static String serialize(AttributeContainer attributes)
	{
		return _gson.toJson(attributes, AttributeContainer.class);
	}
	
	public static CustomItem deserialize(String serialization)
	{
		return _gson.fromJson(serialization, CustomItem.class);
	}
	
	public static <T> T deserialize(String serialization, Class<T> type)
	{
		return _gson.fromJson(serialization, type);
	}
	
	/**
	 * @return singleton instance of {@link GearManager}.
	 */
	public static GearManager getInstance()
	{
		return _instance;
	}
	
	public static void notify(Player player, String message)
	{
		UtilPlayer.message(player, F.main("Gear", message));
	}
	
	/**
	 * @param player - the player to see if they should have their out-going
	 *        packets masked on CustomGear items.
	 * @return true, if the player should have their gear lore masked, false
	 *         otherwise.
	 */
	private boolean maskGearPacket(Player player)
	{
		return player.getGameMode() != GameMode.CREATIVE && !_creativePlayers.contains(player.getName());
	}
	
	public void handle(PacketInfo packetInfo)
	{
		System.out.println("handling packet...");
		
		// Don't mask custom gear lore for creative players, as this will break
		// them.
		if (!maskGearPacket(packetInfo.getPlayer())) return;
		
		Packet<?> packet = packetInfo.getPacket();
		
		System.out.println("<-GearManager-> Packet >> " + packetInfo.getPlayer().getName());
		
		if (packet instanceof PacketPlayOutSetSlot)
		{
			PacketPlayOutSetSlot slotPacket = (PacketPlayOutSetSlot) packet;
			slotPacket.c = maskItem(slotPacket.c); // Mask all out-going item
													// packets
		}
		else if (packet instanceof PacketPlayOutWindowItems)
		{
			PacketPlayOutWindowItems itemsPacket = (PacketPlayOutWindowItems) packet;
			
			for (int i = 0; i < itemsPacket.b.length; i++)
			{
				itemsPacket.b[i] = maskItem(itemsPacket.b[i]); // Mask all
																// out-going
																// item packets
			}
		}
	}
	
	private net.minecraft.server.v1_8_R3.ItemStack maskItem(net.minecraft.server.v1_8_R3.ItemStack item)
	{
		System.out.println("<-GearManager-> attempting item mask...");
		// Cannot mask a null item
		if (item == null)
		{
			return null;
		}
		
		CraftItemStack originalItem = CraftItemStack.asCraftMirror(item);
		ItemMeta originalMeta = originalItem.getItemMeta();
		
		// No need to modify item packets with no lore
		if (originalMeta == null || originalMeta.getLore() == null)
		{
			return item;
		}
		
		List<String> lore = new ArrayList<String>();
		
		for (String line : originalMeta.getLore())
		{
			if (!line.startsWith(ITEM_SERIALIZATION_TAG)) // Remove
															// serialization
															// lines from
															// out-going lore
			{
				lore.add(line);
			}else{
			}
		}
		
		net.minecraft.server.v1_8_R3.ItemStack newItem = CraftItemStack.asNMSCopy(originalItem);
		CraftItemStack newCopy = CraftItemStack.asCraftMirror(newItem);
		ItemMeta newMeta = newCopy.getItemMeta();
		newMeta.setLore(lore);
		newCopy.setItemMeta(newMeta);
		return newItem;
	}
	
	public void openShop(Player player)
	{
		_shop.attemptShopOpen(player);
	}
}