/**
 * Learns where items get moved and suggests target pages for future moves.
 * Stores patterns in localStorage:
 *   - By interaction type (e.g. "clothing" → page #42)
 *   - By item name prefix (e.g. "rare_" → page #15)
 *   - Recent moves (last 10)
 *
 * All suggestions are non-forced — just ranked higher in the combobox.
 */

const STORAGE_KEY = "catalog_move_suggestions";

interface MoveRecord {
	targetPageId: number;
	count: number;
}

interface SuggestionStore {
	/** interaction type → target pages with count */
	byType: Record<string, MoveRecord[]>;
	/** item name prefix (first segment before _) → target pages with count */
	byPrefix: Record<string, MoveRecord[]>;
	/** last N recent targets */
	recent: number[];
}

function load(): SuggestionStore {
	try {
		const raw = localStorage.getItem(STORAGE_KEY);
		if (raw) return JSON.parse(raw);
	} catch {}
	return { byType: {}, byPrefix: {}, recent: [] };
}

function save(store: SuggestionStore) {
	try {
		localStorage.setItem(STORAGE_KEY, JSON.stringify(store));
	} catch {}
}

function extractPrefix(itemName: string): string {
	if (!itemName) return "";
	const idx = itemName.indexOf("_");
	return idx > 0
		? itemName.substring(0, idx).toLowerCase()
		: itemName.toLowerCase();
}

function incrementRecord(
	records: MoveRecord[],
	targetPageId: number,
): MoveRecord[] {
	const existing = records.find((r) => r.targetPageId === targetPageId);
	if (existing) {
		return records
			.map((r) =>
				r.targetPageId === targetPageId ? { ...r, count: r.count + 1 } : r,
			)
			.sort((a, b) => b.count - a.count);
	}
	return [...records, { targetPageId, count: 1 }]
		.sort((a, b) => b.count - a.count)
		.slice(0, 10);
}

/**
 * Record a move for learning. Call this after successfully moving an item.
 */
export function recordMove(opts: {
	interactionType?: string;
	itemName?: string;
	targetPageId: number;
}) {
	const store = load();
	const { interactionType, itemName, targetPageId } = opts;

	if (interactionType) {
		const key = interactionType.toLowerCase();
		store.byType[key] = incrementRecord(store.byType[key] || [], targetPageId);
	}

	const prefix = extractPrefix(itemName ?? "");
	if (prefix && prefix.length > 1) {
		store.byPrefix[prefix] = incrementRecord(
			store.byPrefix[prefix] || [],
			targetPageId,
		);
	}

	// Recent (deduplicate, keep last 10)
	store.recent = [
		targetPageId,
		...store.recent.filter((id) => id !== targetPageId),
	].slice(0, 10);

	save(store);
}

/**
 * Get suggested page IDs for moving an item, ranked by relevance.
 * Returns unique page IDs ordered by best match.
 */
export function getSuggestions(opts: {
	interactionType?: string;
	itemName?: string;
}): number[] {
	const store = load();
	const { interactionType, itemName } = opts;
	const scores = new Map<number, number>();

	// By interaction type (highest weight)
	if (interactionType) {
		const records = store.byType[interactionType.toLowerCase()] || [];
		for (const r of records) {
			scores.set(
				r.targetPageId,
				(scores.get(r.targetPageId) ?? 0) + r.count * 3,
			);
		}
	}

	// By name prefix
	const prefix = extractPrefix(itemName ?? "");
	if (prefix && prefix.length > 1) {
		const records = store.byPrefix[prefix] || [];
		for (const r of records) {
			scores.set(
				r.targetPageId,
				(scores.get(r.targetPageId) ?? 0) + r.count * 2,
			);
		}
	}

	// Recent (lowest weight)
	for (let i = 0; i < store.recent.length; i++) {
		const id = store.recent[i];
		scores.set(id, (scores.get(id) ?? 0) + (10 - i));
	}

	return Array.from(scores.entries())
		.sort((a, b) => b[1] - a[1])
		.map(([id]) => id);
}