'use strict';

const { sleep } = require('../utils');

const botSlots = [0, 1, 2, 3, 9, 10, 11, 12, 18, 19, 20, 21];

class FarmSupply {
	constructor(args) {
		this.bot = args.bot;
		const settings = require('./settings/manager');
		this.config = {
			enabled: settings.get('farmSupply.enabled'),
			storageBotName: settings.get('farmSupply.storageBotName'),
		};
		this._storageBotKey = this.config.storageBotName;
		this.isAction = true;
		this._onTimeListen = null;
		this._onReadyListen = null;
		this._resupplying = false;
	}

	get storageBotName() {
		const storageBot = this.bot.constructor.bots[this._storageBotKey];
		if (storageBot && storageBot.bot && storageBot.bot.entity) {
			return storageBot.bot.entity.username;
		}
		return this._storageBotKey;
	}

	async init() {
		if (!this._storageBotKey) {
			console.log('FarmSupply: No storageBotName configured, plugin disabled');
			return false;
		}

		console.log(`FarmSupply: Initialized for bot ${this.bot.name}, storage bot: ${this._storageBotKey}`);

		this._onReadyListen = this.bot.on('onReady', async () => {
			await sleep(3000);
			let lastTimeOfDay = this.bot.bot.time.timeOfDay;

			this._onTimeListen = this.bot.bot.on('time', async () => {
				const currentTime = this.bot.bot.time.timeOfDay;
				if (lastTimeOfDay < 12000 && currentTime >= 12000 && !this._resupplying) {
					lastTimeOfDay = currentTime;
					console.log('FarmSupply: Sunset detected, starting resupply');
					try {
						await this.resupply();
					} catch (error) {
						console.error('FarmSupply: Sunset resupply error:', error);
					}
				} else {
					lastTimeOfDay = currentTime;
				}
			});
		});

		return true;
	}

	unload() {
		if (this._onReadyListen) this._onReadyListen();
		if (this._onTimeListen) this._onTimeListen = null;
		return true;
	}

	// ========================================
	// Pause / Resume farm plugins
	// ========================================

	pauseFarmPlugins() {
		const paused = [];
		for (const [name, plugin] of Object.entries(this.bot.plunginsLoaded)) {
			if (name === 'FarmSupply' || name === 'AutoEat') continue;
			if (plugin.isAction) {
				console.log(`FarmSupply: Pausing plugin ${name}`);
				try {
					plugin.unload();
				} catch (error) {
					console.error(`FarmSupply: Error pausing ${name}:`, error);
				}
				paused.push(name);
				delete this.bot.plunginsLoaded[name];
			}
		}
		return paused;
	}

	async resumeFarmPlugins(paused) {
		for (const name of paused) {
			console.log(`FarmSupply: Resuming plugin ${name}`);
			try {
				await this.bot.pluginLoad(name);
			} catch (error) {
				console.error(`FarmSupply: Error resuming ${name}:`, error);
			}
		}
	}

	// ========================================
	// Wait after trade teleport — let server tp us back and chunks load
	// ========================================

	async settleAfterTrade() {
		console.log('FarmSupply: Settling after trade teleport...');
		await sleep(3000);
		// Wait for pathfinder to be idle
		while (this.bot.bot.pathfinder.isMoving()) {
			this.bot.bot.clearControlStates();
			await sleep(500);
		}
		this.bot.bot.clearControlStates();
		await sleep(1000);
	}

	// ========================================
	// Main resupply flow
	// ========================================

	async resupply() {
		if (this._resupplying) {
			console.log('FarmSupply: Already resupplying, skipping');
			return;
		}

		this._resupplying = true;
		console.log('FarmSupply: Starting resupply...');
		const paused = this.pauseFarmPlugins();

		try {
			await this.emptyFilledBoxes();
			await this.fillEmptyShulkers();
		} catch (error) {
			console.error('FarmSupply: Resupply error:', error);
		} finally {
			// Always resume the farm and clear the flag — a stuck trade must
			// not leave the farm paused until restart
			try {
				await this.resumeFarmPlugins(paused);
			} catch (resumeError) {
				console.error('FarmSupply: Error resuming farm plugins:', resumeError);
			}
			this._resupplying = false;
			console.log('FarmSupply: Resupply complete, farm resumed.');
		}
	}

	// ========================================
	// Storage bot access
	// ========================================

	/**
	 * Bring the on-demand storage bot online (with plugins loaded) and return
	 * its Storage plugin instance. Returns null if unavailable.
	 */
	async _ensureStorageOnline() {
		const storageBot = this.bot.constructor.bots[this._storageBotKey];
		if (!storageBot) {
			console.log(`FarmSupply: Storage bot '${this._storageBotKey}' not configured`);
			return null;
		}

		if (!storageBot.isReady) {
			console.log('FarmSupply: Bringing storage bot online...');
			try {
				await Promise.race([
					storageBot.ensureConnected(async () => {}),
					sleep(60000).then(() => { throw new Error('Storage bot connect timeout'); }),
				]);
			} catch (error) {
				console.error(`FarmSupply: Could not bring storage bot online: ${error.message}`);
				return null;
			}
		}

		return storageBot.plunginsLoaded['Storage'] || null;
	}

	// ========================================
	// Empty "filled boxes" chest
	// ========================================

	async emptyFilledBoxes() {
		let filledChest;
		try {
			filledChest = this.bot.findBlockBySign('filled boxes');
		} catch (error) {
			console.log('FarmSupply: No "filled boxes" chest found, skipping');
			return;
		}
		if (!filledChest) {
			console.log('FarmSupply: No "filled boxes" chest found, skipping');
			return;
		}

		console.log('FarmSupply: Processing filled boxes chest');

		// Boxes left in inventory by a previously failed deposit go first,
		// before taking more from the chest
		const leftover = this.bot.bot.inventory.items().filter(i => i.name.includes('shulker_box'));
		if (leftover.length > 0) {
			console.log(`FarmSupply: ${leftover.length} leftover box(es) in inventory, depositing those first`);
			// Player inventory slot 9+k maps to window.inventoryStart+k
			await this.tradeDeposit(leftover.slice(0, 12).map(i => i.slot - 9));
			await this.waitForStorageBotIdle();
			await this.settleAfterTrade();
		}

		let hasMore = true;
		while (hasMore) {
			await this.bot.goToMust({ where: filledChest.position, range: 2 });
			let window = await this.bot.openContainer(this.bot.findChestBySign('filled boxes'));
			await sleep(300);

			// Track slots RELATIVE to inventoryStart — the trade window has a
			// different inventoryStart than this chest window, so absolute slot
			// numbers from here would point at the wrong items there
			const takenSlots = [];
			for (let chestSlot = 0; chestSlot < window.inventoryStart; chestSlot++) {
				if (takenSlots.length >= 12) break;
				const item = window.slots[chestSlot];
				if (!item || !item.name.includes('shulker_box')) continue;

				const destSlot = window.inventoryStart + takenSlots.length;
				if (window.slots[destSlot]) {
					console.log(`FarmSupply: Inventory slot ${destSlot} occupied, finding free slot`);
					// Find an actually empty slot
					let found = false;
					for (let freeSlot = window.inventoryStart; freeSlot < window.inventoryEnd; freeSlot++) {
						if (!window.slots[freeSlot]) {
							await this.bot.bot.moveSlotItem(chestSlot, freeSlot);
							await sleep(200);
							takenSlots.push(freeSlot - window.inventoryStart);
							found = true;
							break;
						}
					}
					if (!found) {
						console.log('FarmSupply: No empty inventory slots, stopping');
						break;
					}
				} else {
					await this.bot.bot.moveSlotItem(chestSlot, destSlot);
					await sleep(200);
					takenSlots.push(destSlot - window.inventoryStart);
				}
			}

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

			if (takenSlots.length === 0) {
				console.log('FarmSupply: No more filled shulker boxes to deposit');
				hasMore = false;
				break;
			}

			console.log(`FarmSupply: Took ${takenSlots.length} shulker boxes, initiating trade deposit`);
			await this.tradeDeposit(takenSlots);
			await this.waitForStorageBotIdle();
			await this.settleAfterTrade();
		}
	}

	// ========================================
	// Fill "empty shulkers" chest
	// ========================================

	async fillEmptyShulkers() {
		let emptyChest;
		try {
			emptyChest = this.bot.findBlockBySign('empty shulkers');
		} catch (error) {
			console.log('FarmSupply: No "empty shulkers" chest found, skipping');
			return;
		}
		if (!emptyChest) {
			console.log('FarmSupply: No "empty shulkers" chest found, skipping');
			return;
		}

		console.log('FarmSupply: Processing empty shulkers chest');

		await this.bot.goToMust({ where: emptyChest.position, range: 2 });
		let window = await this.bot.openContainer(this.bot.findChestBySign('empty shulkers'));
		await sleep(300);

		let emptySlots = 0;
		for (let chestSlot = 0; chestSlot < window.inventoryStart; chestSlot++) {
			if (!window.slots[chestSlot]) emptySlots++;
		}

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

		if (emptySlots === 0) {
			console.log('FarmSupply: Empty shulkers chest is full, skipping');
			return;
		}

		console.log(`FarmSupply: Need ${emptySlots} shulker boxes`);

		// Check current inventory for materials
		let shellsInInv = 0;
		let chestsInInv = 0;
		let shulkerBoxesInInv = 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;
			if (item.name.includes('shulker_box')) shulkerBoxesInInv += item.count;
		}

		const canCraft = Math.min(Math.floor(shellsInInv / 2), chestsInInv);
		const totalAvailable = shulkerBoxesInInv + canCraft;
		const needed = Math.min(emptySlots, 27);

		if (totalAvailable < needed) {
			const toCraft = needed - shulkerBoxesInInv;
			const shellsNeeded = Math.max(0, (toCraft * 2) - shellsInInv);
			const chestsNeeded = Math.max(0, toCraft - chestsInInv);

			if (shellsNeeded > 0) {
				console.log(`FarmSupply: Withdrawing ${shellsNeeded} shulker_shell from storage`);
				await this.tradeWithdraw('shulker_shell', shellsNeeded);
				await this.waitForStorageBotIdle();
				await this.settleAfterTrade();
			}

			if (chestsNeeded > 0) {
				console.log(`FarmSupply: Withdrawing ${chestsNeeded} chest from storage`);
				await this.tradeWithdraw('chest', chestsNeeded);
				await this.waitForStorageBotIdle();
				await this.settleAfterTrade();
			}
		}

		// Recount after possible withdrawal
		shellsInInv = 0;
		chestsInInv = 0;
		shulkerBoxesInInv = 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;
			if (item.name.includes('shulker_box')) shulkerBoxesInInv += item.count;
		}

		// Craft shulker boxes
		const craftCount = Math.min(Math.floor(shellsInInv / 2), chestsInInv, needed - shulkerBoxesInInv);
		if (craftCount > 0) {
			console.log(`FarmSupply: Crafting ${craftCount} shulker boxes`);
			for (let i = 0; i < craftCount; i++) {
				try {
					await this.craftShulkerBox();
					await sleep(300);
				} catch (error) {
					console.error('FarmSupply: Crafting error:', error);
					break;
				}
			}
		}

		// Re-find chest and dump shulker boxes
		emptyChest = this.bot.findChestBySign('empty shulkers');
		await this.bot.goToMust({ where: emptyChest.position, range: 2 });
		window = await this.bot.openContainer(emptyChest);
		await sleep(300);

		let deposited = 0;
		for (let invSlot = window.inventoryStart; invSlot < window.inventoryEnd; invSlot++) {
			const item = window.slots[invSlot];
			if (item && item.name.includes('shulker_box')) {
				let targetSlot = null;
				for (let emptyChestSlot = 0; emptyChestSlot < window.inventoryStart; emptyChestSlot++) {
					if (!window.slots[emptyChestSlot]) {
						targetSlot = emptyChestSlot;
						break;
					}
				}
				if (targetSlot === null) break;

				try {
					await this.bot.bot.moveSlotItem(invSlot, targetSlot);
					await sleep(200);
					deposited++;
				} catch (error) {
					console.error('FarmSupply: Error depositing shulker box:', error);
				}
			}
		}

		await this.bot.bot.closeWindow(window);
		console.log(`FarmSupply: Deposited ${deposited} shulker boxes into empty shulkers chest`);
	}

	// ========================================
	// Trade: Withdraw items from storage bot
	// ========================================

	async tradeWithdraw(itemName, count) {
		const storageName = this.storageBotName;
		console.log(`FarmSupply: Requesting ${count}x ${itemName} from ${storageName}`);

		// Both bots run in this process — call the storage plugin directly
		// instead of whispering a chat command (which raced against the storage
		// bot's command lock and required the bot to already be online)
		const storage = await this._ensureStorageOnline();
		if (!storage) throw new Error(`Storage bot unavailable for ${itemName} withdraw`);

		// Listen for the "ready — sending trade request" whisper the storage
		// bot sends right before initiating /trade with us
		let cleanupWhisper = () => {};
		const whisperPromise = new Promise((resolve, reject) => {
			const timeout = setTimeout(() => {
				cleanupWhisper();
				reject(new Error(`Timeout waiting for ${storageName} to prepare ${itemName}`));
			}, 180000);
			const onWhisper = (from, message) => {
				if (from !== storageName) return;
				if (message.includes('ready — sending trade')) {
					cleanupWhisper();
					resolve();
				} else if (message.includes('Item not found') || message.includes('Failed to withdraw')
					|| message.includes('Cannot find') || message.includes('Storage busy')) {
					cleanupWhisper();
					reject(new Error(`Storage bot: ${message}`));
				}
			};
			cleanupWhisper = () => {
				this.bot.bot.removeListener('whisper', onWhisper);
				clearTimeout(timeout);
			};
			this.bot.bot.on('whisper', onWhisper);
		});

		// Fire the withdraw — it pulls items from shulkers (can take minutes),
		// then trades with us. Don't await yet: we have to accept its trade
		// for it to complete.
		const myUsername = this.bot.bot.entity.username;
		const requestPromise = storage.handleWithdrawRequest(myUsername, itemName, count)
			.catch(error => console.error(`FarmSupply: Storage withdraw error: ${error.message}`));

		try {
			await whisperPromise;
		} catch (error) {
			await requestPromise;
			throw error;
		}

		// Poll /trade accept until the trade window opens.
		// Set up windowOpen listener BEFORE chat to avoid missing the event.
		let window = null;
		const tradeStart = Date.now();
		while (!window && (Date.now() - tradeStart) < 45000) {
			const winPromise = this.bot.once('windowOpen');
			await this.bot.bot.chat('/trade accept');
			window = await Promise.race([winPromise, sleep(2000).then(() => null)]);
		}
		if (!window) throw new Error(`Trade window did not open with ${storageName}`);

		// Click 1: lock our items — single left-click (moveSlotItem's
		// pickup+putdown pair desyncs on the cancelled GUI slot and trips
		// anti-cheat)
		await sleep(500);
		try { await this.bot.bot.clickWindow(37, 0, 0); } catch (e) { /* ignore */ }
		console.log('FarmSupply: Trade click 1 — items locked');

		// Wait for storage bot to lock (slot 53 turns lime_dye), bounded —
		// an unbounded poll here used to hang resupply forever on a dead trade
		const locked = await this._waitForTradeLock(window, 120000);
		if (!locked) {
			try { this.bot.bot.closeWindow(window); } catch (e) { /* ignore */ }
			await requestPromise;
			throw new Error(`${storageName} never confirmed the ${itemName} trade`);
		}

		// Click 2: final confirmation
		if (this.bot.bot.currentWindow === window) {
			try { await this.bot.bot.clickWindow(37, 0, 0); } catch (e) { /* ignore */ }
			console.log('FarmSupply: Trade click 2 — final confirm');
		}

		// Wait for trade to complete
		await Promise.race([
			this.bot.once('windowClose'),
			sleep(120000),
		]);

		await requestPromise;
		await sleep(500);
		console.log(`FarmSupply: Withdraw trade complete for ${itemName}`);
	}

	/**
	 * Poll the trade window for the other party's lock indicator (slot 53
	 * turning lime_dye). Resolves true when locked, false on timeout or if
	 * the window closes.
	 */
	async _waitForTradeLock(window, timeoutMs) {
		const start = Date.now();
		while (Date.now() - start < timeoutMs) {
			try {
				const indicator = window.slots[53];
				if (indicator && indicator.name === 'lime_dye') {
					console.log('FarmSupply: Storage bot has locked');
					return true;
				}
			} catch (e) {
				return false; // window closed
			}
			if (this.bot.bot.currentWindow !== window) return false;
			await sleep(500);
		}
		return false;
	}

	// ========================================
	// Trade: Deposit items to storage bot
	// ========================================

	async tradeDeposit(slotsToTrade) {
		console.log(`FarmSupply: Depositing ${slotsToTrade.length} shulker boxes to ${this.storageBotName}`);

		// Storage bot is on-demand — it must be online to accept the trade
		const storage = await this._ensureStorageOnline();
		if (!storage) throw new Error('Storage bot unavailable for deposit');

		const windowPromise = this.bot.once('windowOpen');
		await this.bot.say(`/trade ${this.storageBotName}`);
		let window = await Promise.race([
			windowPromise,
			sleep(45000).then(() => null),
		]);
		if (!window) throw new Error(`Trade window with ${this.storageBotName} never opened`);

		// slotsToTrade holds inventory-relative indices — offset them into
		// this window's inventory section
		let placed = 0;
		for (const tradeSlot of botSlots) {
			if (placed >= slotsToTrade.length) break;
			try {
				await this.bot.bot.moveSlotItem(window.inventoryStart + slotsToTrade[placed], tradeSlot);
				await sleep(200);
				placed++;
			} catch (error) {
				console.error('FarmSupply: Error placing item in trade:', error);
			}
		}

		console.log(`FarmSupply: Placed ${placed} shulker boxes in trade window`);

		// Click 1: lock items (green wool — first confirmation, single click)
		try {
			await this.bot.bot.clickWindow(37, 0, 0);
			console.log('FarmSupply: Trade click 1 — items locked');
		} catch (error) {
			console.error('FarmSupply: Error on trade click 1:', error);
		}

		// Wait for storage bot to lock (slot 53 turns lime_dye from grey_dye)
		const locked = await this._waitForTradeLock(window, 120000);
		if (!locked) {
			try { this.bot.bot.closeWindow(window); } catch (e) { /* ignore */ }
			throw new Error('Storage bot never confirmed the deposit trade');
		}

		// Click 2: final confirmation (green wool — second click, both locked)
		try {
			if (this.bot.bot.currentWindow === window) {
				await this.bot.bot.clickWindow(37, 0, 0);
				console.log('FarmSupply: Trade click 2 — final confirm');
			}
		} catch (error) {
			console.error('FarmSupply: Error on trade click 2:', error);
		}

		try {
			await Promise.race([
				this.bot.once('windowClose'),
				sleep(30000),
			]);
		} catch (error) {
			console.error('FarmSupply: Trade deposit timeout or error:', error);
		}

		await sleep(500);
		console.log(`FarmSupply: Deposit trade complete`);
	}

	// ========================================
	// Wait for storage bot to finish processing
	// ========================================

	async waitForStorageBotIdle() {
		const storageBot = this.bot.constructor.bots[this._storageBotKey];
		if (!storageBot) return;

		const storage = storageBot.plunginsLoaded['Storage'];
		if (!storage) return;

		console.log('FarmSupply: Waiting for storage bot to finish processing...');
		const maxWait = 300000;
		const start = Date.now();
		const isBusy = () => storage._busy || storage._operationLock;

		while (Date.now() - start < maxWait) {
			if (!isBusy()) {
				// There's a short gap between the trade handler releasing the
				// lock and the post-trade organize grabbing it — require the
				// bot to stay idle across a re-check before trusting it
				await sleep(3000);
				if (!isBusy()) break;
			}
			await sleep(2000);
		}

		if (isBusy()) {
			console.log('FarmSupply: Storage bot still busy after timeout, continuing anyway');
		} else {
			console.log('FarmSupply: Storage bot idle');
		}
		await sleep(1000);
	}

	// ========================================
	// Craft a shulker box
	// ========================================

	async craftShulkerBox() {
		let craftingTable;
		try {
			const signBlock = this.bot.findBlockBySign('crafting table');
			if (signBlock) {
				craftingTable = this.bot.bot.findBlock({
					point: signBlock.position,
					matching: this.bot.mcData.blocksByName.crafting_table.id,
					maxDistance: 4,
				});
			}
		} catch (error) {
			// No sign, search nearby
		}

		if (!craftingTable) {
			craftingTable = this.bot.bot.findBlock({
				matching: this.bot.mcData.blocksByName.crafting_table.id,
				maxDistance: 64,
			});
		}

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

		await this.bot.goToMust({ where: craftingTable.position, range: 2 });

		const recipe = this.bot.bot.recipesAll(
			this.bot.mcData.itemsByName.shulker_box.id,
			null,
			craftingTable
		)[0];

		if (!recipe) {
			throw new Error('FarmSupply: No recipe found for shulker box');
		}

		const window = await this.bot.openCraftingTable(craftingTable);
		const inventory = window.slots.slice(window.inventoryStart, window.inventoryEnd);

		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 (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(`FarmSupply: Missing ingredient type ${typeId} in inventory`);
			}
			const actualSlot = window.inventoryStart + invIdx;

			await this.bot.bot.clickWindow(actualSlot, 0, 0);
			await sleep(100);

			for (const gridSlot of gridSlots) {
				await this.bot.bot.clickWindow(gridSlot, 1, 0);
				await sleep(100);
			}

			await this.bot.bot.clickWindow(actualSlot, 0, 0);
			await sleep(100);
		}

		await sleep(500);

		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(300);
		console.log('FarmSupply: Crafted a shulker box');
	}
}

FarmSupply.getStatus = function(instance) {
	return {
		active: true,
		storageBotName: instance._storageBotKey,
		resupplying: instance._resupplying,
	};
};

module.exports = FarmSupply;