'use strict';

const Vec3 = require('vec3');
const conf = require('../../conf');
const { sleep } = require('../../utils');
const Database = require('./database');
const Scanner = require('./scanner');
const ShulkerHandler = require('./shulker-handler');
const StorageWeb = require('./web');

class Storage {
	static createRouter = StorageWeb.createRouter;
	static webUI = StorageWeb.webUI;

	constructor(args) {
		console.log('Storage: Constructor called');
		this.bot = args.bot;
		this.config = { ...conf.storage, ...args };
		this.isReady = false;
		this.shulkerHandler = new ShulkerHandler();
		this.pendingWithdrawals = new Map(); // playerName → { itemName, count, mode, timeoutId }
		this._craftAvailable = true; // reset when crafting fails, so we don't spam retries
		this._busy = false; // true during organize/withdraw/trade to block interval restock
	}

	init() {
		console.log('Storage: init() called');
		return new Promise((resolve, reject) => {
			this.bot.on('onReady', async () => {
				try {
					console.log(`Storage: Bot ${this.bot.name} is ready, initializing storage system...`);

					// Initialize database
					if (!Database.db) {
						console.log('Storage: Initializing database...');
						await Database.initialize(this.config.dbPath || './storage/storage.db');
					} else {
						console.log('Storage: Database already initialized');
					}

					// Initialize scanner
					console.log('Storage: Creating Scanner...');
					this.scanner = new Scanner();
					this.shulkerHandler.scanner = this.scanner;

					if (this.config.startupTasks) {
						console.log('Storage: Running startup tasks...');
						await this.config.startupTasks();
					}

					this.isReady = true;
					console.log('Storage: Initialization complete! Ready to use.');

					if (!this.bot.onDemand) {
						// Initial hotbar restock
						try {
							await this.restockHotbar();
						} catch (error) {
							console.error('Storage: Initial hotbar restock failed:', error.message);
						}

						// Start hotbar restock interval
						const restockInterval = this.config.hotbarRestockInterval || 60000;
						this.hotbarInterval = setInterval(async () => {
							try {
								await this.restockHotbar();
							} catch (error) {
								console.error('Storage: Hotbar restock interval failed:', error.message);
							}
						}, restockInterval);

						// Start periodic inventory cleanup
						const cleanupInterval = this.config.inventoryCleanupInterval || 5 * 60 * 1000;
						this.cleanupInterval = setInterval(async () => {
							if (!this.isReady || this._busy || this.shulkerHandler.operationInProgress) return;
							try {
								await this.cleanInventory();
							} catch (error) {
								console.error('Storage: Periodic inventory cleanup failed:', error.message);
							}
						}, cleanupInterval);
					}

					resolve();

				} catch (error) {
					console.error('Storage: Error in init:', error);
					reject(error);
				}
			});
		});
	}

	async unload(keepDb = false) {
		console.log('Storage: Unloading...');

		if (this.hotbarInterval) {
			clearInterval(this.hotbarInterval);
			this.hotbarInterval = null;
		}

		if (this.cleanupInterval) {
			clearInterval(this.cleanupInterval);
			this.cleanupInterval = null;
		}

		// Clear any pending withdrawal timeouts
		for (const [, pending] of this.pendingWithdrawals) {
			if (pending.timeoutId) clearTimeout(pending.timeoutId);
		}
		this.pendingWithdrawals.clear();

		if (this.scanner) delete this.scanner;

		if (!keepDb && Database.db) {
			console.log('Storage: Closing database...');
			Database.close();
		}

		this.isReady = false;
		console.log('Storage: Unload complete');
	}

	async scanArea(force = false) {
		console.log(`Storage[${this.bot.name}]: Scanning storage area...`);
		const chests = await this.scanner.discoverChests(this.bot, this.config.scanRadius || 30, Database);
		const shulkers = await this.scanner.scanAllChests(this.bot, Database);
		console.log(`Storage[${this.bot.name}]: Complete - ${chests.length} chests, ${shulkers} shulkers`);
	}

	// ========================================
	// Hotbar Management
	// ========================================

	async restockHotbar() {
		if (!this.isReady) return;
		if (this._busy) {
			console.log('Storage: Skipping hotbar restock — storage operation in progress');
			return;
		}
		if (this.shulkerHandler.operationInProgress) {
			console.log('Storage: Skipping hotbar restock — shulker operation in progress');
			return;
		}

		const hotbarItems = this.config.hotbarItems || [];
		if (hotbarItems.length === 0) return;

		for (const spec of hotbarItems) {
			// Count current inventory
			let currentCount = 0;
			for (const item of this.bot.bot.inventory.items()) {
				if (item.name === spec.name) {
					currentCount += item.count;
				}
			}

			if (currentCount >= spec.min) continue;

			const needed = spec.target - currentCount;
			console.log(`Storage: Hotbar restock — ${spec.name}: have ${currentCount}, need ${needed} more (target ${spec.target})`);

			// Check storage availability
			const available = await Database.getItemTotalCount(spec.name);
			if (available === 0) {
				console.log(`Storage: No ${spec.name} in storage, skipping`);
				continue;
			}

			const toWithdraw = Math.min(needed, available);
			const shulkers = await Database.findShulkersWithItem(spec.name);

			let remaining = toWithdraw;
			let consecutiveFailures = 0;
			for (const shulker of shulkers) {
				if (remaining <= 0) break;
				if (consecutiveFailures >= 2) {
					console.log(`Storage: Too many failures restocking ${spec.name}, giving up`);
					break;
				}

				const chestPos = new Vec3(shulker.pos_x, shulker.pos_y, shulker.pos_z);
				try {
					const { withdrawn, updatedSlotItem } = await this.shulkerHandler.withdrawFromShulker(
						this.bot, chestPos, shulker.slot, spec.name, remaining, shulker.id, shulker.chest_id
					);

					if (withdrawn > 0) {
						remaining -= withdrawn;
						consecutiveFailures = 0;
					} else {
						consecutiveFailures++;
					}
				} catch (error) {
					console.error(`Storage: Hotbar restock error for ${spec.name}:`, error.message);
					consecutiveFailures++;
				}
			}

			console.log(`Storage: Restocked ${toWithdraw - remaining}x ${spec.name}`);
		}

		await Database.rebuildItemIndex();
	}

	// ========================================
	// Deposit Flow
	// ========================================

	async handleTrade(playerName, itemsReceived) {
		console.log(`Storage[${this.bot.name}]: Processing trade from ${playerName}, received ${itemsReceived.length} item types`);
		this._craftAvailable = true; // new items may include craft materials
		this._busy = true;

		try {
			// Log trade
			await Database.logTrade(playerName, 'deposit', itemsReceived);

			// Unpack any traded shulker boxes before depositing
			const hasShulkers = itemsReceived.some(item => item.name.includes('shulker_box'));
			if (hasShulkers) {
				console.log('Storage: Traded items include shulker boxes, unpacking...');
				await this.unpackTradedShulkers();
			}

			// After unpacking, read current bot inventory for depositing
			// Skip hotbar items and shulker boxes (already stored by unpack)
			const hotbarNames = new Set((this.config.hotbarItems || []).map(h => h.name));
			const grouped = {};
			for (const item of this.bot.bot.inventory.items()) {
				if (hotbarNames.has(item.name)) continue;
				if (item.name.includes('shulker_box')) continue;
				if (!grouped[item.name]) {
					grouped[item.name] = 0;
				}
				grouped[item.name] += item.count;
			}

			// Deposit each item type
			const results = [];
			for (const [itemName, totalCount] of Object.entries(grouped)) {
				try {
					const result = await this.depositItemType(itemName, totalCount);
					results.push({ itemName, requested: totalCount, deposited: result.deposited });
				} catch (error) {
					console.error(`Storage: Error depositing ${itemName}:`, error);
					results.push({ itemName, requested: totalCount, deposited: 0, error: error.message });
				}
			}

			// Rebuild index after all deposits
			await Database.rebuildItemIndex();

			// Whisper summary to player
			const summary = results.map(r => {
				if (r.error) return `${r.itemName}: FAILED (${r.error})`;
				return `${r.itemName}: ${r.deposited}/${r.requested}`;
			}).join(', ');

			this.bot.whisper(playerName, `Storage complete: ${summary}`);
			return results;
		} finally {
			this._busy = false;
		}
	}

	/**
	 * Process all shulker boxes in bot inventory from a trade.
	 * Sorted shulkers (single item type) are stored directly — no unpack needed.
	 * Mixed shulkers are unpacked, items deposited, then empty box stored.
	 * Deposits between each shulker to keep inventory space free.
	 */
	async unpackTradedShulkers() {
		// Phase 1: Store ALL shulkers from inventory into chests.
		// This frees inventory space and registers contents in DB via NBT scan.
		// Sorted/empty shulkers are done after this. Mixed ones need phase 2.
		const mixedShulkers = []; // { chestId, chestSlot, chestPos, shulkerId }

		console.log('Storage: Phase 1 — stashing all traded shulkers into chests');
		let stashCount = 0;
		while (stashCount < 50) {
			const shulkerItem = this.bot.bot.inventory.items().find(item => item.name.includes('shulker_box'));
			if (!shulkerItem) break;
			stashCount++;

			const contents = this.scanner.extractShulkerContents(this.bot, shulkerItem);
			const itemTypes = new Set(contents.map(c => c.name));
			const isMixed = contents.length > 0 && itemTypes.size > 1;

			const label = isMixed
				? `mixed (${itemTypes.size} types)`
				: contents.length === 0 ? 'empty' : `sorted (${[...itemTypes][0]})`;
			console.log(`Storage: Stashing shulker ${stashCount}: ${label}`);

			try {
				const info = await this.storeShulker(shulkerItem);
				if (!info) {
					console.error('Storage: No empty chest slot, cannot stash more shulkers');
					break;
				}
				if (isMixed) {
					mixedShulkers.push(info);
				}
			} catch (error) {
				console.error(`Storage: Error stashing shulker:`, error.message);
				break;
			}
		}

		console.log(`Storage: Phase 1 complete — stashed ${stashCount} shulkers, ${mixedShulkers.length} need unpacking`);

		// Phase 2: Pull each mixed shulker back out, unpack it, deposit items, store empty box.
		// Bot inventory is now empty (aside from hotbar), so we have room.
		for (let i = 0; i < mixedShulkers.length; i++) {
			const info = mixedShulkers[i];
			console.log(`Storage: Phase 2 — unpacking mixed shulker ${i + 1}/${mixedShulkers.length} (DB #${info.shulkerId})`);

			try {
				// Take the shulker from the chest into inventory
				await this.shulkerHandler.takeWholeShulker(
					this.bot, info.chestPos, info.chestSlot, info.shulkerId
				);
				// Delete from DB since we're about to empty it
				await Database.deleteShulker(info.shulkerId);

				// Find the shulker in inventory and unpack it
				const shulkerItem = this.bot.bot.inventory.items().find(item => item.name.includes('shulker_box'));
				if (!shulkerItem) {
					console.error('Storage: Shulker not found in inventory after taking from chest');
					continue;
				}

				const { extracted, inventoryFull } = await this.shulkerHandler.unpackShulkerFromInventory(this.bot, shulkerItem);
				console.log(`Storage: Extracted ${extracted.length} item stacks from mixed shulker`);

				// Deposit all extracted items
				await this._depositNonShulkerInventory();

				// Store the empty shulker box back into a chest
				const emptyBox = this.bot.bot.inventory.items().find(item => item.name.includes('shulker_box'));
				if (emptyBox) {
					try {
						await this.storeShulker(emptyBox);
					} catch (e) {
						console.error(`Storage: Error storing empty box:`, e.message);
					}
				}
			} catch (error) {
				console.error(`Storage: Error unpacking mixed shulker #${info.shulkerId}:`, error.message);
				// Deposit whatever we managed to extract
				await this._depositNonShulkerInventory();
				// Try to store any shulker box left in inventory
				const leftover = this.bot.bot.inventory.items().find(item => item.name.includes('shulker_box'));
				if (leftover) {
					try { await this.storeShulker(leftover); } catch (e) { /* best effort */ }
				}
			}
		}

		// Final cleanup: store any shulker boxes still in inventory
		let remaining = this.bot.bot.inventory.items().filter(item => item.name.includes('shulker_box'));
		for (const leftover of remaining) {
			try { await this.storeShulker(leftover); } catch (e) {
				console.error(`Storage: Error storing leftover shulker:`, e.message);
			}
		}

		console.log('Storage: All traded shulkers processed');
	}

	/**
	 * Deposit all non-shulker, non-hotbar items from bot inventory.
	 * Used during trade unpack to free inventory space between shulkers.
	 */
	async _depositNonShulkerInventory() {
		const hotbarNames = new Set((this.config.hotbarItems || []).map(h => h.name));
		const todeposit = {};
		for (const item of this.bot.bot.inventory.items()) {
			if (item.name.includes('shulker_box')) continue;
			if (hotbarNames.has(item.name)) continue;
			if (!todeposit[item.name]) todeposit[item.name] = 0;
			todeposit[item.name] += item.count;
		}

		for (const [itemName, count] of Object.entries(todeposit)) {
			try {
				await this.depositItemType(itemName, count);
			} catch (error) {
				console.error(`Storage: Error depositing ${itemName} during unpack:`, error.message);
			}
		}
	}

	/**
	 * Store a shulker box from bot inventory into an empty chest slot.
	 * Scans NBT to register contents in DB.
	 * @returns {{ chestId, chestSlot, shulkerId, itemFocus }} or false on failure
	 */
	async storeShulker(shulkerItem) {
		console.log(`Storage: Storing shulker box (${shulkerItem.name})`);

		const emptySlot = await Database.findEmptyChestSlot();
		if (!emptySlot) {
			console.log('Storage: No empty chest slot for shulker');
			return false;
		}

		const chestPos = new Vec3(emptySlot.pos_x, emptySlot.pos_y, emptySlot.pos_z);
		await this.bot.goTo({ where: chestPos, range: 3 });
		const chestBlock = this.bot.bot.blockAt(chestPos);
		const window = await this.bot.openContainer(chestBlock);
		await sleep(300);

		// Find the specific shulker in inventory portion of the window by matching slot
		let shulkerWindowSlot = null;
		for (let i = window.inventoryStart; i < window.inventoryEnd; i++) {
			const item = window.slots[i];
			if (item && item.slot === shulkerItem.slot && item.name.includes('shulker_box')) {
				shulkerWindowSlot = i;
				break;
			}
		}
		// Fallback: find any shulker box if slot match failed
		if (shulkerWindowSlot === null) {
			for (let i = window.inventoryStart; i < window.inventoryEnd; i++) {
				const item = window.slots[i];
				if (item && item.name.includes('shulker_box')) {
					shulkerWindowSlot = i;
					break;
				}
			}
		}

		if (shulkerWindowSlot === null) {
			await this.bot.bot.closeWindow(window);
			console.log('Storage: Shulker not found in window inventory');
			return false;
		}

		await this.bot.bot.moveSlotItem(shulkerWindowSlot, emptySlot.slot);
		await sleep(300);

		// Read NBT from the placed slot and scan actual contents
		const placedItem = window.slots[emptySlot.slot];
		await this.bot.bot.closeWindow(window);
		await sleep(200);

		// Register in DB with actual contents via NBT scan
		let shulkerRecord = null;
		if (placedItem) {
			await this.scanner.scanShulkerFromNBT(this.bot, Database, emptySlot.chest_id, emptySlot.slot, placedItem);
			// Look up the record that was just created/updated
			const chestShulkers = await Database.getShulkersByChest(emptySlot.chest_id);
			shulkerRecord = chestShulkers.find(s => s.slot === emptySlot.slot);
		}

		const info = {
			chestId: emptySlot.chest_id,
			chestSlot: emptySlot.slot,
			chestPos,
			shulkerId: shulkerRecord ? shulkerRecord.id : null,
			itemFocus: shulkerRecord ? shulkerRecord.item_focus : null,
		};

		console.log(`Storage: Shulker stored at chest ${info.chestId}, slot ${info.chestSlot} (focus: ${info.itemFocus || 'mixed/empty'})`);
		return info;
	}

	/**
	 * Check whether a mineflayer inventory item has special NBT (custom name, lore, custom model data).
	 */
	_isItemSpecial(item) {
		if (!item.nbt) return false;
		const tag = item.nbt?.value?.tag?.value || item.nbt?.value || item.nbt;
		const parsed = this.scanner.parseNBT(tag);
		return Scanner.isSpecialItem(parsed);
	}

	async depositItemType(itemName, count, excludeShulkerId = null) {
		console.log(`Storage: Depositing ${count}x ${itemName}`);

		// Split inventory items into regular and special
		const allInvItems = this.bot.bot.inventory.items().filter(i => i.name === itemName);
		const regularCount = allInvItems.filter(i => !this._isItemSpecial(i)).reduce((s, i) => s + i.count, 0);
		const specialCount = allInvItems.filter(i => this._isItemSpecial(i)).reduce((s, i) => s + i.count, 0);

		let totalDeposited = 0;

		// Deposit regular items first (filter out special ones during shift-click)
		if (regularCount > 0) {
			const toDeposit = Math.min(regularCount, count);
			const result = await this._depositItemBatch(
				itemName, toDeposit, itemName,
				(item) => !this._isItemSpecial(item),
				excludeShulkerId
			);
			totalDeposited += result.deposited;
		}

		// Then deposit special items (filter out regular ones during shift-click)
		if (specialCount > 0 && totalDeposited < count) {
			const remaining = Math.min(specialCount, count - totalDeposited);
			console.log(`Storage: Depositing ${remaining}x ${itemName} (special) separately`);
			const result = await this._depositItemBatch(
				itemName, remaining, itemName + '#special',
				(item) => this._isItemSpecial(item),
				excludeShulkerId
			);
			totalDeposited += result.deposited;
		}

		console.log(`Storage: Deposited ${totalDeposited}/${count} ${itemName}`);
		return { deposited: totalDeposited };
	}

	/**
	 * Internal: deposit items of a given type into shulkers with a specific focus.
	 * @param {string} itemName - The minecraft item name to match
	 * @param {number} count - How many to deposit
	 * @param {string} focus - The shulker item_focus to target (e.g. 'diamond_sword' or 'diamond_sword#special')
	 * @param {Function|null} itemFilter - Filter passed to depositIntoShulker to control which slots get shift-clicked
	 * @param {number|null} excludeShulkerId - Shulker ID to skip
	 */
	async _depositItemBatch(itemName, count, focus, itemFilter, excludeShulkerId = null) {
		let remaining = count;
		let totalDeposited = 0;
		let failedAttempts = 0;

		while (remaining > 0) {
			if (failedAttempts >= 3) {
				console.log(`Storage: ${failedAttempts} consecutive deposit failures for ${itemName} (focus=${focus}), giving up`);
				break;
			}

			// Verify we actually still have matching items in inventory
			const actualInvItems = this.bot.bot.inventory.items().filter(i => i.name === itemName);
			const matchingCount = itemFilter
				? actualInvItems.filter(itemFilter).reduce((sum, i) => sum + i.count, 0)
				: actualInvItems.reduce((sum, i) => sum + i.count, 0);
			if (matchingCount === 0) {
				console.log(`Storage: No more matching ${itemName} in inventory, done`);
				break;
			}
			remaining = Math.min(remaining, matchingCount);

			// Try to find an existing shulker with this focus that has space
			let shulker = await Database.findShulkerWithSpace(focus, excludeShulkerId);
			let wasEmpty = false;
			console.log(`Storage: findShulkerWithSpace('${focus}') → ${shulker ? `shulker ${shulker.id} (slot_count=${shulker.slot_count}, focus=${shulker.item_focus})` : 'none'}`);

			if (!shulker) {
				// No matching shulker, find an empty one
				shulker = await Database.findEmptyShulker(excludeShulkerId);

				if (!shulker) {
					// No empty shulkers - try crafting one (skip if crafting already failed this cycle)
					if (this._craftAvailable) {
						console.log(`Storage: No empty shulkers, attempting to craft one`);
						try {
							await this.craftShulkerBox();
							shulker = await Database.findEmptyShulker();
						} catch (error) {
							console.error('Storage: Failed to craft shulker:', error.message);
							this._craftAvailable = false;
						}
					}

					if (!shulker) {
						console.log(`Storage: Cannot deposit ${remaining}x ${itemName} - no available shulkers`);
						break;
					}
				}

				// Set the item focus for this empty shulker
				await Database.updateShulkerItemFocus(shulker.id, focus);
				wasEmpty = true;
			}

			const chestPos = new Vec3(shulker.pos_x, shulker.pos_y, shulker.pos_z);

			try {
				const { deposited, updatedSlotItem } = await this.shulkerHandler.depositIntoShulker(
					this.bot, chestPos, shulker.slot, itemName, remaining, shulker.id, shulker.chest_id, itemFilter
				);

				totalDeposited += deposited;
				remaining -= deposited;

				if (deposited === 0) {
					failedAttempts++;
					console.log(`Storage: Shulker full or deposit failed (attempt ${failedAttempts}/3), trying next`);
					// Reset item_focus if we just assigned it — don't orphan empty shulkers
					if (wasEmpty) {
						await Database.updateShulkerItemFocus(shulker.id, null);
					}
					continue;
				}
				failedAttempts = 0;
			} catch (error) {
				console.error(`Storage: Error in deposit cycle:`, error);
				if (wasEmpty) {
					await Database.updateShulkerItemFocus(shulker.id, null);
				}
				break;
			}
		}

		return { deposited: totalDeposited };
	}

	// ========================================
	// Withdrawal Flow
	// ========================================

	async handleWithdrawRequest(playerName, itemName, count) {
		console.log(`Storage[${this.bot.name}]: Withdraw request from ${playerName}: ${itemName} x${count}`);
		this._busy = true;

		try {
			// Check total available
			const totalAvailable = await Database.getItemTotalCount(itemName);
			if (totalAvailable === 0) {
				return this.bot.whisper(playerName, `Item not found: ${itemName}`);
			}

			const actualCount = Math.min(count, totalAvailable);
			if (actualCount < count) {
				this.bot.whisper(playerName, `Only ${totalAvailable} ${itemName} available. Withdrawing ${actualCount}.`);
			}

			// Find shulkers containing this item
			const shulkers = await Database.findShulkersWithItem(itemName);
			if (!shulkers || shulkers.length === 0) {
				return this.bot.whisper(playerName, `Cannot find ${itemName} in any shulker`);
			}

			let remaining = actualCount;
			let totalWithdrawn = 0;
			let consecutiveFailures = 0;

			for (const shulker of shulkers) {
				if (remaining <= 0) break;
				if (consecutiveFailures >= 3) {
					console.log(`Storage: Too many withdraw failures for ${itemName}, stopping`);
					break;
				}

				const chestPos = new Vec3(shulker.pos_x, shulker.pos_y, shulker.pos_z);
				try {
					const { withdrawn, updatedSlotItem } = await this.shulkerHandler.withdrawFromShulker(
						this.bot, chestPos, shulker.slot, itemName, remaining, shulker.id, shulker.chest_id
					);

					if (withdrawn > 0) {
						totalWithdrawn += withdrawn;
						remaining -= withdrawn;
						consecutiveFailures = 0;
					} else {
						consecutiveFailures++;
					}
				} catch (error) {
					console.error(`Storage: Error withdrawing from shulker ${shulker.id}:`, error.message);
					consecutiveFailures++;
				}
			}

			// Rebuild index after withdrawals
			await Database.rebuildItemIndex();

			if (totalWithdrawn > 0) {
				// Set up timeout to re-store items if not collected
				const timeoutId = setTimeout(() => {
					this.restoreWithdrawal(playerName);
				}, 5 * 60 * 1000);

				// Store pending withdrawal for trade pickup
				this.pendingWithdrawals.set(playerName, {
					itemName,
					count: totalWithdrawn,
					mode: 'items',
					timeoutId,
				});

				// Log trade
				await Database.logTrade(playerName, 'withdraw', [{ name: itemName, count: totalWithdrawn }]);

				this.bot.whisper(playerName, `${totalWithdrawn}x ${itemName} ready. Use /trade to collect within 5 minutes.`);
			} else {
				this.bot.whisper(playerName, `Failed to withdraw ${itemName}.`);
			}
		} finally {
			this._busy = false;
		}
	}

	async handleWithdrawShulkers(playerName, itemName, shulkerCount) {
		console.log(`Storage[${this.bot.name}]: Shulker withdraw request from ${playerName}: ${shulkerCount} shulkers of ${itemName}`);
		this._busy = true;

		try {
			if (shulkerCount > 12) {
				this.bot.whisper(playerName, `Trade window only has 12 slots. Limiting to 12 shulkers.`);
				shulkerCount = 12;
			}

			// Find shulkers with this item that have items in them
			const shulkers = await Database.findShulkersWithItem(itemName);
			if (!shulkers || shulkers.length === 0) {
				return this.bot.whisper(playerName, `No shulkers containing ${itemName} found`);
			}

			const available = shulkers.length;
			const actualCount = Math.min(shulkerCount, available);
			if (actualCount < shulkerCount) {
				this.bot.whisper(playerName, `Only ${available} shulkers of ${itemName} available. Withdrawing ${actualCount}.`);
			}

			let taken = 0;
			for (let i = 0; i < actualCount; i++) {
				const shulker = shulkers[i];
				const chestPos = new Vec3(shulker.pos_x, shulker.pos_y, shulker.pos_z);

				try {
					await this.shulkerHandler.takeWholeShulker(this.bot, chestPos, shulker.slot, shulker.id);

					// Also fully delete from DB — it's leaving storage permanently
					await Database.deleteShulker(shulker.id);
					taken++;
				} catch (error) {
					console.error(`Storage: Error taking whole shulker ${shulker.id}:`, error.message);
				}
			}

			await Database.rebuildItemIndex();

			if (taken > 0) {
				// Set up timeout to re-store shulkers if not collected
				const timeoutId = setTimeout(() => {
					this.restoreWithdrawal(playerName);
				}, 5 * 60 * 1000);

				this.pendingWithdrawals.set(playerName, {
					itemName,
					count: taken,
					mode: 'shulkers',
					timeoutId,
				});

				await Database.logTrade(playerName, 'withdraw', [{ name: itemName, count: taken, mode: 'shulkers' }]);

				this.bot.whisper(playerName, `${taken} shulker(s) of ${itemName} ready. Use /trade to collect within 5 minutes.`);
			} else {
				this.bot.whisper(playerName, `Failed to withdraw shulkers of ${itemName}.`);
			}
		} finally {
			this._busy = false;
		}
	}

	async restoreWithdrawal(playerName) {
		const pending = this.pendingWithdrawals.get(playerName);
		if (!pending) return;

		console.log(`Storage: Withdrawal timeout for ${playerName} — restoring ${pending.count}x ${pending.itemName} (mode: ${pending.mode || 'items'})`);

		// Clear timeout ref
		if (pending.timeoutId) {
			clearTimeout(pending.timeoutId);
		}
		this.pendingWithdrawals.delete(playerName);

		try {
			if (pending.mode === 'shulkers') {
				// Re-store whole shulker boxes
				const shulkerItems = this.bot.bot.inventory.items().filter(item => item.name.includes('shulker_box'));
				for (const shulkerItem of shulkerItems) {
					await this.storeShulker(shulkerItem);
				}
			} else {
				// Re-deposit individual items
				const grouped = {};
				for (const item of this.bot.bot.inventory.items()) {
					if (item.name === pending.itemName) {
						if (!grouped[item.name]) grouped[item.name] = 0;
						grouped[item.name] += item.count;
					}
				}
				for (const [itemName, count] of Object.entries(grouped)) {
					await this.depositItemType(itemName, count);
				}
			}

			await Database.rebuildItemIndex();
			this.bot.whisper(playerName, `Withdrawal cancelled — ${pending.count}x ${pending.itemName} returned to storage.`);
		} catch (error) {
			console.error(`Storage: Error restoring withdrawal for ${playerName}:`, error.message);
			this.bot.whisper(playerName, `Withdrawal timed out but failed to re-store items. Please contact an admin.`);
		}
	}

	// ========================================
	// Crafting
	// ========================================

	async craftShulkerBox() {
		console.log('Storage: Attempting to craft shulker box');

		// Check bot inventory first for materials
		let shellsInInv = 0;
		let chestsInInv = 0;
		for (const item of this.bot.bot.inventory.items()) {
			if (item.name === 'shulker_shell') shellsInInv += item.count;
			if (item.name === 'chest') chestsInInv += item.count;
		}

		// Take enough shells for the recipe AND to restock to hotbar target (saves repeat trips)
		const shellHotbar = (this.config.hotbarItems || []).find(h => h.name === 'shulker_shell');
		const shellTarget = shellHotbar ? shellHotbar.target : 2;
		let shellsNeeded = Math.max(0, Math.max(2, shellTarget) - shellsInInv);
		let chestsNeeded = Math.max(0, 1 - chestsInInv);

		console.log(`Storage: Craft materials — inventory: ${shellsInInv} shells, ${chestsInInv} chests. Need from storage: ${shellsNeeded} shells (target ${shellTarget}), ${chestsNeeded} chests`);

		// Only check/withdraw from storage if inventory doesn't have enough
		if (shellsNeeded > 0) {
			const shellCount = await Database.getItemTotalCount('shulker_shell');
			const minForRecipe = Math.max(0, 2 - shellsInInv);
			if (shellCount < minForRecipe) {
				throw new Error(`Not enough shulker shells (have ${shellsInInv} inv + ${shellCount} storage, need 2)`);
			}
			// Take up to target, but at least enough for the recipe
			shellsNeeded = Math.min(shellsNeeded, shellCount);

			const shellShulkers = await Database.findShulkersWithItem('shulker_shell');
			// Sort by distance so the bot tries nearby chests first
			const botPos = this.bot.bot.entity.position;
			shellShulkers.sort((a, b) => {
				const da = botPos.distanceTo(new Vec3(a.pos_x, a.pos_y, a.pos_z));
				const db = botPos.distanceTo(new Vec3(b.pos_x, b.pos_y, b.pos_z));
				return da - db;
			});
			let shellsObtained = 0;
			for (const shulker of shellShulkers) {
				if (shellsObtained >= shellsNeeded) break;
				const chestPos = new Vec3(shulker.pos_x, shulker.pos_y, shulker.pos_z);
				const { withdrawn } = await this.shulkerHandler.withdrawFromShulker(
					this.bot, chestPos, shulker.slot, 'shulker_shell', shellsNeeded - shellsObtained,
					shulker.id, shulker.chest_id
				);
				shellsObtained += withdrawn;
			}

			if (shellsObtained < minForRecipe) {
				throw new Error(`Failed to gather shells: got ${shellsObtained}/${minForRecipe} from storage`);
			}
		}

		if (chestsNeeded > 0) {
			const chestCount = await Database.getItemTotalCount('chest');
			if (chestCount < chestsNeeded) {
				throw new Error(`Not enough chests (have ${chestsInInv} inv + ${chestCount} storage, need 1)`);
			}

			const chestShulkers = await Database.findShulkersWithItem('chest');
			chestShulkers.sort((a, b) => {
				const da = botPos.distanceTo(new Vec3(a.pos_x, a.pos_y, a.pos_z));
				const db = botPos.distanceTo(new Vec3(b.pos_x, b.pos_y, b.pos_z));
				return da - db;
			});
			let chestsObtained = 0;
			for (const shulker of chestShulkers) {
				if (chestsObtained >= chestsNeeded) break;
				const chestPos = new Vec3(shulker.pos_x, shulker.pos_y, shulker.pos_z);
				const { withdrawn } = await this.shulkerHandler.withdrawFromShulker(
					this.bot, chestPos, shulker.slot, 'chest', chestsNeeded - chestsObtained,
					shulker.id, shulker.chest_id
				);
				chestsObtained += withdrawn;
			}

			if (chestsObtained < chestsNeeded) {
				throw new Error(`Failed to gather chests: got ${chestsObtained}/${chestsNeeded} from storage`);
			}
		}

		// Find or navigate to crafting table
		const craftingTablePos = this.config.craftingTablePos;
		let craftingTable;

		if (craftingTablePos) {
			craftingTable = this.bot.bot.blockAt(new Vec3(craftingTablePos.x, craftingTablePos.y, craftingTablePos.z));
		} else {
			craftingTable = this.bot.bot.findBlock({
				matching: this.bot.mcData.blocksByName.crafting_table?.id,
				maxDistance: 32,
			});
		}

		if (!craftingTable) {
			throw new Error('No crafting table found nearby');
		}

		await this.bot.goTo({ where: craftingTable.position, range: 3 });

		// Craft shulker box manually (bot.craft() broken on 1.21+)
		const shulkerBoxRecipes = this.bot.bot.recipesAll(
			this.bot.mcData.itemsByName.shulker_box.id,
			null,
			craftingTable
		);

		if (!shulkerBoxRecipes || shulkerBoxRecipes.length === 0) {
			throw new Error('No recipe found for shulker box');
		}

		const recipe = shulkerBoxRecipes[0];
		const window = await this.bot.openCraftingTable(craftingTable);
		const inventory = window.slots.slice(window.inventoryStart, window.inventoryEnd);

		// Group grid slots by ingredient type (handles single stack needing multiple grid slots)
		const ingredientsByType = {};
		for (let row = 0; row < recipe.inShape.length; row++) {
			for (let col = 0; col < recipe.inShape[row].length; col++) {
				const shape = recipe.inShape[row][col];
				if (shape.id === -1) continue;
				const gridSlot = row * 3 + col + 1;
				if (!ingredientsByType[shape.id]) ingredientsByType[shape.id] = [];
				ingredientsByType[shape.id].push(gridSlot);
			}
		}

		// For each ingredient type: pick up stack, right-click into each grid slot, put stack back
		for (const [typeId, gridSlots] of Object.entries(ingredientsByType)) {
			const invIdx = inventory.findIndex(el => el && el.type === parseInt(typeId));
			if (invIdx === -1) {
				await window.close();
				throw new Error(`Missing ingredient type ${typeId} in inventory`);
			}
			const actualSlot = window.inventoryStart + invIdx;

			// Left-click to pick up the stack
			await this.bot.bot.clickWindow(actualSlot, 0, 0);
			await sleep(100);

			// Right-click on each grid slot to place one item
			for (const gridSlot of gridSlots) {
				await this.bot.bot.clickWindow(gridSlot, 1, 0);
				await sleep(100);
			}

			// Left-click to put remaining stack back
			await this.bot.bot.clickWindow(actualSlot, 0, 0);
			await sleep(100);
		}

		await sleep(500);

		// Take crafted shulker box from result slot
		if (window.slots[0]) {
			let outputSlot = null;
			for (let j = window.inventoryStart; j < window.inventoryEnd; j++) {
				if (!window.slots[j]) { outputSlot = j; break; }
			}
			if (outputSlot === null) outputSlot = window.inventoryStart;
			await this.bot.bot.clickWindow(0, 0, 0);
			await sleep(100);
			await this.bot.bot.clickWindow(outputSlot, 0, 0);
			await sleep(100);
		}

		await window.close();
		await sleep(500);

		// Find an empty chest slot to store the new shulker
		const emptySlot = await Database.findEmptyChestSlot();
		if (emptySlot) {
			const chestPos = new Vec3(emptySlot.pos_x, emptySlot.pos_y, emptySlot.pos_z);
			await this.bot.goTo({ where: chestPos, range: 3 });
			const chestBlock = this.bot.bot.blockAt(chestPos);
			const storeWindow = await this.bot.openContainer(chestBlock);
			await sleep(300);

			// Find shulker in inventory portion of the window
			let shulkerWindowSlot = null;
			for (let i = storeWindow.inventoryStart; i < storeWindow.inventoryEnd; i++) {
				const item = storeWindow.slots[i];
				if (item && item.name.includes('shulker_box')) {
					shulkerWindowSlot = i;
					break;
				}
			}

			if (shulkerWindowSlot !== null) {
				await this.bot.bot.moveSlotItem(shulkerWindowSlot, emptySlot.slot);
				await sleep(300);
			}

			await this.bot.bot.closeWindow(storeWindow);
			await sleep(200);

			// Register in DB as empty shulker
			await Database.upsertShulker(emptySlot.chest_id, emptySlot.slot, 'shulker_box', null, null);
			const craftedShulkers = await Database.getShulkersByChest(emptySlot.chest_id);
			const newShulker = craftedShulkers.find(s => s.slot === emptySlot.slot);
			if (newShulker) {
				await Database.updateShulkerCounts(newShulker.id, 0, 0);
			}
		}

		this._craftAvailable = true; // crafting succeeded, reset flag
		console.log('Storage: Successfully crafted shulker box');
	}

	// ========================================
	// Inventory Cleanup
	// ========================================

	/**
	 * Deposit any non-shulker, non-hotbar items from bot inventory into storage.
	 * Called periodically and as pre/post-flight during organize.
	 */
	async cleanInventory() {
		const hotbarNames = new Set((this.config.hotbarItems || []).map(h => h.name));
		const grouped = {};
		for (const item of this.bot.bot.inventory.items()) {
			if (item.name.includes('shulker_box')) continue;
			if (hotbarNames.has(item.name)) continue;
			if (!grouped[item.name]) grouped[item.name] = 0;
			grouped[item.name] += item.count;
		}

		const itemTypes = Object.entries(grouped);
		if (itemTypes.length === 0) return 0;

		let cleaned = 0;
		for (const [itemName, count] of itemTypes) {
			try {
				console.log(`Storage: Cleaning inventory — depositing ${count}x ${itemName}`);
				await this.depositItemType(itemName, count);
				cleaned++;
			} catch (error) {
				console.log(`Storage: Inventory cleanup failed for ${itemName}: ${error.message}`);
			}
		}

		if (cleaned > 0) {
			await Database.rebuildItemIndex();
			console.log(`Storage: Inventory cleanup deposited ${cleaned} item type(s)`);
		}

		return cleaned;
	}

	// ========================================
	// Organize
	// ========================================

	async organizeLooseItems() {
		console.log('Storage: Organizing loose items into shulkers...');
		this._craftAvailable = true; // fresh organize, allow craft retry
		this._busy = true;
		let organized = 0;

		try {
			// Pre-flight: deposit any stray items in bot inventory
			await this.cleanInventory();

			const chests = await Database.getChestsWithLooseItems();
			console.log(`Storage: ${chests.length} chest(s) have loose items in DB`);

			for (const chest of chests) {
				// Check inventory has room before processing next chest (need 3+ free: items + shulker + buffer)
				const freeSlots = this.bot.bot.inventory.slots.filter((s, i) => !s && i >= 9).length;
				if (freeSlots < 3) {
					console.log(`Storage: Inventory too full (${freeSlots} free slots), stopping organize loop`);
					break;
				}

				const chestPos = new Vec3(chest.pos_x, chest.pos_y, chest.pos_z);

				try {
					// Process one item type at a time from this chest
					const failedItems = new Set();
					while (true) {
						await this.bot.goTo({ where: chestPos, range: 3 });
						const chestBlock = this.bot.bot.blockAt(chestPos);
						const window = await this.bot.openContainer(chestBlock);
						await sleep(300);

						// Find the first non-shulker item in the chest (skip already-failed types)
						const chestSlotCount = window.inventoryStart;
						let firstLooseSlot = null;
						for (let i = 0; i < chestSlotCount; i++) {
							const slot = window.slots[i];
							if (slot && !slot.name.includes('shulker_box') && !failedItems.has(slot.name)) {
								firstLooseSlot = i;
								break;
							}
						}

						if (firstLooseSlot === null) {
							// No loose items left in this chest
							await Database.clearLooseItems(chest.id);
							await this.bot.bot.closeWindow(window);
							break;
						}

						const itemName = window.slots[firstLooseSlot].name;
						console.log(`Storage: Picking up ${itemName} from chest at ${chestPos}`);

						// Count empty inventory slots
						let emptyInvSlots = 0;
						for (let i = window.inventoryStart; i < window.inventoryEnd; i++) {
							if (!window.slots[i]) emptyInvSlots++;
						}

						// Pick up all stacks of THIS item type only
						const pickedUpSlots = [];
						let totalCount = 0;

						for (let i = 0; i < chestSlotCount; i++) {
							const srcItem = window.slots[i];
							if (!srcItem || srcItem.name !== itemName) continue;

							// Find stackable slot first (doesn't consume an empty slot)
							let targetSlot = null;
							for (let j = window.inventoryStart; j < window.inventoryEnd; j++) {
								const invItem = window.slots[j];
								if (invItem && invItem.name === itemName && invItem.count < invItem.stackSize) {
									targetSlot = j;
									break;
								}
							}

							// Then find empty slot, but keep at least 1 free for shulker
							if (targetSlot === null) {
								if (emptyInvSlots <= 1) {
									console.log('Storage: Reserving last inventory slot for shulker operations');
									break;
								}
								for (let j = window.inventoryStart; j < window.inventoryEnd; j++) {
									if (!window.slots[j]) {
										targetSlot = j;
										break;
									}
								}
								emptyInvSlots--;
							}

							if (targetSlot === null) {
								console.log('Storage: Bot inventory full');
								break;
							}

							try {
								await this.bot.bot.moveSlotItem(i, targetSlot);
								await sleep(200);
								// Measure actual items removed from chest slot (handles partial stacking)
								const afterItem = window.slots[i];
								const moved = srcItem.count - (afterItem ? afterItem.count : 0);
								pickedUpSlots.push(i);
								totalCount += moved;
							} catch (error) {
								console.log(`Storage: Could not pick up slot ${i}: ${error.message}`);
							}
						}

						await this.bot.bot.closeWindow(window);

						// Sync DB: remove picked-up items individually
						for (const slot of pickedUpSlots) {
							await Database.deleteLooseItem(chest.id, slot);
						}

						if (totalCount === 0) {
							console.log(`Storage: Could not pick up any ${itemName}, skipping chest`);
							break;
						}

						// Deposit into shulker(s)
						try {
							const result = await this.depositItemType(itemName, totalCount);
							organized++;

							// If deposit was partial, return remaining items to the chest
							if (result.deposited < totalCount) {
								console.log(`Storage: Partial deposit for ${itemName} (${result.deposited}/${totalCount}), returning remainder to chest`);
								await this._returnItemsToChest(chestPos, itemName);
							}
						} catch (error) {
							console.log(`Storage: Could not deposit ${itemName}: ${error.message}`);
							failedItems.add(itemName);
							// Try to return items to the chest instead of leaving them in inventory
							try {
								await this._returnItemsToChest(chestPos, itemName);
							} catch (returnError) {
								console.log(`Storage: Could not return ${itemName} to chest: ${returnError.message}`);
								break; // Can't recover, stop this chest
							}
						}

						// Check if inventory is nearly full before processing next item type
						const innerFreeSlots = this.bot.bot.inventory.slots.filter((s, i) => !s && i >= 9).length;
						if (innerFreeSlots < 3) {
							console.log(`Storage: Inventory nearly full (${innerFreeSlots} free), stopping this chest`);
							break;
						}

						await sleep(250);
						// Loop back to re-open chest for next item type
					}

				} catch (error) {
					console.log(`Storage: Error organizing chest at ${chestPos}: ${error.message}`);
				}

				// Check if inventory is too full to continue organizing other chests
				const outerFreeSlots = this.bot.bot.inventory.slots.filter((s, i) => !s && i >= 9).length;
				if (outerFreeSlots < 3) {
					console.log(`Storage: Inventory too full (${outerFreeSlots} free slots), stopping organize`);
					break;
				}

				await sleep(250);
			}

			// Consolidate partially filled shulkers of the same item type
			try {
				await this.consolidateShulkers();
			} catch (error) {
				console.error('Storage: Consolidation error:', error.message);
			}

			// Post-flight: deposit any items still in inventory (may succeed now that organize freed shulker space)
			await this.cleanInventory();

			await Database.rebuildItemIndex();
			console.log(`Storage: Organized ${organized} item types into shulkers`);
			return organized;
		} finally {
			this._busy = false;
		}
	}


	/**
	 * Consolidate partially filled shulkers of the same item type.
	 * Withdraws from least-full shulker and deposits into the most-full one.
	 */
	async consolidateShulkers() {
		console.log('Storage: Consolidating partially filled shulkers...');
		let consolidated = 0;

		const candidates = await Database.findConsolidatableItems();
		console.log(`Storage: ${candidates.length} item type(s) have multiple non-full shulkers`);

		for (const candidate of candidates) {
			const itemName = candidate.item_focus;

			// Re-fetch shulkers each iteration (DB may have changed from previous consolidation)
			const shulkers = await Database.getShulkersByItemFocus(itemName);
			// Need at least 2 non-full shulkers to consolidate
			const nonFull = shulkers.filter(s => s.slot_count < 27);
			if (nonFull.length < 2) continue;

			// Withdraw from the least-full shulker (first in list, sorted ASC)
			const source = nonFull[0];
			console.log(`Storage: Consolidating ${itemName} — withdrawing from shulker ${source.id} (${source.slot_count} slots used)`);

			const chestPos = new Vec3(source.pos_x, source.pos_y, source.pos_z);

			try {
				const { withdrawn } = await this.shulkerHandler.withdrawFromShulker(
					this.bot, chestPos, source.slot, itemName, source.total_items,
					source.id, source.chest_id
				);

				if (withdrawn === 0) {
					console.log(`Storage: Could not withdraw from shulker ${source.id}, skipping`);
					continue;
				}

				console.log(`Storage: Withdrew ${withdrawn}x ${itemName}, depositing into fuller shulker(s)`);

				// Deposit will fill the most-full matching shulker first (exclude source to prevent depositing back)
				const result = await this.depositItemType(itemName, withdrawn, source.id);
				consolidated++;

				// If source shulker is now empty, clear its item_focus
				const updatedSource = await Database.getShulkerById(source.id);
				if (updatedSource && updatedSource.total_items === 0) {
					await Database.updateShulkerItemFocus(source.id, null);
					console.log(`Storage: Shulker ${source.id} is now empty, cleared item_focus`);
				}

			} catch (error) {
				console.error(`Storage: Error consolidating ${itemName}:`, error.message);
			}

			// Check inventory space before continuing
			const freeSlots = this.bot.bot.inventory.slots.filter((s, i) => !s && i >= 9).length;
			if (freeSlots < 3) {
				console.log('Storage: Inventory too full, stopping consolidation');
				break;
			}

			await sleep(250);
		}

		if (consolidated > 0) {
			await Database.rebuildItemIndex();
		}
		console.log(`Storage: Consolidated ${consolidated} item type(s)`);
		return consolidated;
	}

	/**
	 * Return items of a given type from bot inventory back into a chest.
	 * Used by organize when deposit is partial to prevent inventory buildup.
	 */
	async _returnItemsToChest(chestPos, itemName) {
		const itemsInInv = this.bot.bot.inventory.items().filter(i => i.name === itemName);
		if (itemsInInv.length === 0) return;

		console.log(`Storage: Returning ${itemsInInv.length} stack(s) of ${itemName} to chest at ${chestPos}`);
		await this.bot.goTo({ where: chestPos, range: 3 });
		const chestBlock = this.bot.bot.blockAt(chestPos);
		const window = await this.bot.openContainer(chestBlock);
		await sleep(300);

		for (let i = window.inventoryStart; i < window.inventoryEnd; i++) {
			const item = window.slots[i];
			if (!item || item.name !== itemName) continue;

			// Find empty chest slot
			let targetSlot = null;
			for (let j = 0; j < window.inventoryStart; j++) {
				if (!window.slots[j]) {
					targetSlot = j;
					break;
				}
			}
			if (targetSlot === null) {
				console.log('Storage: Chest full, cannot return all items');
				break;
			}

			await this.bot.bot.moveSlotItem(i, targetSlot);
			await sleep(200);
		}

		await this.bot.bot.closeWindow(window);
		await sleep(200);
	}

	// ========================================
	// Special Item Withdrawal
	// ========================================

	async handleWithdrawSpecialItem(playerName, shulkerItemId) {
		console.log(`Storage[${this.bot.name}]: Special item withdraw request from ${playerName}: shulker_item #${shulkerItemId}`);
		this._busy = true;

		try {
			// Look up the specific shulker_items row
			const itemRow = await Database.getShulkerItemById(shulkerItemId);
			if (!itemRow) {
				return this.bot.whisper(playerName, `Special item #${shulkerItemId} not found.`);
			}

			const shulker = await Database.getShulkerById(itemRow.shulker_id);
			if (!shulker) {
				return this.bot.whisper(playerName, `Shulker for item #${shulkerItemId} not found.`);
			}

			const chest = await Database.getChestById(shulker.chest_id);
			if (!chest) {
				return this.bot.whisper(playerName, `Chest for shulker #${shulker.id} not found.`);
			}

			const chestPos = new Vec3(chest.pos_x, chest.pos_y, chest.pos_z);

			try {
				const { withdrawn } = await this.shulkerHandler.withdrawFromShulkerSlot(
					this.bot, chestPos, shulker.slot, itemRow.slot, itemRow.count, shulker.id, shulker.chest_id
				);

				if (withdrawn > 0) {
					await Database.rebuildItemIndex();

					const timeoutId = setTimeout(() => {
						this.restoreWithdrawal(playerName);
					}, 5 * 60 * 1000);

					this.pendingWithdrawals.set(playerName, {
						itemName: itemRow.item_name,
						count: withdrawn,
						mode: 'items',
						timeoutId,
					});

					await Database.logTrade(playerName, 'withdraw', [{ name: itemRow.item_name, count: withdrawn, special: true }]);
					this.bot.whisper(playerName, `${withdrawn}x ${itemRow.item_name} (special) ready. Use /trade to collect within 5 minutes.`);
				} else {
					this.bot.whisper(playerName, `Failed to withdraw special item.`);
				}
			} catch (error) {
				console.error(`Storage: Error withdrawing special item:`, error.message);
				this.bot.whisper(playerName, `Withdraw failed: ${error.message}`);
			}
		} finally {
			this._busy = false;
		}
	}

	// ========================================
	// Status & Search
	// ========================================

	async getStatus(playerName) {
		const stats = await Database.getStats();
		this.bot.whisper(playerName, `Storage: ${stats.totalItems} items in ${stats.totalShulkers} shulkers (${stats.totalChests} chests)`);
	}

	async findItem(itemName) {
		return await Database.searchItems(itemName);
	}

	async checkPermission(name, requiredRole) {
		return await Database.checkPermission(name, requiredRole);
	}

	// ========================================
	// Command Handler
	// ========================================

	async handleCommand(from, command, ...args) {
		console.log(`Storage: Command '${command}' from ${from} with args:`, args);
		this._currentCommand = command;

		try { switch (command) {
			case 'scan':
				this.bot.whisper(from, 'Starting storage scan...');
				try {
					await this.scanArea(true);
					const stats = await Database.getStats();
					this.bot.whisper(from, `Scan complete! ${stats.totalChests} chests, ${stats.totalShulkers} shulkers, ${stats.totalItems} items`);
				} catch (error) {
					console.error('Storage: Scan error:', error);
					this.bot.whisper(from, `Scan failed: ${error.message}`);
				}
				break;

			case 'status':
				await this.getStatus(from);
				break;

			case 'withdraw': {
				const [itemName, count] = args;
				const parsedCount = parseInt(count) || 1;
				await this.handleWithdrawRequest(from, itemName, parsedCount);
				break;
			}

			case 'withdraw-shulkers': {
				const [itemName, shulkerCount] = args;
				await this.handleWithdrawShulkers(from, itemName, shulkerCount);
				break;
			}

			case 'find': {
				const [searchTerm] = args;
				const items = await this.findItem(searchTerm);
				if (items.length === 0) {
					this.bot.whisper(from, `No items found matching '${searchTerm}'`);
				} else {
					const results = items.slice(0, 5).map(i => `${i.item_name}: ${i.total_count}`);
					this.bot.whisper(from, `Found: ${results.join(', ')}`);
				}
				break;
			}

			case 'chests': {
				const chests = await Database.getChests();
				this.bot.whisper(from, `Tracking ${chests.length} chests`);
				break;
			}

			case 'organize':
				this.bot.whisper(from, 'Starting organize...');
				try {
					const count = await this.organizeLooseItems();
					this.bot.whisper(from, `Organize complete! Sorted ${count} item stacks.`);
				} catch (error) {
					console.error('Storage: Organize error:', error);
					this.bot.whisper(from, `Organize failed: ${error.message}`);
				}
				break;

			case 'consolidate':
				this.bot.whisper(from, 'Starting consolidation...');
				try {
					this._busy = true;
					const count = await this.consolidateShulkers();
					this.bot.whisper(from, `Consolidation complete! Merged ${count} item type(s).`);
				} catch (error) {
					console.error('Storage: Consolidate error:', error);
					this.bot.whisper(from, `Consolidation failed: ${error.message}`);
				} finally {
					this._busy = false;
				}
				break;

			case 'addplayer': {
				const [playerName, role] = args;
				try {
					await Database.addPlayer(playerName, role || 'team');
					this.bot.whisper(from, `Added ${playerName} as ${role || 'team'}`);
				} catch (error) {
					this.bot.whisper(from, `Failed to add player: ${error.message}`);
				}
				break;
			}

			case 'removeplayer': {
				const [removePlayer] = args;
				try {
					await Database.removePlayer(removePlayer);
					this.bot.whisper(from, `Removed ${removePlayer}`);
				} catch (error) {
					this.bot.whisper(from, `Failed to remove player: ${error.message}`);
				}
				break;
			}

			case 'players': {
				const players = await Database.getAllPlayers();
				const playerList = players.map(p => `${p.player_name}(${p.role})`).join(', ');
				this.bot.whisper(from, `Players: ${playerList}`);
				break;
			}

			default:
				this.bot.whisper(from, `Unknown command: ${command}`);
		}
		} finally {
			this._currentCommand = null;
		}
	}
}

module.exports = Storage;