// • ▌ ▄ ·.  ▄▄▄·  ▄▄ • ▪   ▄▄· ▄▄▄▄·  ▄▄▄·  ▐▄▄▄  ▄▄▄ .
// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
// ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
//      Magicbane Emulator Project © 2013 - 2022
//                www.magicbane.com


package engine.objects;

import ch.claude_martin.enumbitset.EnumBitSet;
import engine.Enum;
import engine.gameManager.BuildingManager;
import engine.gameManager.ChatManager;
import engine.gameManager.DbManager;
import engine.net.Dispatch;
import engine.net.DispatchMessage;
import engine.net.client.ClientConnection;
import engine.net.client.msg.*;
import engine.server.MBServerStatics;
import org.joda.time.DateTime;
import org.pmw.tinylog.Logger;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.concurrent.ConcurrentHashMap;

public class Warehouse extends AbstractWorldObject {

    public static ConcurrentHashMap<Integer, Warehouse> warehouseByBuildingUUID = new ConcurrentHashMap<>();
    public EnumBitSet<Enum.ResourceType> lockedResourceTypes;
    public int UID;
    public int buildingUID;
    public ArrayList<Transaction> transactions = new ArrayList<>();
    public ConcurrentHashMap<Enum.ResourceType, Integer> resources = new ConcurrentHashMap<>();


    /**
     * ResultSet Constructor
     */
    public Warehouse(ResultSet rs) throws SQLException {
        super(rs);
        this.UID = rs.getInt("UID");
        this.resources.put(Enum.ResourceType.STONE, rs.getInt("warehouse_stone"));
        this.resources.put(Enum.ResourceType.TRUESTEEL, rs.getInt("warehouse_truesteel"));
        this.resources.put(Enum.ResourceType.IRON, rs.getInt("warehouse_iron"));
        this.resources.put(Enum.ResourceType.ADAMANT, rs.getInt("warehouse_adamant"));
        this.resources.put(Enum.ResourceType.LUMBER, rs.getInt("warehouse_lumber"));
        this.resources.put(Enum.ResourceType.OAK, rs.getInt("warehouse_oak"));
        this.resources.put(Enum.ResourceType.BRONZEWOOD, rs.getInt("warehouse_bronzewood"));
        this.resources.put(Enum.ResourceType.MANDRAKE, rs.getInt("warehouse_mandrake"));
        this.resources.put(Enum.ResourceType.COAL, rs.getInt("warehouse_coal"));
        this.resources.put(Enum.ResourceType.AGATE, rs.getInt("warehouse_agate"));
        this.resources.put(Enum.ResourceType.DIAMOND, rs.getInt("warehouse_diamond"));
        this.resources.put(Enum.ResourceType.ONYX, rs.getInt("warehouse_onyx"));
        this.resources.put(Enum.ResourceType.AZOTH, rs.getInt("warehouse_azoth"));
        this.resources.put(Enum.ResourceType.ORICHALK, rs.getInt("warehouse_orichalk"));
        this.resources.put(Enum.ResourceType.ANTIMONY, rs.getInt("warehouse_antimony"));
        this.resources.put(Enum.ResourceType.SULFUR, rs.getInt("warehouse_sulfur"));
        this.resources.put(Enum.ResourceType.QUICKSILVER, rs.getInt("warehouse_quicksilver"));
        this.resources.put(Enum.ResourceType.GALVOR, rs.getInt("warehouse_galvor"));
        this.resources.put(Enum.ResourceType.WORMWOOD, rs.getInt("warehouse_wormwood"));
        this.resources.put(Enum.ResourceType.OBSIDIAN, rs.getInt("warehouse_obsidian"));
        this.resources.put(Enum.ResourceType.BLOODSTONE, rs.getInt("warehouse_bloodstone"));
        this.resources.put(Enum.ResourceType.MITHRIL, rs.getInt("warehouse_mithril"));
        this.resources.put(Enum.ResourceType.GOLD, rs.getInt("warehouse_gold"));
        this.lockedResourceTypes = EnumBitSet.asEnumBitSet(rs.getLong("warehouse_locks"), Enum.ResourceType.class);
        this.buildingUID = rs.getInt("parent");
        warehouseByBuildingUUID.put(this.buildingUID, this);
    }

    public static void warehouseDeposit(MerchantMsg msg, PlayerCharacter player, NPC npc) {

        Building warehouseBuilding;
        Warehouse warehouse;
        int depositAmount;
        Dispatch dispatch;

        Item resource = Item.getFromCache(msg.getItemID());

        if (resource == null)
            return;

        depositAmount = msg.getAmount();
        CharacterItemManager itemMan = player.getCharItemManager();

        if (!itemMan.doesCharOwnThisItem(resource.getObjectUUID()))
            return;

        warehouseBuilding = npc.getBuilding();

        if (warehouseBuilding == null)
            return;

        warehouse = warehouseByBuildingUUID.get(warehouseBuilding.getObjectUUID());

        if (warehouse == null)
            return;


        if (!deposit(player, resource, depositAmount, true, true,warehouse)) {
            return;
        }

        ViewResourcesMessage vrm = new ViewResourcesMessage(player);
        vrm.setGuild(player.getGuild());
        vrm.setWarehouseBuilding(warehouseBuilding);
        vrm.configure();
        dispatch = Dispatch.borrow(player, vrm);
        DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
    }

    public static void warehouseWithdraw(MerchantMsg msg, PlayerCharacter player, NPC npc) {

        int withdrawAmount;
        Building warehouseBuilding;
        Warehouse warehouse;
        Dispatch dispatch;

        withdrawAmount = msg.getAmount();
        warehouseBuilding = npc.getBuilding();

        if (warehouseBuilding == null)
            return;

        if (player.getGuild() != warehouseBuilding.getGuild() || !GuildStatusController.isInnerCouncil(player.getGuildStatus()))
            return;

        warehouse = warehouseByBuildingUUID.get(warehouseBuilding.getObjectUUID());

        if (warehouse == null)
            return;

        Enum.ResourceType resourceType = Enum.ResourceType.hashLookup.get(msg.getHashID());

        if (isResourceLocked(warehouse, resourceType)) {
            ChatManager.chatSystemInfo(player, "You cannot withdrawl a locked resource.");
            return;
        }
        if (!withdraw(warehouse, player, resourceType, withdrawAmount, true, true)) {
            ChatManager.chatGuildError(player, "Failed to withdrawl " + resourceType.name() + '.');
            Logger.debug(player.getName() + " Failed to withdrawl  =" + resourceType.name() + " from Warehouse With ID = " + warehouseBuilding.getObjectUUID());
            return;
        }

        ViewResourcesMessage vrm = new ViewResourcesMessage(player);
        vrm.setGuild(player.getGuild());
        vrm.setWarehouseBuilding(warehouseBuilding);
        vrm.configure();
        dispatch = Dispatch.borrow(player, vrm);
        DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
    }

    public static void warehouseLock(MerchantMsg msg, PlayerCharacter player, NPC npc) {
        Building warehouse;
        int hashID;
        Dispatch dispatch;

        hashID = msg.getHashID();
        warehouse = npc.getBuilding();

        if (warehouse == null)
            return;

        if (player.getGuild() != warehouse.getGuild() || !GuildStatusController.isInnerCouncil(player.getGuildStatus()))
            return;

        Warehouse wh = warehouseByBuildingUUID.get(warehouse.getObjectUUID());

        if (wh == null)
            return;

        Enum.ResourceType resourceType = Enum.ResourceType.hashLookup.get(hashID);

        if (isResourceLocked(wh, resourceType)) {
            boolean worked;
            EnumBitSet<Enum.ResourceType> bitSet = EnumBitSet.asEnumBitSet(wh.lockedResourceTypes.toLong(), Enum.ResourceType.class);

            bitSet.remove(Enum.ResourceType.resourceLookup.get(ItemBase.getItemBase(resourceType.templateID)));

            worked = DbManager.WarehouseQueries.updateLocks(wh, bitSet.toLong());

            if (worked) {
                wh.lockedResourceTypes.remove(Enum.ResourceType.resourceLookup.get(ItemBase.getItemBase(resourceType.templateID)));
                ViewResourcesMessage vrm = new ViewResourcesMessage(player);
                vrm.setGuild(player.getGuild());
                vrm.setWarehouseBuilding(warehouse);
                vrm.configure();
                dispatch = Dispatch.borrow(player, vrm);
                DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
            }
            return;
        }

        EnumBitSet<Enum.ResourceType> bitSet = EnumBitSet.asEnumBitSet(wh.lockedResourceTypes.toLong(), Enum.ResourceType.class);

        bitSet.add(Enum.ResourceType.resourceLookup.get(ItemBase.getItemBase(resourceType.templateID)));

        if (!DbManager.WarehouseQueries.updateLocks(wh, bitSet.toLong()))
            return;

        wh.lockedResourceTypes.add(Enum.ResourceType.resourceLookup.get(ItemBase.getItemBase(resourceType.templateID)));
        ViewResourcesMessage vrm = new ViewResourcesMessage(player);
        vrm.setGuild(player.getGuild());
        vrm.setWarehouseBuilding(warehouse);
        vrm.configure();
        dispatch = Dispatch.borrow(player, vrm);
        DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);

    }

    public static synchronized boolean deposit(PlayerCharacter pc, Item resource, int amount, boolean removeFromInventory, boolean transaction, Warehouse warehouse) {

        ClientConnection origin = pc.getClientConnection();

        if (origin == null)
            return false;

        if (amount < 0) {
            Logger.info(pc.getFirstName() + " Attempting to Dupe!!!!!!");
            return false;
        }

        Enum.ResourceType resourceType = Enum.ResourceType.resourceLookup.get(resource.templateID);

        if (warehouse.resources.get(resourceType) == null)
            return false;

        CharacterItemManager itemMan = pc.getCharItemManager();

        if (itemMan == null)
            return false;

        if (itemMan.getGoldTrading() > 0) {
            ErrorPopupMsg.sendErrorPopup(pc, 195);
            return false;
        }

        if (!itemMan.doesCharOwnThisItem(resource.getObjectUUID()))
            return false;

        if (!resource.validForInventory(origin, pc, itemMan))
            return false;

        if (resource.getNumOfItems() < amount)
            return false;

        int oldAmount = warehouse.resources.get(resourceType);

        int newAmount = oldAmount + amount;

        if (newAmount > Enum.ResourceType.resourceLookup.get(resource.templateID).deposit_limit) {
            //ChatManager.chatSystemInfo(pc, "The Warehouse is at it's maximum for this type of resource.");
            return false;
        }


        if (removeFromInventory) {
            if (resourceType.equals(Enum.ResourceType.GOLD)) {

                if (itemMan.getGoldInventory().getNumOfItems() - amount < 0)
                    return false;

                if (itemMan.getGoldInventory().getNumOfItems() - amount > MBServerStatics.PLAYER_GOLD_LIMIT)
                    return false;

                if (!itemMan.modifyInventoryGold(-amount)) {
                    //ChatManager.chatSystemError(pc, "You do not have this Gold.");
                    return false;
                }

                UpdateGoldMsg ugm = new UpdateGoldMsg(pc);
                ugm.configure();
                Dispatch dispatch = Dispatch.borrow(pc, ugm);
                DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);

                itemMan.updateInventory();

            } else {
                itemMan.delete(resource);
                itemMan.updateInventory();
            }
        }
        itemMan.updateInventory();

        if (!DepositApproved(resourceType, amount, warehouse))
            return false;

        warehouse.resources.put(resourceType, newAmount);

        if (resource.template.item_type.equals(Enum.ItemType.GOLD))
            resourceType = Enum.ResourceType.GOLD;
        else
            resourceType = Enum.ResourceType.valueOf(ItemTemplate.itemTemplates.get(resource.getTemplateID()).item_base_name.toUpperCase());

        if (transaction)
            AddTransactionToWarehouse(warehouse, pc.getObjectType(), pc.getObjectUUID(), Enum.TransactionType.DEPOSIT, resourceType, amount);

        return true;
    }

    public static synchronized boolean depositFromMine(Mine mine, Enum.ResourceType resourceType, int amount, Warehouse warehouse) {

        int oldAmount = warehouse.resources.get(resourceType);
        int newAmount = oldAmount + amount;

        if (newAmount > resourceType.deposit_limit)
            return false;

        if (!DepositApproved(resourceType, amount, warehouse))
            return false;

        warehouse.resources.put(resourceType, newAmount);

        if (mine != null)
            AddTransactionToWarehouse(warehouse, Enum.GameObjectType.Building, mine.getBuildingID(), Enum.TransactionType.MINE, resourceType, amount);

        return true;
    }

    public static boolean DepositApproved(Enum.ResourceType resourceType, int amount, Warehouse warehouse) {


        if (warehouse.resources.get(resourceType) == null)
            return false;

        int oldAmount = warehouse.resources.get(resourceType);
        int newAmount = oldAmount + amount;

        if (newAmount > resourceType.deposit_limit)
            return false;

        boolean worked = false;

        switch (resourceType) {
            case GOLD:
                worked = DbManager.WarehouseQueries.updateGold(warehouse, newAmount);
                break;
            case STONE:
                worked = DbManager.WarehouseQueries.updateStone(warehouse, newAmount);
                break;
            case TRUESTEEL:
                worked = DbManager.WarehouseQueries.updateTruesteel(warehouse, newAmount);
                break;
            case IRON:
                worked = DbManager.WarehouseQueries.updateIron(warehouse, newAmount);
                break;
            case ADAMANT:
                worked = DbManager.WarehouseQueries.updateAdamant(warehouse, newAmount);
                break;
            case LUMBER:
                worked = DbManager.WarehouseQueries.updateLumber(warehouse, newAmount);
                break;
            case OAK:
                worked = DbManager.WarehouseQueries.updateOak(warehouse, newAmount);
                break;
            case BRONZEWOOD:
                worked = DbManager.WarehouseQueries.updateBronzewood(warehouse, newAmount);
                break;
            case MANDRAKE:
                worked = DbManager.WarehouseQueries.updateMandrake(warehouse, newAmount);
                break;
            case COAL:
                worked = DbManager.WarehouseQueries.updateCoal(warehouse, newAmount);
                break;
            case AGATE:
                worked = DbManager.WarehouseQueries.updateAgate(warehouse, newAmount);
                break;
            case DIAMOND:
                worked = DbManager.WarehouseQueries.updateDiamond(warehouse, newAmount);
                break;
            case ONYX:
                worked = DbManager.WarehouseQueries.updateOnyx(warehouse, newAmount);
                break;
            case AZOTH:
                worked = DbManager.WarehouseQueries.updateAzoth(warehouse, newAmount);
                break;
            case ORICHALK:
                worked = DbManager.WarehouseQueries.updateOrichalk(warehouse, newAmount);
                break;
            case ANTIMONY:
                worked = DbManager.WarehouseQueries.updateAntimony(warehouse, newAmount);
                break;
            case SULFUR:
                worked = DbManager.WarehouseQueries.updateSulfur(warehouse, newAmount);
                break;
            case QUICKSILVER:
                worked = DbManager.WarehouseQueries.updateQuicksilver(warehouse, newAmount);
                break;
            case GALVOR:
                worked = DbManager.WarehouseQueries.updateGalvor(warehouse, newAmount);
                break;
            case WORMWOOD:
                worked = DbManager.WarehouseQueries.updateWormwood(warehouse, newAmount);
                break;
            case OBSIDIAN:
                worked = DbManager.WarehouseQueries.updateObsidian(warehouse, newAmount);
                break;
            case BLOODSTONE:
                worked = DbManager.WarehouseQueries.updateBloodstone(warehouse, newAmount);
                break;
            case MITHRIL:
                worked = DbManager.WarehouseQueries.updateMithril(warehouse, newAmount);
                break;
        }
        return worked;
    }

    public static synchronized void depositRealmTaxes(PlayerCharacter taxer, Enum.ResourceType resourceType, int amount, Warehouse warehouse) {

        if (!DepositApproved(resourceType, amount, warehouse))
            return;

        int oldAmount = warehouse.resources.get(resourceType);
        int newAmount = oldAmount + amount;
        warehouse.resources.put(resourceType, newAmount);

        AddTransactionToWarehouse(warehouse, taxer.getObjectType(), taxer.getObjectUUID(), Enum.TransactionType.TAXRESOURCEDEPOSIT, resourceType, amount);

    }

    public static synchronized void depositProfitTax(Enum.ResourceType resourceType, int amount, Building building, Warehouse warehouse) {

        if (warehouse.resources.get(resourceType) == null)
            return;

        int oldAmount = warehouse.resources.get(resourceType);
        int newAmount = oldAmount + amount;

        if (newAmount > resourceType.deposit_limit)
            return;

        if (!DepositApproved(resourceType, amount, warehouse))
            return;

        warehouse.resources.put(resourceType, newAmount);

        if (building != null)
            AddTransactionToWarehouse(warehouse, Enum.GameObjectType.Building, building.getObjectUUID(), Enum.TransactionType.DEPOSIT, resourceType, amount);

    }

    public static boolean WithdrawApproved(Enum.ResourceType resourceType, int amount, Warehouse warehouse) {


        if (warehouse.resources.get(resourceType) == null)
            return false;

        if (amount <= 0)
            return false;

        int oldAmount = warehouse.resources.get(resourceType);

        if (oldAmount < amount)
            return false;

        int newAmount = oldAmount - amount;
        boolean worked = false;

        switch (resourceType) {
            case GOLD:
                worked = DbManager.WarehouseQueries.updateGold(warehouse, newAmount);
                break;
            case STONE:
                worked = DbManager.WarehouseQueries.updateStone(warehouse, newAmount);
                break;
            case TRUESTEEL:
                worked = DbManager.WarehouseQueries.updateTruesteel(warehouse, newAmount);
                break;
            case IRON:
                worked = DbManager.WarehouseQueries.updateIron(warehouse, newAmount);
                break;
            case ADAMANT:
                worked = DbManager.WarehouseQueries.updateAdamant(warehouse, newAmount);
                break;
            case LUMBER:
                worked = DbManager.WarehouseQueries.updateLumber(warehouse, newAmount);
                break;
            case OAK:
                worked = DbManager.WarehouseQueries.updateOak(warehouse, newAmount);
                break;
            case BRONZEWOOD:
                worked = DbManager.WarehouseQueries.updateBronzewood(warehouse, newAmount);
                break;
            case MANDRAKE:
                worked = DbManager.WarehouseQueries.updateMandrake(warehouse, newAmount);
                break;
            case COAL:
                worked = DbManager.WarehouseQueries.updateCoal(warehouse, newAmount);
                break;
            case AGATE:
                worked = DbManager.WarehouseQueries.updateAgate(warehouse, newAmount);
                break;
            case DIAMOND:
                worked = DbManager.WarehouseQueries.updateDiamond(warehouse, newAmount);
                break;
            case ONYX:
                worked = DbManager.WarehouseQueries.updateOnyx(warehouse, newAmount);
                break;
            case AZOTH:
                worked = DbManager.WarehouseQueries.updateAzoth(warehouse, newAmount);
                break;
            case ORICHALK:
                worked = DbManager.WarehouseQueries.updateOrichalk(warehouse, newAmount);
                break;
            case ANTIMONY:
                worked = DbManager.WarehouseQueries.updateAntimony(warehouse, newAmount);
                break;
            case SULFUR:
                worked = DbManager.WarehouseQueries.updateSulfur(warehouse, newAmount);
                break;
            case QUICKSILVER:
                worked = DbManager.WarehouseQueries.updateQuicksilver(warehouse, newAmount);
                break;
            case GALVOR:
                worked = DbManager.WarehouseQueries.updateGalvor(warehouse, newAmount);
                break;
            case WORMWOOD:
                worked = DbManager.WarehouseQueries.updateWormwood(warehouse, newAmount);
                break;
            case OBSIDIAN:
                worked = DbManager.WarehouseQueries.updateObsidian(warehouse, newAmount);
                break;
            case BLOODSTONE:
                worked = DbManager.WarehouseQueries.updateBloodstone(warehouse, newAmount);
                break;
            case MITHRIL:
                worked = DbManager.WarehouseQueries.updateMithril(warehouse, newAmount);
                break;
        }
        return worked;
    }

    public static synchronized boolean withdraw(Warehouse warehouse, NPC npc, Enum.ResourceType resourceType, int amount, boolean transaction) {

        int oldAmount = warehouse.resources.get(resourceType);

        int newAmount = oldAmount - amount;

        if (!WithdrawApproved(resourceType, amount, warehouse))
            return false;

        warehouse.resources.put(resourceType, newAmount);

        if (transaction)
            AddTransactionToWarehouse(warehouse, npc.getObjectType(), npc.getObjectUUID(), Enum.TransactionType.WITHDRAWL, resourceType, amount);

        return true;
    }

    public static synchronized void transferResources(Warehouse warehouse, PlayerCharacter taxer, TaxResourcesMsg msg, ArrayList<Enum.ResourceType> realmResources, float taxPercent) {

        for (Enum.ResourceType resourceType : realmResources) {

            if (warehouse.resources.get(resourceType) == null)
                return;

            int amount = (int) (warehouse.resources.get(resourceType) * taxPercent);

            if (amount <= 0) {
                msg.getResources().put(resourceType.hash, 0);
                continue;
            }

            int oldAmount = warehouse.resources.get(resourceType);

            if (oldAmount < amount)
                amount = oldAmount;

            int newAmount = oldAmount - amount;

            if (newAmount < amount)
                continue;

            if (!WithdrawApproved(resourceType, amount, warehouse)) {
                msg.getResources().put(resourceType.hash, 0);
                continue;
            }

            msg.getResources().put(resourceType.hash, amount);

            warehouse.resources.put(resourceType, newAmount);
            depositRealmTaxes(taxer, resourceType, amount, warehouse);
            Enum.ResourceType resource;

            AddTransactionToWarehouse(warehouse, taxer.getObjectType(), taxer.getObjectUUID(), Enum.TransactionType.TAXRESOURCE, resourceType, amount);

        }
    }

    public static synchronized boolean withdraw(Warehouse warehouse, PlayerCharacter pc, Enum.ResourceType resourceType, int amount, boolean addToInventory, boolean transaction) {

        if (pc == null)
            return false;

        ItemTemplate template = ItemTemplate.itemTemplates.get(resourceType.templateID);

        if (warehouse.resources.get(resourceType) == null)
            return false;

        if (amount <= 0)
            return false;

        CharacterItemManager itemMan = pc.getCharItemManager();

        if (itemMan == null)
            return false;

        if (addToInventory)
            if (!itemMan.hasRoomInventory(template.item_wt * amount)) {
                ChatManager.chatSystemInfo(pc, "You can not carry any more of that item.");
                return false;
            }

        if (addToInventory && resourceType.equals(Enum.ResourceType.GOLD)) {
            if (pc.getCharItemManager().getGoldInventory().getNumOfItems() + amount > MBServerStatics.PLAYER_GOLD_LIMIT)
                return false;

            if (pc.getCharItemManager().getGoldInventory().getNumOfItems() + amount < 0)
                return false;
        }
        int oldAmount = warehouse.resources.get(resourceType);

        if (oldAmount < amount)
            return false;

        int newAmount = oldAmount - amount;


        if (!WithdrawApproved(resourceType, amount, warehouse))
            return false;

        warehouse.resources.put(resourceType, newAmount);

        if (addToInventory) {
            if (resourceType.equals(Enum.ResourceType.GOLD)) {

                itemMan.addGoldToInventory(amount, false);
                UpdateGoldMsg ugm = new UpdateGoldMsg(pc);
                ugm.configure();
                Dispatch dispatch = Dispatch.borrow(pc, ugm);
                DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);

                itemMan.updateInventory();
            } else {
                boolean itemWorked = false;

                Item item = new Item(resourceType.templateID);
                item.ownerID = pc.getObjectUUID();
                item.ownerType = Enum.OwnerType.PlayerCharacter;
                item.containerType = Enum.ItemContainerType.INVENTORY;
                item.numberOfItems = amount;

                try {
                    item = DbManager.ItemQueries.PERSIST(item);
                    itemWorked = true;
                } catch (Exception e) {
                    Logger.error(e);
                }
                if (itemWorked) {
                    itemMan.addItemToInventory(item);
                    itemMan.updateInventory();
                }
            }
        }

        if (transaction)
            AddTransactionToWarehouse(warehouse, pc.getObjectType(), pc.getObjectUUID(), Enum.TransactionType.WITHDRAWL, resourceType, amount);

        return true;
    }

    public static synchronized boolean loot(Warehouse warehouse, PlayerCharacter pc, Enum.ResourceType resourceType, int amount, boolean addToInventory) {

        if (pc == null)
            return false;

        ItemTemplate template = ItemTemplate.itemTemplates.get(resourceType);

        if (template == null)
            return false;

        if (warehouse.resources.get(resourceType) == null)
            return false;

        if (amount <= 0)
            return false;

        CharacterItemManager itemMan = pc.getCharItemManager();

        if (itemMan == null)
            return false;

        if (!itemMan.hasRoomInventory(template.item_wt)) {
            ChatManager.chatSystemInfo(pc, "You can not carry any more of that item.");
            return false;
        }

        int oldAmount = warehouse.resources.get(resourceType);

        if (oldAmount < amount)
            return false;

        int newAmount = oldAmount - amount;

        warehouse.resources.put(resourceType, newAmount);

        if (addToInventory) {
            if (resourceType.equals(Enum.ResourceType.GOLD)) {

                itemMan.addGoldToInventory(amount, false);
                UpdateGoldMsg ugm = new UpdateGoldMsg(pc);
                ugm.configure();
                Dispatch dispatch = Dispatch.borrow(pc, ugm);
                DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);

                itemMan.updateInventory();
            } else {
                boolean itemWorked = false;
                Item item = new Item(resourceType.templateID);
                item.ownerID = pc.getObjectUUID();
                item.ownerType = Enum.OwnerType.PlayerCharacter;
                item.containerType = Enum.ItemContainerType.INVENTORY;
                item.numberOfItems = amount;

                try {
                    item = DbManager.ItemQueries.PERSIST(item);
                    itemWorked = true;
                } catch (Exception e) {
                    Logger.error(e);
                }
                if (itemWorked) {
                    itemMan.addItemToInventory(item);
                    itemMan.updateInventory();
                }
            }
        }

        return true;
    }

    public static boolean isEmpty(Warehouse warehouse) {
        int amount = 0;

        for (Enum.ResourceType resourceType : EnumSet.allOf(Enum.ResourceType.class)) {
            amount += warehouse.resources.get(resourceType);

            if (amount > 0)
                return false;
        }
        return true;
    }

    public static void loadAllTransactions(Warehouse warehouse) {
        warehouse.transactions = DbManager.WarehouseQueries.GET_TRANSACTIONS_FOR_WAREHOUSE(warehouse.buildingUID);
    }

    public static void AddTransactionToWarehouse(Warehouse warehouse, Enum.GameObjectType targetType, int targetUUID, Enum.TransactionType transactionType, Enum.ResourceType resource, int amount) {


        if (!DbManager.WarehouseQueries.CREATE_TRANSACTION(warehouse.buildingUID, targetType, targetUUID, transactionType, resource, amount, DateTime.now()))
            return;

        Transaction transaction = new Transaction(warehouse.buildingUID, targetType, targetUUID, transactionType, resource, amount, DateTime.now());
        warehouse.transactions.add(transaction);
    }

    public static boolean isAboveCap(Warehouse warehouse, Enum.ResourceType resourceType, int deposit) {
        int newAmount = warehouse.resources.get(resourceType) + deposit;
        return newAmount > resourceType.deposit_limit;

    }

    public static boolean isResourceLocked(Warehouse warehouse, Enum.ResourceType resourceType) {
        return resourceType.elementOf(warehouse.lockedResourceTypes);
    }

    @Override
    public void updateDatabase() {
        // TODO Auto-generated method stub

    }

    @Override
    public void runAfterLoad() {

        try {
            Building warehouseBuilding = BuildingManager.getBuilding(this.buildingUID);
            Logger.info("configuring warehouse " + UID + " for city " + warehouseBuilding.getCity().getCityName() + " structure UUID " + this.buildingUID);

            //Building is gone, but Warehouse still in DB?? Should never happen, sanity check anyway.
            if (warehouseBuilding == null) {
                Logger.error("Failed to load Building for Warehouse");
                return;
            }

            Zone cityZone = warehouseBuilding.getParentZone();

            if (cityZone == null) {
                Logger.error("Failed to load Zone for Warehouse with UUID " + this.getObjectUUID());
                return;
            }

            City city = City.getCity(cityZone.playerCityUUID);

            if (city == null) {
                Logger.error("Failed to load City for Warehouse with UUID " + this.getObjectUUID());
                return;
            }

            warehouseByBuildingUUID.put(this.buildingUID, this);
            city.setWarehouseBuildingID(this.buildingUID);
        } catch (Exception E) {
            Logger.info(this.getObjectUUID() + " failed");

        }
    }

}