dankgrinder 4.8.1 → 4.9.0

package/lib/commands/inventory.js

@@ -0,0 +1,344 @@
+/**
+ * Inventory command handler.
+ * Sends "pls inv", pages through all pages, parses items.
+ * Stores parsed inventory in Redis (no expiry) with gwapes.com net values.
+ * Supports incremental updates: add/remove/change qty.
+ */
+
+const https = require('https');
+const {
+  LOG, c, sleep, humanDelay, getFullText, getAllButtons,
+  safeClickButton, logMsg, isHoldTight, getHoldTightReason,
+  isCV2, ensureCV2,
+} = require('./utils');
+
+let _itemValuesCache = null;
+let _itemValuesFetchedAt = 0;
+const ITEM_CACHE_TTL = 3600_000; // 1 hour
+
+/**
+ * Fetch all item values from gwapes.com API.
+ * Caches in-memory for 1 hour.
+ */
+async function fetchItemValues() {
+  if (_itemValuesCache && Date.now() - _itemValuesFetchedAt < ITEM_CACHE_TTL) {
+    return _itemValuesCache;
+  }
+
+  return new Promise((resolve) => {
+    https.get('https://api.gwapes.com/items', (res) => {
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.success && Array.isArray(parsed.body)) {
+            const map = {};
+            for (const item of parsed.body) {
+              map[item.name.toLowerCase()] = {
+                name: item.name,
+                value: item.value || 0,
+                net_value: item.net_value || 0,
+                type: item.type || 'Unknown',
+              };
+            }
+            _itemValuesCache = map;
+            _itemValuesFetchedAt = Date.now();
+            LOG.info(`[inv] Fetched ${Object.keys(map).length} item values from gwapes.com`);
+            resolve(map);
+          } else {
+            resolve(_itemValuesCache || {});
+          }
+        } catch (e) {
+          LOG.error(`[inv] gwapes API parse error: ${e.message}`);
+          resolve(_itemValuesCache || {});
+        }
+      });
+    }).on('error', (e) => {
+      LOG.error(`[inv] gwapes API error: ${e.message}`);
+      resolve(_itemValuesCache || {});
+    });
+  });
+}
+
+/** Strip Discord emoji tags like <:Name:ID> or <a:Name:ID> */
+function stripEmojis(str) {
+  return str.replace(/<a?:[a-zA-Z0-9_]+:\d+>/g, '').trim();
+}
+
+/**
+ * Parse inventory items from a message.
+ * CV2 format: **<:EmojiName:ID> Item Name** ─ qty
+ * Legacy format: <emoji> **Item Name** ⎯ qty
+ */
+function parseInventoryPage(msg) {
+  const items = [];
+  const text = getFullText(msg);
+  if (!text) return items;
+
+  const lines = text.split('\n');
+  for (const line of lines) {
+    let m;
+
+    // Primary: bold name with dash separator — handles emoji inside bold
+    // e.g. **<:AdventureTicket:123> Adventure Ticket** ─ 10
+    m = line.match(/\*{2}(.+?)\*{2}\s*[⎯—─\-]+\s*`?(\d[\d,]*)`?/);
+    if (m) {
+      const name = stripEmojis(m[1]).trim();
+      const qty = parseInt(m[2].replace(/,/g, ''), 10);
+      if (name && qty > 0 && name.length > 1 && name.length < 60) {
+        items.push({ name, qty });
+        continue;
+      }
+    }
+
+    // Fallback: non-bold with dash separator
+    m = line.match(/([A-Za-z][A-Za-z0-9 ''.\-]+?)\s*[⎯—─\-]+\s*`?(\d[\d,]*)`?/);
+    if (m) {
+      const name = stripEmojis(m[1]).replace(/^\*+|\*+$/g, '').trim();
+      const qty = parseInt(m[2].replace(/,/g, ''), 10);
+      if (name && qty > 0 && name.length > 2 && name.length < 60 && !/^(page|showing)/i.test(name)) {
+        items.push({ name, qty });
+        continue;
+      }
+    }
+
+    // x-quantity format: Item Name x3
+    m = line.match(/\*{0,2}([A-Za-z][A-Za-z0-9 ''.\-]+?)\*{0,2}\s+x\s*(\d[\d,]*)/);
+    if (m) {
+      const name = stripEmojis(m[1]).trim();
+      const qty = parseInt(m[2].replace(/,/g, ''), 10);
+      if (name && qty > 0 && name.length > 1 && name.length < 60) {
+        items.push({ name, qty });
+      }
+    }
+  }
+
+  return items;
+}
+
+/**
+ * Get current page / total pages from footer or text.
+ */
+function parsePageInfo(msg) {
+  // Check embed footer first
+  for (const embed of msg.embeds || []) {
+    if (embed.footer?.text) {
+      const fm = embed.footer.text.match(/page\s*(\d+)\s*(?:\/|of)\s*(\d+)/i);
+      if (fm) return { page: parseInt(fm[1]), total: parseInt(fm[2]) };
+    }
+  }
+  const text = getFullText(msg);
+  const m = text.match(/page\s*(\d+)\s*(?:\/|of)\s*(\d+)/i);
+  if (m) return { page: parseInt(m[1]), total: parseInt(m[2]) };
+  return { page: 1, total: 1 };
+}
+
+/**
+ * Enrich items array with gwapes values.
+ */
+async function enrichItems(items) {
+  const values = await fetchItemValues();
+  let totalValue = 0;
+  let totalMarket = 0;
+  for (const item of items) {
+    const info = values[item.name.toLowerCase()];
+    if (info) {
+      item.net_value = info.net_value;
+      item.market_value = info.value;
+      item.type = info.type;
+      item.total_net = info.net_value * item.qty;
+      item.total_market = info.value * item.qty;
+      totalValue += item.total_net;
+      totalMarket += item.total_market;
+    } else {
+      item.net_value = 0;
+      item.market_value = 0;
+      item.type = 'Unknown';
+      item.total_net = 0;
+      item.total_market = 0;
+    }
+  }
+  return { totalValue, totalMarket };
+}
+
+/**
+ * Check inventory for all pages and return full item list.
+ */
+async function runInventory({ channel, waitForDankMemer, client, accountId, redis }) {
+  LOG.cmd(`${c.white}${c.bold}pls inv${c.reset}`);
+
+  await channel.send('pls inv');
+  let response = await waitForDankMemer(10000);
+
+  if (!response) {
+    LOG.warn('[inv] No response');
+    return { result: 'no response', items: [] };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[inv] Hold Tight${reason ? ` (reason: ${reason})` : ''}`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, items: [], holdTightReason: reason };
+  }
+
+  if (isCV2(response)) await ensureCV2(response);
+  logMsg(response, 'inv');
+
+  const allItems = [];
+  let { page, total } = parsePageInfo(response);
+  LOG.info(`[inv] Page ${page}/${total}`);
+
+  allItems.push(...parseInventoryPage(response));
+
+  while (page < total) {
+    const buttons = getAllButtons(response);
+    const nextBtn = buttons.find(b => {
+      if (b.disabled) return false;
+      const id = (b.customId || '').toLowerCase();
+      const label = (b.label || '').toLowerCase();
+      const emoji = (b.emoji?.name || '').toLowerCase();
+      return id.includes('next') || id.includes('right') || label.includes('next')
+        || label === '▶' || label === '→' || emoji.includes('right') || emoji === '▶';
+    });
+
+    if (!nextBtn) {
+      LOG.debug(`[inv] No next button on page ${page}`);
+      break;
+    }
+
+    await humanDelay(300, 600);
+    try {
+      const result = await safeClickButton(response, nextBtn);
+      if (result) {
+        response = result;
+      } else {
+        // CV2 button click returns null — wait for Discord to update the message
+        await sleep(2000);
+      }
+    } catch (e) {
+      LOG.error(`[inv] Next page click failed: ${e.message}`);
+      break;
+    }
+
+    // Clear cached CV2 data so ensureCV2 re-fetches the updated message
+    delete response._cv2;
+    delete response._cv2text;
+    delete response._cv2buttons;
+    await sleep(500);
+    if (isCV2(response)) await ensureCV2(response);
+    const pageInfo = parsePageInfo(response);
+    if (pageInfo.page <= page) break;
+    page = pageInfo.page;
+    total = pageInfo.total;
+
+    LOG.info(`[inv] Page ${page}/${total}`);
+    allItems.push(...parseInventoryPage(response));
+  }
+
+  // Deduplicate
+  const itemMap = {};
+  for (const item of allItems) {
+    const key = item.name.toLowerCase();
+    if (itemMap[key]) {
+      itemMap[key].qty = Math.max(itemMap[key].qty, item.qty);
+    } else {
+      itemMap[key] = { ...item };
+    }
+  }
+
+  const items = Object.values(itemMap);
+  LOG.success(`[inv] Found ${items.length} unique items across ${total} pages`);
+
+  const { totalValue, totalMarket } = await enrichItems(items);
+  LOG.info(`[inv] Net value: ${c.bold}${c.green}⏣ ${totalValue.toLocaleString()}${c.reset}  Market: ${c.bold}⏣ ${totalMarket.toLocaleString()}${c.reset}`);
+
+  // Store in Redis — NO EXPIRY (permanent until next update)
+  if (redis && accountId) {
+    try {
+      const payload = {
+        items,
+        totalValue,
+        totalMarket,
+        itemCount: items.length,
+        updatedAt: Date.now(),
+      };
+      await redis.set(`dkg:inv:${accountId}`, JSON.stringify(payload));
+      LOG.success(`[inv] Stored in Redis (${items.length} items)`);
+    } catch (e) {
+      LOG.error(`[inv] Redis store failed: ${e.message}`);
+    }
+  }
+
+  return {
+    result: `inv: ${items.length} items, ⏣ ${totalValue.toLocaleString()} net`,
+    items,
+    totalValue,
+    totalMarket,
+    coins: 0,
+  };
+}
+
+// ── Incremental inventory updates ───────────────────────────
+
+async function updateInventoryItem(redis, accountId, itemName, newQty) {
+  if (!redis || !accountId) return null;
+  try {
+    const raw = await redis.get(`dkg:inv:${accountId}`);
+    if (!raw) return null;
+    const inv = JSON.parse(raw);
+    const key = itemName.toLowerCase();
+    const idx = inv.items.findIndex(i => i.name.toLowerCase() === key);
+
+    if (newQty <= 0) {
+      // Delete item
+      if (idx >= 0) inv.items.splice(idx, 1);
+    } else if (idx >= 0) {
+      inv.items[idx].qty = newQty;
+      if (inv.items[idx].net_value) {
+        inv.items[idx].total_net = inv.items[idx].net_value * newQty;
+        inv.items[idx].total_market = (inv.items[idx].market_value || 0) * newQty;
+      }
+    } else {
+      inv.items.push({ name: itemName, qty: newQty, net_value: 0, market_value: 0, type: 'Unknown', total_net: 0, total_market: 0 });
+    }
+
+    // Recalculate totals
+    inv.totalValue = inv.items.reduce((s, i) => s + (i.total_net || 0), 0);
+    inv.totalMarket = inv.items.reduce((s, i) => s + (i.total_market || 0), 0);
+    inv.itemCount = inv.items.length;
+    inv.updatedAt = Date.now();
+
+    await redis.set(`dkg:inv:${accountId}`, JSON.stringify(inv));
+    return inv;
+  } catch { return null; }
+}
+
+async function deleteInventoryItem(redis, accountId, itemName) {
+  return updateInventoryItem(redis, accountId, itemName, 0);
+}
+
+async function getCachedInventory(redis, accountId) {
+  if (!redis || !accountId) return null;
+  try {
+    const data = await redis.get(`dkg:inv:${accountId}`);
+    return data ? JSON.parse(data) : null;
+  } catch { return null; }
+}
+
+async function getAllInventories(redis, accountIds) {
+  if (!redis) return {};
+  const result = {};
+  for (const id of accountIds) {
+    const inv = await getCachedInventory(redis, id);
+    if (inv) result[id] = inv;
+  }
+  return result;
+}
+
+module.exports = {
+  runInventory, fetchItemValues, enrichItems,
+  getCachedInventory, getAllInventories,
+  updateInventoryItem, deleteInventoryItem,
+};