export const ItemOriginKind = Object.freeze({
	crafted: "crafted",
	shop: "shop",
	gathered: "gathered",
	unknown: "unknown"
});

/** Gather verbs for origin labels (`Mined by …`, `Felled by …`). */
export const GatherOriginVerb = Object.freeze({
	mined: "Mined",
	felled: "Felled",
	caught: "Caught",
	picked: "Picked"
});

/**
 * Craft verbs by station (`Forged by …` furnace, `Smithed by …` anvil,
 * `Carved by …` woodworking, `Assembled by …` crafting bench).
 */
export const CraftOriginVerb = Object.freeze({
	forged: "Forged",
	smithed: "Smithed",
	carved: "Carved",
	assembled: "Assembled",
	made: "Made"
});

/** @type {Readonly<Record<string, string>>} */
export const CRAFT_ORIGIN_VERB_BY_STATION = Object.freeze({
	furnace: CraftOriginVerb.forged,
	anvil: CraftOriginVerb.smithed,
	"woodworking-bench": CraftOriginVerb.carved,
	"crafting-bench": CraftOriginVerb.assembled
});

export function craftOriginVerbForStation (stationId)
{
	return CRAFT_ORIGIN_VERB_BY_STATION[stationId] ?? CraftOriginVerb.made;
}

export function originKey (origin)
{
	if (!origin)
	{ return "none"; }
	return JSON.stringify(origin);
}

export function originLabel (origin)
{
	if (!origin)
	{ return "unknown origin"; }
	if (origin.kind === ItemOriginKind.crafted)
	{
		const verb = origin.verb?.trim() || CraftOriginVerb.made;
		const name = origin.displayName?.trim() || "someone";
		return `${verb} by ${name}`;
	}
	if (origin.kind === ItemOriginKind.shop)
	{
		const name = origin.displayName?.trim() || "a shop";
		return `Bought from ${name}`;
	}
	if (origin.kind === ItemOriginKind.gathered)
	{
		const verb = origin.verb?.trim() || "Gathered";
		const name = origin.displayName?.trim() || "someone";
		return `${verb} by ${name}`;
	}
	return "unknown origin";
}

/** Build a crafted-item origin (`Forged by Ada`, …). */
export function craftOrigin (verb, displayName)
{
	return {
		kind: ItemOriginKind.crafted,
		verb: String(verb ?? CraftOriginVerb.made).trim() || CraftOriginVerb.made,
		displayName: String(displayName ?? "").trim() || "someone"
	};
}

/** Build a gathered-item origin (`Mined by Ada`, …). */
export function gatherOrigin (verb, displayName)
{
	return {
		kind: ItemOriginKind.gathered,
		verb: String(verb ?? "Gathered").trim() || "Gathered",
		displayName: String(displayName ?? "").trim() || "someone"
	};
}

/** @returns {{ origin: object|null, quantity: number }[]} */
export function normalizeOrigins (stack)
{
	if (!stack)
	{ return []; }
	const qty = Math.max(0, Math.floor(Number(stack.quantity) || 0));
	if (Array.isArray(stack.origins) && stack.origins.length)
	{
		return stack.origins.map((entry) => ({
			origin: entry.origin ?? null,
			quantity: Math.max(0, Math.floor(Number(entry.quantity) || 0))
		})).filter((entry) => entry.quantity > 0);
	}
	if (qty <= 0)
	{ return []; }
	return [{ origin: stack.origin ?? null, quantity: qty }];
}

export function mergeOriginLists (left, right)
{
	const map = new Map();
	for (const entry of [...normalizeOriginsList(left), ...normalizeOriginsList(right)])
	{
		const key = originKey(entry.origin);
		const prev = map.get(key) ?? { origin: entry.origin ?? null, quantity: 0 };
		prev.quantity += entry.quantity;
		map.set(key, prev);
	}
	return [...map.values()].filter((entry) => entry.quantity > 0);
}

function normalizeOriginsList (list)
{
	if (!Array.isArray(list))
	{ return []; }
	return list.map((entry) => ({
		origin: entry?.origin ?? null,
		quantity: Math.max(0, Math.floor(Number(entry?.quantity) || 0))
	})).filter((entry) => entry.quantity > 0);
}

/** FIFO split of origin quantities when taking from a stack. */
export function splitOrigins (origins, takeQuantity)
{
	const take = Math.max(0, Math.floor(Number(takeQuantity) || 0));
	const source = normalizeOriginsList(origins);
	const taken = [];
	const remain = [];
	let left = take;
	for (const entry of source)
	{
		if (left <= 0)
		{
			remain.push({ ...entry });
			continue;
		}
		const amount = Math.min(entry.quantity, left);
		if (amount > 0)
		{
			taken.push({ origin: entry.origin ?? null, quantity: amount });
			left -= amount;
		}
		const rest = entry.quantity - amount;
		if (rest > 0)
		{ remain.push({ origin: entry.origin ?? null, quantity: rest }); }
	}
	return { taken, remain };
}

export function attachOrigins (stack)
{
	const origins = normalizeOrigins(stack);
	const next = { ...stack, origins };
	delete next.origin;
	return next;
}

export function formatOriginBreakdown (stack)
{
	const origins = normalizeOrigins(stack);
	if (!origins.length)
	{ return ""; }
	return origins
		.map((entry) => `${entry.quantity} ${originLabel(entry.origin)}`)
		.join(", ");
}
