Mineplex2018-withcommit/Plugins/Mineplex.Game.Clans/src/mineplex/game/clans/items/GearManager.java

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_7_R4.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.gear.GearShop;
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.serverdata.serialization.RuntimeTypeAdapterFactory;
import net.minecraft.server.v1_7_R4.Packet;
import net.minecraft.server.v1_7_R4.PacketPlayOutSetSlot;
import net.minecraft.server.v1_7_R4.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/armour/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;
	
	// Armour generation
	private WeightSet<Material> _armourTypes;
	
	// Attribute generation
	private WeightSet<Class<? extends ItemAttribute>> _weaponAttributes;
	private WeightSet<Class<? extends ItemAttribute>> _armourAttributes;
	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.ARMOUR),
												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);
		
		// Armour-based attributes 
		_armourAttributes = 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.STONE_SWORD,
										Material.DIAMOND_AXE, Material.GOLD_AXE, Material.IRON_AXE, Material.STONE_AXE);
		
		// Armour material types
		_armourTypes = 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 : _armourAttributes.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);
		
		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(); 
		CustomItem item = generateItem(itemType);

		if (itemType != ItemType.LEGENDARY)	// Only non-legendaries have attributes
		{
			generateAttributes(item.getAttributes(), itemType, attributeCount);
		}

		return item;
	}
	
	private CustomItem generateItem(ItemType itemType)
	{
		switch(itemType)
		{
		case LEGENDARY:	// Legendary weapon
			Class<? extends LegendaryItem> legendaryClass = _legendaryWeights.generateRandom();
			System.out.println("Legendary: " + legendaryClass.getName());
			return instantiate(legendaryClass);
		case WEAPON:	// Sword or axe
			return new CustomItem(_weaponTypes.generateRandom());
		case ARMOUR: 	// Helmet, chestplate, leggings, or boots
			return new CustomItem(_armourTypes.generateRandom());
		case BOW:		// A bow
			return new CustomItem(Material.BOW);
		default:
			return null;// Never reached, yet required for compilation purposes.
		}
	}
	
	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 ARMOUR:
					sampleAttribute = instantiate(_armourAttributes.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());
	}

	@Override
	public void handle(PacketInfo packetInfo)
	{
		// Don't mask custom gear lore for creative players, as this will break them.
		if (!maskGearPacket(packetInfo.getPlayer())) return;
		
		Packet packet = packetInfo.getPacket();
		
		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_7_R4.ItemStack maskItem(net.minecraft.server.v1_7_R4.ItemStack item)
	{
		if (item == null) return null;	// Cannot mask a null item
		
		CraftItemStack originalItem = CraftItemStack.asCraftMirror(item);
		ItemMeta originalMeta = originalItem.getItemMeta();
		
		if (originalMeta == null || originalMeta.getLore() == null) return item;	// No need to modify item packets with no lore
		
		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);
			}
		}
		
		net.minecraft.server.v1_7_R4.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);
	}
}