FurnaceMeta.java

package net.cratemuncher.rentafurnace;

import java.util.UUID;

public class FurnaceMeta {
    public UUID owner = null;
    public String ownerName = "";
    public FurnaceState state = FurnaceState.UNLOCKED;
    public int totalCost = 0;
}

FurnaceState.java

package net.cratemuncher.rentafurnace;

public enum FurnaceState {
    UNLOCKED,
    SMELTING,
    FINISHED,
    OUT_OF_MONEY
}

RentAFurnace.java

package net.cratemuncher.rentafurnace;

import net.milkbowl.vault.economy.Economy;
import net.milkbowl.vault.economy.EconomyResponse;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.Furnace;
import org.bukkit.block.Sign;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.SignChangeEvent;
import org.bukkit.event.inventory.FurnaceSmeltEvent;
import org.bukkit.event.inventory.InventoryAction;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryOpenEvent;
import org.bukkit.inventory.FurnaceInventory;
import org.bukkit.inventory.FurnaceRecipe;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.Recipe;
import org.bukkit.metadata.FixedMetadataValue;
import org.bukkit.metadata.MetadataValue;
import org.bukkit.plugin.RegisteredServiceProvider;
import org.bukkit.plugin.java.JavaPlugin;

import java.util.Iterator;
import java.util.List;

public class RentAFurnace extends JavaPlugin implements Listener {
    public static final String TAG = ChatColor.RED + "[" + ChatColor.GOLD + "RentAFurnace" + ChatColor.RED + "]" + ChatColor.GRAY + " ";

    public static Economy econ;

    @Override
    public void onEnable() {
        Bukkit.getPluginManager().registerEvents(this, this);

        RegisteredServiceProvider<Economy> economyProvider = getServer().getServicesManager().getRegistration(net.milkbowl.vault.economy.Economy.class);
        if (economyProvider != null) {
            econ = economyProvider.getProvider();
        }

        getConfig().addDefault("cost", 5);
        getConfig().options().copyDefaults(true);
        saveConfig();
    }

    @EventHandler
    public void onFurnaceSmelt(FurnaceSmeltEvent e) {
        if (isRentalFurnace(e.getBlock())) {
            FurnaceMeta meta = getFurnaceMetadata(e.getBlock());
            if (meta.ownerName != null) {
                if (econ.has(meta.ownerName, getConfig().getDouble("cost"))) {
                    EconomyResponse r = econ.withdrawPlayer(meta.ownerName, getConfig().getDouble("cost"));
                    if (!r.transactionSuccess()) {
                        getLogger().warning("Could not withdraw " + getConfig().getDouble("cost") + econ.currencyNamePlural() + " from " + meta.ownerName + ": " + r.errorMessage);
                    } else {
                        Furnace f = (Furnace) e.getBlock().getState();
                        if (f.getInventory().getSmelting() == null || f.getInventory().getSmelting().getAmount() <= 1) { // If empty (1 item = empty when the event finishes)
                            meta.state = FurnaceState.FINISHED;
                            Player p = Bukkit.getPlayer(meta.owner);
                            p.sendMessage(TAG + "Your furnace has finished smelting, come pick up your items!");
                        } else {
                            if (meta.state == FurnaceState.OUT_OF_MONEY) {
                                Player p = Bukkit.getPlayer(meta.owner);
                                p.sendMessage(TAG + "You now have some money, and your furnace will continue smelting.");
                            }
                        }
                    }
                } else {
                    if (meta.state != FurnaceState.OUT_OF_MONEY) { // Don't send error if error already sent before - that would be spam.
                        Player p = Bukkit.getPlayer(meta.owner);
                        p.sendMessage(TAG + "Your furnace cannot continue smelting, because you do not have enough money. Please pick up your remaining items, or get more money.");
                    }
                    meta.state = FurnaceState.OUT_OF_MONEY;
                    e.setCancelled(true);
                }
            }
            setFurnaceMetadata(e.getBlock(), meta);
        }
    }

    @EventHandler
    @SuppressWarnings("deprecated")
    // yes yes yes player names are deprecated BUT THIS IS TEMPORARY (until Vault decides to implement UUIDs)
    public void onInventoryClick(final InventoryClickEvent e) {
        if (e.getInventory() instanceof FurnaceInventory) {
            final FurnaceInventory i = ((FurnaceInventory) e.getInventory());
            final Block block = i.getHolder().getBlock();
            boolean clickedInFurnaceInventory = e.getRawSlot() == e.getSlot(); // A little quirky, but this checks if the click was in the furnace's inventory and not the player's own.

            if (isRentalFurnace(i.getHolder().getBlock())) {
                final FurnaceMeta meta = getFurnaceMetadata(block);
                final Player p = (Player) e.getWhoClicked();

                if (e.getSlot() == 1) { // Don't touch the fuel!
                    e.setCancelled(true);
                    return;
                }

                if (((clickedInFurnaceInventory && isEither(e.getAction(), InventoryAction.PLACE_ALL, InventoryAction.PLACE_ONE, InventoryAction.PLACE_SOME)) || (!clickedInFurnaceInventory && e.getAction() == InventoryAction.MOVE_TO_OTHER_INVENTORY)) && e.getSlot() == 0 && !isSmeltable(e.getCursor())) { // Holy mother of god
                    p.sendMessage(TAG + "You can't smelt that!");
                    e.setCancelled(true);
                }

                Bukkit.getScheduler().runTaskLater(this, new Runnable() { // Run it later to see what happens AFTER this event finishes.
                    @Override
                    public void run() {
                        boolean empty = i.getResult() == null && i.getSmelting() == null;

                        if (meta.state != FurnaceState.UNLOCKED && empty) {
                            p.sendMessage(TAG + "Your furnace is now unlocked!");
                            meta.state = FurnaceState.UNLOCKED;
                        } else if (meta.state == FurnaceState.UNLOCKED && !empty) {
                            p.sendMessage(TAG + "Your furnace is now locked, and nobody else can steal your stuff!");
                            meta.owner = p.getUniqueId();
                            meta.ownerName = p.getName();
                            meta.state = FurnaceState.SMELTING;
                        }

                        setFurnaceMetadata(block, meta);
                    }
                }, 1L);
            }
        }
    }

    @EventHandler
    public void onSignChange(SignChangeEvent e) {
        if (e.getLine(0).equalsIgnoreCase("[RentAFurnace]")) {
            e.getPlayer().sendMessage(TAG + "Registered a furnace!");
        }
    }

    @EventHandler
    public void onInventoryOpen(InventoryOpenEvent e) {
        Block furnaceBlock = ((FurnaceInventory) e.getInventory()).getHolder().getBlock();
        if (isRentalFurnace(furnaceBlock)) {
            ((FurnaceInventory) e.getInventory()).setFuel(new ItemStack(Material.LAVA_BUCKET, 1));

            FurnaceMeta meta = getFurnaceMetadata(furnaceBlock);
            if (meta.state != FurnaceState.UNLOCKED && (e.getPlayer().getUniqueId() != meta.owner && !e.getPlayer().hasPermission("rentafurnace.admin"))) {
                e.setCancelled(true);
                ((Player) e.getPlayer()).sendMessage(TAG + "That furnace is locked by " + meta.ownerName + "!");
            }
        }
    }

    private boolean isEither(Object a, Object... bs) { // This should be in the std libs.
        for (Object b : bs) {
            if (a == b) {
                return true;
            }
        }
        return false;
    }

    private FurnaceMeta getFurnaceMetadata(Block furnaceBlock) {
        List<MetadataValue> metas = furnaceBlock.getMetadata("rentafurnace");
        if (metas == null || metas.isEmpty()) {
            return addNewMetadata(furnaceBlock);
        }
        System.out.println(FurnaceMeta.class.getClassLoader());
        System.out.println(metas.get(0).value().getClass().getClassLoader());
        return (FurnaceMeta) metas.get(0).value();
    }

    private void setFurnaceMetadata(Block furnaceBlock, FurnaceMeta newMeta) {
        furnaceBlock.setMetadata("rentafurnace", new FixedMetadataValue(this, newMeta));
    }

    private FurnaceMeta addNewMetadata(Block furnace) {
        FurnaceMeta meta = new FurnaceMeta();
        furnace.setMetadata("rentafurnace", new FixedMetadataValue(this, meta));
        return meta;
    }

    @EventHandler
    public void onBlockBreak(BlockBreakEvent e) {
        if (isRentalFurnace(e.getBlock())) {
            e.setCancelled(true);
            e.getPlayer().sendMessage(TAG + "Don't break the rental furnace!");
        }
    }

    public boolean isSmeltable(ItemStack item) {
        Iterator<Recipe> i = Bukkit.getServer().recipeIterator();
        while (i.hasNext()) {
            Recipe r = i.next();
            if (r instanceof FurnaceRecipe) {
                FurnaceRecipe fr = (FurnaceRecipe) r;
                if (fr.getInput().getType().equals(item.getType())) {
                    return true;
                }
            }
        }
        return false;
    }

    public boolean isRentalFurnace(Block furnace) {
        if (!(furnace.getState() instanceof Furnace)) return false;
        Sign sign = null;
        if (furnace.getRelative(1, 0, 0).getState() instanceof Sign)
            sign = (Sign) furnace.getRelative(1, 0, 0).getState();
        if (furnace.getRelative(-1, 0, 0).getState() instanceof Sign)
            sign = (Sign) furnace.getRelative(-1, 0, 0).getState();
        if (furnace.getRelative(0, 0, 1).getState() instanceof Sign)
            sign = (Sign) furnace.getRelative(0, 0, 1).getState();
        if (furnace.getRelative(0, 0, -1).getState() instanceof Sign)
            sign = (Sign) furnace.getRelative(0, 0, -1).getState();

        return sign != null && (sign.getLine(0).equalsIgnoreCase("[RentAFurnace]"));
    }
}