PremiumManager.java

package net.sf.l2j.gameserver.instancemanager;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import net.sf.l2j.commons.config.Config;
import net.sf.l2j.commons.db.DatabaseFactory;
import net.sf.l2j.gameserver.model.L2Object;
import net.sf.l2j.gameserver.model.L2World;
import net.sf.l2j.gameserver.model.actor.instance.L2PcInstance;
import net.sf.l2j.gameserver.model.item.instance.ItemInstance;
import net.sf.l2j.gameserver.model.item.kind.Premium;
import net.sf.l2j.gameserver.network.SystemMessageId;
import net.sf.l2j.gameserver.network.serverpackets.ItemList;
import net.sf.l2j.gameserver.network.serverpackets.SystemMessage;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PremiumManager
{
    protected static final Logger _log = LoggerFactory.getLogger(PremiumManager.class.getName());

    private static int time_multiplier = 1 * 60 * 60; //1 * 60 * 60 equals to hours
    private static PremiumManager _instance;
    private final Map<Integer, Premium> _items = new ConcurrentHashMap<>();

    public static final PremiumManager getInstance()
    {
        if (_instance == null)
        {
            _instance = new PremiumManager();
        }
        return _instance;
    }

    private PremiumManager()
    {
        restore();
    }

    /**
     * Вызывается только когда игрок сам удаляет предмет
     * @param instance
     */
    public synchronized void destroyItem(ItemInstance instance)
    {
        final Premium item = _items.get(instance.getObjectId());
        if (item != null)
        {
            try
            {
                final String query = "DELETE FROM character_premium_items WHERE charId=? AND itemId=?";
                try (Connection con = DatabaseFactory.getInstance().getConnection();
                    PreparedStatement statement = con.prepareStatement(query))
                {
                    statement.setInt(1, item.getCharId());
                    statement.setInt(2, item.getItemId());
                    statement.execute();
                }
            }
            catch (SQLException e)
            {
                _log.warn(e.toString());
            }
        }
    }

    public synchronized void addPremiumItem(ItemInstance instance, int index)
    {
        Premium item = _items.get(instance.getObjectId());
        if (item != null)
        {
            item.setCharId(instance.getOwnerId());
        }
        else
        {
            item = new Premium();
            item.setActivationTime(System.currentTimeMillis() / 1000 + Config.PREMIUM_ITEM_TIME[index] * time_multiplier);
            item.setCharId(instance.getOwnerId());
            item.setItemId(instance.getObjectId());
            _items.put(item.getItemId(), item);
        }

        try
        {
            String query = "UPDATE character_premium_items SET charId=? WHERE itemId=?";
            try (Connection con = DatabaseFactory.getInstance().getConnection();
                PreparedStatement statement_update = con.prepareStatement(query))
            {
                statement_update.setInt(1, item.getCharId());
                statement_update.setInt(2, item.getItemId());
                if (statement_update.executeUpdate() == 0)
                {
                    query = "INSERT INTO character_premium_items (charId,itemId,time) VALUES (?,?,?)";
                    try (PreparedStatement statement_insert = con.prepareStatement(query))
                    {
                        statement_insert.setInt(1, item.getCharId());
                        statement_insert.setInt(2, item.getItemId());
                        statement_insert.setLong(3, item.getActivationTime());
                        statement_insert.execute();
                    }
                }
            }
        }
        catch (SQLException e)
        {
            _log.warn(e.toString());
        }
    }

    private void restore()
    {
        try
        {
            final String query = "SELECT charId,itemId,time FROM character_premium_items";
            try (Connection con = DatabaseFactory.getInstance().getConnection();
                PreparedStatement statement = con.prepareStatement(query);
                ResultSet result = statement.executeQuery())
            {
                while (result.next())
                {
                    final Premium item = new Premium();
                    item.setActivationTime(result.getLong("time"));
                    item.setCharId(result.getInt("charId"));
                    item.setItemId(result.getInt("itemId"));
                    _items.put(item.getItemId(), item);
                }
                _log.info(String.format("PremiumItems: Loaded %s items ", _items.size()));
            }
        }
        catch (SQLException e)
        {
            _log.warn(e.toString());
        }
    }

    private void deleteItem(Premium item)
    {
        _items.remove(item.getItemId());
        try
        {
            final String query = "DELETE FROM character_premium_items WHERE charId=? AND itemId=?";
            try (Connection con = DatabaseFactory.getInstance().getConnection();
                PreparedStatement statement = con.prepareStatement(query))
            {
                statement.setInt(1, item.getCharId());
                statement.setInt(2, item.getItemId());
                statement.execute();
            }
        }
        catch (SQLException e)
        {
            _log.warn(e.toString());
        }

        L2PcInstance pl = L2World.getInstance().getPlayer(item.getCharId());
        if (pl != null)
        {
            ItemInstance instance = pl.getInventory().getItemByObjectId(item.getItemId());
            if (instance != null)
            {
                if (instance.isEquipped())
                {
                    pl.getInventory().unEquipItemInSlot(instance.getLocationSlot());
                }
                pl.getInventory().destroyItem("timeLost", instance, pl, pl);
                pl.sendPacket(new ItemList(pl, false));
                pl.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_DISAPPEARED).addItemName(instance));
                pl.calculatePremiumAttributes();
            }
        }
        else
        {
            try
            {
                final String query = "DELETE FROM items WHERE owner_id=? AND object_id=?";
                if (item.getCharId() != 0)
                {
                    try (Connection con = DatabaseFactory.getInstance().getConnection();
                        PreparedStatement statement = con.prepareStatement(query))
                    {
                        statement.setInt(1, item.getCharId());
                        statement.setInt(2, item.getItemId());
                        statement.execute();
                    }
                }
                else
                {
                    for (L2Object o : L2World.getInstance().getAllVisibleObjects().values())
                    {
                        if (o.getObjectId() == item.getItemId())
                        {
                            L2World.getInstance().removeVisibleObject(o, o.getWorldRegion());
                            break;
                        }
                    }
                }
            }
            catch (SQLException e)
            {
                _log.warn(e.toString());
            }
        }
    }

    public void deleteItemShedule()
    {
        for (final Premium item : _items.values())
        {
            if (item.getActivationTime() < (System.currentTimeMillis() / 1000))
            {
                deleteItem(item);
            }
        }
    }

    public Map<Integer, Premium> getPremiumItems()
    {
        return _items;
    }

    public Premium getPremiumItem(int objId)
    {
        return _items.get(objId);
    }

    public List<Premium> getPremiumItemsByOwner(int charId)
    {
        final List<Premium> value = new ArrayList<>();
        for (Premium item : _items.values())
        {
            if (item.getCharId() == charId)
            {
                value.add(item);
            }
        }
        return value;
    }

    public int getItemIndex(int itemId)
    {
        int[] premiumIdsArray = Config.PREMIUM_ITEM_IDS;
        for (int i = 0; i < premiumIdsArray.length; i++)
        {
            if (premiumIdsArray[i] == itemId)
            {
                return i;
            }
        }
        return -1;
    }

    public Premium getFirstPremiumItem(L2PcInstance player)
    {
        long activationTime = Long.MIN_VALUE;
        Premium firstItem = null;

        if (player == null)
        {
            return null;
        }

        for (Premium premium : getPremiumItemsByOwner(player.getObjectId()))
        {
            ItemInstance item = player.getInventory().getItemByObjectId(premium.getItemId());
            if (item != null)
            {
                long temp = (premium.getActivationTime() - Config.PREMIUM_ITEM_IDS[getItemIndex(item.getItemId())] * time_multiplier) * 1000;
                if (temp > activationTime)
                {
                    activationTime = temp;
                    firstItem = premium;
                }
            }
        }

        return firstItem;
    }
}