Minepacks/Minepacks/src/at/pcgamingfreaks/Minepacks/Bukkit/Backpack.java

/*
 *   Copyright (C) 2020 GeorgH93
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program. If not, see <https://www.gnu.org/licenses/>.
 */

package at.pcgamingfreaks.Minepacks.Bukkit;

import at.pcgamingfreaks.Bukkit.MCVersion;
import at.pcgamingfreaks.Bukkit.Util.InventoryUtils;
import at.pcgamingfreaks.Minepacks.Bukkit.Database.Helper.InventoryCompressor;
import at.pcgamingfreaks.Util.StringUtils;
import lombok.AccessLevel;
import lombok.Setter;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class Backpack implements at.pcgamingfreaks.Minepacks.Bukkit.API.Backpack
{
	@Setter(AccessLevel.PACKAGE) private static ShrinkApproach shrinkApproach = ShrinkApproach.COMPRESS;
	private static Object titleOwn;
	private static String titleOtherFormat;
	private final String titleOther;
	private final OfflinePlayer owner;
	private final Map<Player, Boolean> opened = new ConcurrentHashMap<>(); //Thanks Minecraft 1.14
	private Inventory bp;
	private int size, ownerID;
	private boolean hasChanged;

	public static void setTitle(final @NotNull String title, final @NotNull String titleOther)
	{
		titleOwn = InventoryUtils.prepareTitleForOpenInventoryWithCustomTitle(title);
		titleOtherFormat = titleOther;
	}

	public Backpack(OfflinePlayer owner)
	{
		this(owner, 9);
	}
	
	public Backpack(OfflinePlayer owner, int size)
	{
		this(owner, size, -1);
	}

	public Backpack(OfflinePlayer owner, int size, int ID)
	{
		if(MCVersion.isNewerOrEqualThan(MCVersion.MC_1_14) && size > 54)
		{
			size = 54;
			Minepacks.getInstance().getLogger().warning("Backpacks with more than 6 rows are no longer supported on Minecraft 1.14 and up!");
		}
		this.owner = owner;
		titleOther = StringUtils.limitLength(String.format(titleOtherFormat, owner.getName()), 32);
		bp = Bukkit.createInventory(this, size, titleOther);
		this.size = size;
		ownerID = ID;
	}
	
	public Backpack(final OfflinePlayer owner, ItemStack[] backpack, final int ID)
	{
		this(owner, backpack.length, ID);
		if(MCVersion.isNewerOrEqualThan(MCVersion.MC_1_14) && backpack.length > 54)
		{ // Try to optimize space usage to compress items into only 6 rows
			InventoryCompressor compressor = new InventoryCompressor(backpack, 54);
			final List<ItemStack> toMuch = compressor.compress();
			backpack = compressor.getTargetStacks();
			if(!toMuch.isEmpty())
			{
				Minepacks.getInstance().getLogger().warning(owner.getName() + "'s backpack has to many items.");
				if(owner.isOnline())
				{
					Bukkit.getScheduler().runTask(Minepacks.getInstance(), () -> {
						if(owner.isOnline())
						{
							Player player = owner.getPlayer();
							assert player != null;
							Map<Integer, ItemStack> left = player.getInventory().addItem(toMuch.toArray(new ItemStack[0]));
							left.forEach((id, stack) -> player.getWorld().dropItemNaturally(player.getLocation(), stack));
							this.setChanged();
						}
					});
				}
				else throw new RuntimeException("Backpack to big for MC 1.14 and up!");
			}
		}
		bp.setContents(backpack);
	}
	
	public int getOwnerID()
	{
		return ownerID;
	}
	
	public void setOwnerID(int id)
	{
		ownerID = id;
	}

	@Override
	public @NotNull OfflinePlayer getOwner()
	{
		return owner;
	}

	private void checkResize()
	{
		if(owner.isOnline())
		{
			Player owner = this.owner.getPlayer();
			if(owner != null && owner.hasPermission(Permissions.USE))
			{
				int size = Minepacks.getInstance().getBackpackPermSize(owner);
				if(size != bp.getSize())
				{
					List<ItemStack> items = setSize(size);
					for(ItemStack i : items)
					{
						if(i != null)
						{
							owner.getWorld().dropItemNaturally(owner.getLocation(), i);
						}
					}
				}
			}
		}
	}

	@Override
	public void open(final @NotNull Player player, final boolean editable)
	{
		checkResize();
		opened.put(player, editable);
		if(owner.equals(player)) InventoryUtils.openInventoryWithCustomTitlePrepared(player, bp, titleOwn);
		else player.openInventory(bp);
	}

	@Override
	public void open(final @NotNull Player player, final boolean editable, final @Nullable String title)
	{
		if(title == null)
		{
			open(player, editable);
			return;
		}
		checkResize();
		opened.put(player, editable);
		InventoryUtils.openInventoryWithCustomTitle(player, bp, title);
	}

	public void close(Player p)
	{
		opened.remove(p);
	}

	public void closeAll()
	{
		opened.forEach((key, value) -> key.closeInventory());
		opened.clear();
		save();
	}

	@Override
	public boolean isOpen()
	{
		return !opened.isEmpty();
	}

	@Override
	public boolean canEdit(@NotNull Player player)
	{
		return opened.containsKey(player) && opened.get(player);
	}

	@Override
	public int getSize()
	{
		return size;
	}
	
	public @NotNull List<ItemStack> setSize(int newSize)
	{
		opened.forEach((key, value) -> key.closeInventory()); // Close all open views of the inventory
		List<ItemStack> removedItems;
		ItemStack[] itemStackArray;
		if(bp.getSize() > newSize)
		{
			InventoryCompressor compressor = new InventoryCompressor(bp.getContents(), newSize);
			switch(shrinkApproach)
			{
				case FAST: compressor.fast(); break;
				case COMPRESS: compressor.compress(); break;
				case SORT: compressor.sort(); break;
			}
			itemStackArray = compressor.getTargetStacks();
			removedItems = compressor.getToMuch();
		}
		else
		{
			itemStackArray = bp.getContents();
			removedItems = new ArrayList<>(0);
		}
		bp = Bukkit.createInventory(bp.getHolder(), newSize, titleOther);
		for(int i = 0; i < itemStackArray.length; i++)
		{
			bp.setItem(i, itemStackArray[i]);
		}
		setChanged();
		save(); // Make sure the new inventory is saved
		size = newSize;
		opened.forEach((key, value) -> key.openInventory(bp));
		return removedItems;
	}

	@Override
	public @NotNull Inventory getInventory()
	{
		return bp;
	}

	@Override
	public boolean hasChanged()
	{
		return hasChanged;
	}

	@Override
	public void setChanged()
	{
		hasChanged = true;
	}

	@Override
	public void save()
	{
		if(hasChanged())
		{
			Minepacks.getInstance().getDatabase().saveBackpack(this);
			hasChanged = false;
		}
	}

	public void forceSave()
	{
		hasChanged = true;
		save();
	}

	public void backup()
	{
		Minepacks.getInstance().getDatabase().backup(this);
	}

	@Override
	public void clear()
	{
		bp.clear();
		setChanged();
		save();
	}

	@Override
	public void drop(final @NotNull Location location)
	{
		InventoryUtils.dropInventory(bp, location);
		setChanged();
		save();
	}
}