content: /*
   This file is part of the OdinMS Maple Story Server
   Copyright (C) 2008 Patrick Huy <patrick.huy@frz.cc>
   Matthias Butz <matze@odinms.de>
   Jan Christian Meyer <vimes@odinms.de>
  
   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as
   published by the Free Software Foundation version 3 as published by
   the Free Software Foundation. You may not use, modify or distribute
   this program under any other version of the GNU Affero General Public
   License.
  
   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 Affero General Public License for more details.
  
   You should have received a copy of the GNU Affero General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
  package tools;
  
  import java.io.File;
  import java.sql.PreparedStatement;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.LinkedHashMap;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  
  //import net.server.Server;
  import provider.MapleData;
  import provider.MapleDataDirectoryEntry;
  import provider.MapleDataFileEntry;
  import provider.MapleDataProvider;
  import provider.MapleDataProviderFactory;
  import provider.MapleDataTool;
  import tools.DatabaseConnection;
  //import tools.MaplePacketCreator;
  import tools.Pair;
  //import client.MapleCharacter;
  //import client.MapleClient;
  //import client.MapleJob;
  //import client.Skill;
  //import client.SkillFactory;
  //import client.autoban.AutobanFactory;
  //import client.inventory.Equip;
  //import client.inventory.Item;
  //import client.inventory.MapleInventory;
  //import client.inventory.MapleInventoryType;
  //import client.inventory.MapleWeaponType;
  //import constants.ServerConstants;
  //import constants.EquipSlot;
  //import constants.ItemConstants;
  //import constants.skills.Assassin;
  //import constants.skills.Gunslinger;
  //import constants.skills.NightWalker;
  import java.sql.Connection;
  //import server.life.MapleMonsterInformationProvider;
  
  /**
   *
   * @author Matze
   *
   */
  public class MapleItemInformationProvider {
  
      private static MapleItemInformationProvider instance = null;
      protected MapleDataProvider itemData;
      protected MapleDataProvider equipData;
      protected MapleDataProvider stringData;
      protected MapleData cashStringData;
      protected MapleData consumeStringData;
      protected MapleData eqpStringData;
      protected MapleData etcStringData;
      protected MapleData insStringData;
      protected MapleData petStringData;
      protected Map<Integer, Short> slotMaxCache = new HashMap<>();
      protected Map<Integer, Integer> itemEffects = new HashMap<>();
      protected Map<Integer, Map<String, Integer>> equipStatsCache = new HashMap<>();
      protected Map<Integer, Integer> equipCache = new HashMap<>();
      protected Map<Integer, Double> priceCache = new HashMap<>();
      protected Map<Integer, Integer> wholePriceCache = new HashMap<>();
      protected Map<Integer, Integer> projectileWatkCache = new HashMap<>();
      protected Map<Integer, String> nameCache = new HashMap<>();
      protected Map<Integer, String> descCache = new HashMap<>();
      protected Map<Integer, String> msgCache = new HashMap<>();
      protected Map<Integer, Boolean> dropRestrictionCache = new HashMap<>();
      protected Map<Integer, Boolean> pickupRestrictionCache = new HashMap<>();
      protected Map<Integer, Integer> getMesoCache = new HashMap<>();
      protected Map<Integer, Boolean> onEquipUntradableCache = new HashMap<>();
      protected Map<Integer, Boolean> karmaCache = new HashMap<>();
      protected Map<Integer, Integer> triggerItemCache = new HashMap<>();
      protected Map<Integer, Integer> expCache = new HashMap<>();
      protected Map<Integer, Integer> levelCache = new HashMap<>();
      protected List<Pair<Integer, String>> itemNameCache = new ArrayList<>();
      protected Map<Integer, Boolean> consumeOnPickupCache = new HashMap<>();
      protected Map<Integer, Boolean> isQuestItemCache = new HashMap<>();
      protected Map<Integer, String> equipmentSlotCache = new HashMap<>();
      protected Map<Integer, Boolean> noCancelMouseCache = new HashMap<>();
  
      private MapleItemInformationProvider() {
          itemData = MapleDataProviderFactory.getDataProvider(new File(System.getProperty("wzpath") + "/Item.wz"));
          equipData = MapleDataProviderFactory.getDataProvider(new File(System.getProperty("wzpath") + "/Character.wz"));
          stringData = MapleDataProviderFactory.getDataProvider(new File(System.getProperty("wzpath") + "/String.wz"));
          cashStringData = stringData.getData("Cash.img");
          consumeStringData = stringData.getData("Consume.img");
          eqpStringData = stringData.getData("Eqp.img");
          etcStringData = stringData.getData("Etc.img");
          insStringData = stringData.getData("Ins.img");
          petStringData = stringData.getData("Pet.img");
      }
  
      public static MapleItemInformationProvider getInstance() {
          if (instance == null) {
              instance = new MapleItemInformationProvider();
          }
          return instance;
      }
  
      public List<Pair<Integer, String>> getAllItems() {
          if (!itemNameCache.isEmpty()) {
              return itemNameCache;
          }
          List<Pair<Integer, String>> itemPairs = new ArrayList<>();
          MapleData itemsData;
          itemsData = stringData.getData("Cash.img");
          for (MapleData itemFolder : itemsData.getChildren()) {
              itemPairs.add(new Pair<>(Integer.parseInt(itemFolder.getName()), MapleDataTool.getString("name", itemFolder, "NO-NAME")));
          }
          itemsData = stringData.getData("Consume.img");
          for (MapleData itemFolder : itemsData.getChildren()) {
              itemPairs.add(new Pair<>(Integer.parseInt(itemFolder.getName()), MapleDataTool.getString("name", itemFolder, "NO-NAME")));
          }
          itemsData = stringData.getData("Eqp.img").getChildByPath("Eqp");
          for (MapleData eqpType : itemsData.getChildren()) {
              for (MapleData itemFolder : eqpType.getChildren()) {
                  itemPairs.add(new Pair<>(Integer.parseInt(itemFolder.getName()), MapleDataTool.getString("name", itemFolder, "NO-NAME")));
              }
          }
          itemsData = stringData.getData("Etc.img").getChildByPath("Etc");
          for (MapleData itemFolder : itemsData.getChildren()) {
              itemPairs.add(new Pair<>(Integer.parseInt(itemFolder.getName()), MapleDataTool.getString("name", itemFolder, "NO-NAME")));
          }
          itemsData = stringData.getData("Ins.img");
          for (MapleData itemFolder : itemsData.getChildren()) {
              itemPairs.add(new Pair<>(Integer.parseInt(itemFolder.getName()), MapleDataTool.getString("name", itemFolder, "NO-NAME")));
          }
          itemsData = stringData.getData("Pet.img");
          for (MapleData itemFolder : itemsData.getChildren()) {
              itemPairs.add(new Pair<>(Integer.parseInt(itemFolder.getName()), MapleDataTool.getString("name", itemFolder, "NO-NAME")));
          }
          return itemPairs;
      }
  
      public List<Pair<Integer, String>> getAllEtcItems() {
          if (!itemNameCache.isEmpty()) {
              return itemNameCache;
          }
          
          List<Pair<Integer, String>> itemPairs = new ArrayList<>();
          MapleData itemsData;
          
          itemsData = stringData.getData("Etc.img").getChildByPath("Etc");
          for (MapleData itemFolder : itemsData.getChildren()) {
              itemPairs.add(new Pair<>(Integer.parseInt(itemFolder.getName()), MapleDataTool.getString("name", itemFolder, "NO-NAME")));
          }
          return itemPairs;
      }
      
      private MapleData getStringData(int itemId) {
          String cat = "null";
          MapleData theData;
          if (itemId >= 5010000) {
              theData = cashStringData;
          } else if (itemId >= 2000000 && itemId < 3000000) {
              theData = consumeStringData;
          } else if ((itemId >= 1010000 && itemId < 1040000) || (itemId >= 1122000 && itemId < 1123000) || (itemId >= 1132000 && itemId < 1133000) || (itemId >= 1142000 && itemId < 1143000)) {
              theData = eqpStringData;
              cat = "Eqp/Accessory";
          } else if (itemId >= 1000000 && itemId < 1010000) {
              theData = eqpStringData;
              cat = "Eqp/Cap";
          } else if (itemId >= 1102000 && itemId < 1103000) {
              theData = eqpStringData;
              cat = "Eqp/Cape";
          } else if (itemId >= 1040000 && itemId < 1050000) {
              theData = eqpStringData;
              cat = "Eqp/Coat";
          } else if (itemId >= 20000 && itemId < 22000) {
              theData = eqpStringData;
              cat = "Eqp/Face";
          } else if (itemId >= 1080000 && itemId < 1090000) {
              theData = eqpStringData;
              cat = "Eqp/Glove";
          } else if (itemId >= 30000 && itemId < 35000) {
              theData = eqpStringData;
              cat = "Eqp/Hair";
          } else if (itemId >= 1050000 && itemId < 1060000) {
              theData = eqpStringData;
              cat = "Eqp/Longcoat";
          } else if (itemId >= 1060000 && itemId < 1070000) {
              theData = eqpStringData;
              cat = "Eqp/Pants";
          } else if (itemId >= 1802000 && itemId < 1842000) {
              theData = eqpStringData;
              cat = "Eqp/PetEquip";
          } else if (itemId >= 1112000 && itemId < 1120000) {
              theData = eqpStringData;
              cat = "Eqp/Ring";
          } else if (itemId >= 1092000 && itemId < 1100000) {
              theData = eqpStringData;
              cat = "Eqp/Shield";
          } else if (itemId >= 1070000 && itemId < 1080000) {
              theData = eqpStringData;
              cat = "Eqp/Shoes";
          } else if (itemId >= 1900000 && itemId < 2000000) {
              theData = eqpStringData;
              cat = "Eqp/Taming";
          } else if (itemId >= 1300000 && itemId < 1800000) {
              theData = eqpStringData;
              cat = "Eqp/Weapon";
          } else if (itemId >= 4000000 && itemId < 5000000) {
              theData = etcStringData;
              cat = "Etc";
          } else if (itemId >= 3000000 && itemId < 4000000) {
              theData = insStringData;
          } else if (itemId / 1000 == 5000) {
              theData = petStringData;
          } else {
              return null;
          }
          if (cat.equalsIgnoreCase("null")) {
              return theData.getChildByPath(String.valueOf(itemId));
          } else {
              return theData.getChildByPath(cat + "/" + itemId);
          }
      }
  
      public boolean noCancelMouse(int itemId) {
          if (noCancelMouseCache.containsKey(itemId)) {
              return noCancelMouseCache.get(itemId);
          }
          
          MapleData item = getItemData(itemId);
          if (item == null) {
              noCancelMouseCache.put(itemId, false);
              return false;
          }
          
          boolean blockMouse = MapleDataTool.getIntConvert("info/noCancelMouse", item, 0) == 1;
          noCancelMouseCache.put(itemId, blockMouse);
          return blockMouse;
      }
  
      private MapleData getItemData(int itemId) {
          MapleData ret = null;
          String idStr = "0" + String.valueOf(itemId);
          MapleDataDirectoryEntry root = itemData.getRoot();
          for (MapleDataDirectoryEntry topDir : root.getSubdirectories()) {
              for (MapleDataFileEntry iFile : topDir.getFiles()) {
                  if (iFile.getName().equals(idStr.substring(0, 4) + ".img")) {
                      ret = itemData.getData(topDir.getName() + "/" + iFile.getName());
                      if (ret == null) {
                          return null;
                      }
                      ret = ret.getChildByPath(idStr);
                      return ret;
                  } else if (iFile.getName().equals(idStr.substring(1) + ".img")) {
                      return itemData.getData(topDir.getName() + "/" + iFile.getName());
                  }
              }
          }
          root = equipData.getRoot();
          for (MapleDataDirectoryEntry topDir : root.getSubdirectories()) {
              for (MapleDataFileEntry iFile : topDir.getFiles()) {
                  if (iFile.getName().equals(idStr + ".img")) {
                      return equipData.getData(topDir.getName() + "/" + iFile.getName());
                  }
              }
          }
          return ret;
      }
      
      public List<Integer> getItemIdsInRange(int minId, int maxId, boolean ignoreCashItem) {
          List<Integer> list = new ArrayList<>();
          
          if(ignoreCashItem) {
              for(int i = minId; i <= maxId; i++) {
                  if(getItemData(i) != null && !isCash(i)) {
                      list.add(i);
                  }
              }
          }
          else {
              for(int i = minId; i <= maxId; i++) {
                  if(getItemData(i) != null) {
                      list.add(i);
                  }
              }
          }
          
          
          return list;
      }
  
      public short getSlotMax(int itemId) {
          Short slotMax = slotMaxCache.get(itemId);
          if (slotMax != null) {
              return (short)(slotMax);
          }
          short ret = 0;
          MapleData item = getItemData(itemId);
          if (item != null) {
              MapleData smEntry = item.getChildByPath("info/slotMax");
              if (smEntry == null) {
                  ret = 100;
              } else {
                  ret = (short) MapleDataTool.getInt(smEntry);
              }
          }
          
          slotMaxCache.put(itemId, ret);
          return (short)(ret);
      }
  
      public int getMeso(int itemId) {
          if (getMesoCache.containsKey(itemId)) {
              return getMesoCache.get(itemId);
          }
          MapleData item = getItemData(itemId);
          if (item == null) {
              return -1;
          }
          int pEntry;
          MapleData pData = item.getChildByPath("info/meso");
          if (pData == null) {
              return -1;
          }
          pEntry = MapleDataTool.getInt(pData);
          getMesoCache.put(itemId, pEntry);
          return pEntry;
      }
  
      public int getWholePrice(int itemId) {
          if (wholePriceCache.containsKey(itemId)) {
              return wholePriceCache.get(itemId);
          }
          MapleData item = getItemData(itemId);
          if (item == null) {
              return -1;
          }
          int pEntry;
          MapleData pData = item.getChildByPath("info/price");
          if (pData == null) {
              return -1;
          }
          pEntry = MapleDataTool.getInt(pData);
          wholePriceCache.put(itemId, pEntry);
          return pEntry;
      }
  
      public double getPrice(int itemId) {
          if (priceCache.containsKey(itemId)) {
              return priceCache.get(itemId);
          }
          MapleData item = getItemData(itemId);
          if (item == null) {
              return -1;
          }
          double pEntry;
          MapleData pData = item.getChildByPath("info/unitPrice");
          if (pData != null) {
              try {
                  pEntry = MapleDataTool.getDouble(pData);
              } catch (Exception e) {
                  pEntry = (double) MapleDataTool.getInt(pData);
              }
          } else {
              pData = item.getChildByPath("info/price");
              if (pData == null) {
                  return -1;
              }
              try {
                  pEntry = (double) MapleDataTool.getInt(pData);
              } catch(Exception e) {
                  priceCache.put(itemId, 0.0);
                  return 0;
              }
          }
          priceCache.put(itemId, pEntry);
          return pEntry;
      }
      
      protected String getEquipmentSlot(int itemId) {
          if (equipmentSlotCache.containsKey(itemId)) {
              return equipmentSlotCache.get(itemId);
          }
          
          String ret = "";
          
          MapleData item = getItemData(itemId);
          
          if (item == null) {
              return null;
          }
          
          MapleData info = item.getChildByPath("info");
          
          if (info == null) {
              return null;
          }
  
          ret = MapleDataTool.getString("islot", info, "");
          
          equipmentSlotCache.put(itemId, ret);
          
          return ret;
      }
  
      public Map<String, Integer> getEquipStats(int itemId) {
          if (equipStatsCache.containsKey(itemId)) {
              return equipStatsCache.get(itemId);
          }
          Map<String, Integer> ret = new LinkedHashMap<>();
          MapleData item = getItemData(itemId);
          if (item == null) {
              return null;
          }
          MapleData info = item.getChildByPath("info");
          if (info == null) {
              return null;
          }
          for (MapleData data : info.getChildren()) {
              if (data.getName().startsWith("inc")) {
                  ret.put(data.getName().substring(3), MapleDataTool.getIntConvert(data));
              }
              /*else if (data.getName().startsWith("req"))
               ret.put(data.getName(), MapleDataTool.getInt(data.getName(), info, 0));*/
          }
          ret.put("reqJob", MapleDataTool.getInt("reqJob", info, 0));
          ret.put("reqLevel", MapleDataTool.getInt("reqLevel", info, 0));
          ret.put("reqDEX", MapleDataTool.getInt("reqDEX", info, 0));
          ret.put("reqSTR", MapleDataTool.getInt("reqSTR", info, 0));
          ret.put("reqINT", MapleDataTool.getInt("reqINT", info, 0));
          ret.put("reqLUK", MapleDataTool.getInt("reqLUK", info, 0));
          ret.put("reqPOP", MapleDataTool.getInt("reqPOP", info, 0));
          ret.put("cash", MapleDataTool.getInt("cash", info, 0));
          ret.put("tuc", MapleDataTool.getInt("tuc", info, 0));
          ret.put("cursed", MapleDataTool.getInt("cursed", info, 0));
          ret.put("success", MapleDataTool.getInt("success", info, 0));
          ret.put("fs", MapleDataTool.getInt("fs", info, 0));
          equipStatsCache.put(itemId, ret);
          return ret;
      }
  
      public List<Integer> getScrollReqs(int itemId) {
          List<Integer> ret = new ArrayList<>();
          MapleData data = getItemData(itemId);
          data = data.getChildByPath("req");
          if (data == null) {
              return ret;
          }
          for (MapleData req : data.getChildren()) {
              ret.add(MapleDataTool.getInt(req));
          }
          return ret;
      }
  
      public String getName(int itemId) {
          if (nameCache.containsKey(itemId)) {
              return nameCache.get(itemId);
          }
          MapleData strings = getStringData(itemId);
          if (strings == null) {
              return null;
          }
          String ret = MapleDataTool.getString("name", strings, null);
          nameCache.put(itemId, ret);
          return ret;
      }
  
      public String getMsg(int itemId) {
          if (msgCache.containsKey(itemId)) {
              return msgCache.get(itemId);
          }
          MapleData strings = getStringData(itemId);
          if (strings == null) {
              return null;
          }
          String ret = MapleDataTool.getString("msg", strings, null);
          msgCache.put(itemId, ret);
          return ret;
      }
  
      public boolean isDropRestricted(int itemId) {
          if (dropRestrictionCache.containsKey(itemId)) {
              return dropRestrictionCache.get(itemId);
          }
          MapleData data = getItemData(itemId);
          boolean bRestricted = MapleDataTool.getIntConvert("info/tradeBlock", data, 0) == 1;
          if (!bRestricted) {
          	bRestricted = MapleDataTool.getIntConvert("info/accountSharable", data, 0) == 1;
          }
          if (!bRestricted) {
              bRestricted = MapleDataTool.getIntConvert("info/quest", data, 0) == 1;
          }
          dropRestrictionCache.put(itemId, bRestricted);
          return bRestricted;
      }
  
      public boolean isPickupRestricted(int itemId) {
          if (pickupRestrictionCache.containsKey(itemId)) {
              return pickupRestrictionCache.get(itemId);
          }
          MapleData data = getItemData(itemId);
          boolean bRestricted = MapleDataTool.getIntConvert("info/only", data, 0) == 1;
          pickupRestrictionCache.put(itemId, bRestricted);
          return bRestricted;
      }
  
      public Map<String, Integer> getSkillStats(int itemId, double playerJob) {
          Map<String, Integer> ret = new LinkedHashMap<>();
          MapleData item = getItemData(itemId);
          if (item == null) {
              return null;
          }
          MapleData info = item.getChildByPath("info");
          if (info == null) {
              return null;
          }
          for (MapleData data : info.getChildren()) {
              if (data.getName().startsWith("inc")) {
                  ret.put(data.getName().substring(3), MapleDataTool.getIntConvert(data));
              }
          }
          ret.put("masterLevel", MapleDataTool.getInt("masterLevel", info, 0));
          ret.put("reqSkillLevel", MapleDataTool.getInt("reqSkillLevel", info, 0));
          ret.put("success", MapleDataTool.getInt("success", info, 0));
          MapleData skill = info.getChildByPath("skill");
          int curskill;
          for (int i = 0; i < skill.getChildren().size(); i++) {
              curskill = MapleDataTool.getInt(Integer.toString(i), skill, 0);
              if (curskill == 0) {
                  break;
              }
              if (curskill / 10000 == playerJob) {
                  ret.put("skillid", curskill);
                  break;
              }
          }
          if (ret.get("skillid") == null) {
              ret.put("skillid", 0);
          }
          return ret;
      }
  
      public List<Integer> petsCanConsume(int itemId) {
          List<Integer> ret = new ArrayList<>();
          MapleData data = getItemData(itemId);
          int curPetId;
          for (int i = 0; i < data.getChildren().size(); i++) {
              curPetId = MapleDataTool.getInt("spec/" + Integer.toString(i), data, 0);
              if (curPetId == 0) {
                  break;
              }
              ret.add(Integer.valueOf(curPetId));
          }
          return ret;
      }
  
      public boolean isQuestItem(int itemId) {
          if (isQuestItemCache.containsKey(itemId)) {
              return isQuestItemCache.get(itemId);
          }
          MapleData data = getItemData(itemId);
          boolean questItem = MapleDataTool.getIntConvert("info/quest", data, 0) == 1;
          isQuestItemCache.put(itemId, questItem);
          return questItem;
      }
  
      public int getQuestIdFromItem(int itemId) {
          MapleData data = getItemData(itemId);
          int questItem = MapleDataTool.getIntConvert("info/quest", data, 0);
          return questItem;
      }
  
      public boolean isUntradeableOnEquip(int itemId) {
          if (onEquipUntradableCache.containsKey(itemId)) {
              return onEquipUntradableCache.get(itemId);
          }
          boolean untradableOnEquip = MapleDataTool.getIntConvert("info/equipTradeBlock", getItemData(itemId), 0) > 0;
          onEquipUntradableCache.put(itemId, untradableOnEquip);
          return untradableOnEquip;
      }
  
      public boolean isKarmaAble(int itemId) {
          if (karmaCache.containsKey(itemId)) {
              return karmaCache.get(itemId);
          }
          boolean bRestricted = MapleDataTool.getIntConvert("info/tradeAvailable", getItemData(itemId), 0) > 0;
          karmaCache.put(itemId, bRestricted);
          return bRestricted;
      }
  
      public int getStateChangeItem(int itemId) {
          if (triggerItemCache.containsKey(itemId)) {
              return triggerItemCache.get(itemId);
          } else {
              int triggerItem = MapleDataTool.getIntConvert("info/stateChangeItem", getItemData(itemId), 0);
              triggerItemCache.put(itemId, triggerItem);
              return triggerItem;
          }
      }
  
      public int getExpById(int itemId) {
          if (expCache.containsKey(itemId)) {
              return expCache.get(itemId);
          } else {
              int exp = MapleDataTool.getIntConvert("spec/exp", getItemData(itemId), 0);
              expCache.put(itemId, exp);
              return exp;
          }
      }
  
      public int getMaxLevelById(int itemId) {
          if (levelCache.containsKey(itemId)) {
              return levelCache.get(itemId);
          } else {
              int level = MapleDataTool.getIntConvert("info/maxLevel", getItemData(itemId), 256);
              levelCache.put(itemId, level);
              return level;
          }
      }
  
      public boolean isConsumeOnPickup(int itemId) {
          if (consumeOnPickupCache.containsKey(itemId)) {
              return consumeOnPickupCache.get(itemId);
          }
          MapleData data = getItemData(itemId);
          boolean consume = MapleDataTool.getIntConvert("spec/consumeOnPickup", data, 0) == 1 || MapleDataTool.getIntConvert("specEx/consumeOnPickup", data, 0) == 1;
          consumeOnPickupCache.put(itemId, consume);
          return consume;
      }
  
      public boolean isCash(int itemId) {
          return itemId / 1000000 == 5 || getEquipStats(itemId).get("cash") == 1;
      }
      
      public ArrayList<Pair<Integer, String>> getItemDataByName(String name)
      {
          ArrayList<Pair<Integer, String>> ret = new ArrayList<>();
           for (Pair<Integer, String> itemPair : MapleItemInformationProvider.getInstance().getAllItems()) {
                      if (itemPair.getRight().toLowerCase().contains(name.toLowerCase())) {
                              ret.add(itemPair);
                          }
                      }
           return ret;
      }
  }
  