openmonetis/lib/utils/calculator.ts

export type Operator = "add" | "subtract" | "multiply" | "divide";

export const OPERATOR_SYMBOLS: Record<Operator, string> = {
	add: "+",
	subtract: "-",
	multiply: "×",
	divide: "÷",
};

export function formatNumber(value: number): string {
	if (!Number.isFinite(value)) {
		return "Erro";
	}

	const rounded = Number(Math.round(value * 1e10) / 1e10);
	return rounded.toString();
}

export function formatLocaleValue(rawValue: string): string {
	if (rawValue === "Erro") {
		return rawValue;
	}

	const isNegative = rawValue.startsWith("-");
	const unsignedValue = isNegative ? rawValue.slice(1) : rawValue;

	if (unsignedValue === "") {
		return isNegative ? "-0" : "0";
	}

	const hasDecimalSeparator = unsignedValue.includes(".");
	const [integerPartRaw, decimalPartRaw] = unsignedValue.split(".");

	const integerPart = integerPartRaw || "0";
	const decimalPart = hasDecimalSeparator ? (decimalPartRaw ?? "") : undefined;

	const numericInteger = Number(integerPart);
	const formattedInteger = Number.isFinite(numericInteger)
		? numericInteger.toLocaleString("pt-BR")
		: integerPart;

	if (decimalPart === undefined) {
		return `${isNegative ? "-" : ""}${formattedInteger}`;
	}

	return `${isNegative ? "-" : ""}${formattedInteger},${decimalPart}`;
}

export function performOperation(
	a: number,
	b: number,
	operator: Operator,
): number {
	switch (operator) {
		case "add":
			return a + b;
		case "subtract":
			return a - b;
		case "multiply":
			return a * b;
		case "divide":
			return b === 0 ? Infinity : a / b;
		default:
			return b;
	}
}

// Trata colagem de valores com formatação brasileira (ponto para milhar, vírgula para decimal)
// e variações simples em formato internacional.
export function normalizeClipboardNumber(rawValue: string): string | null {
	const trimmed = rawValue.trim();
	if (!trimmed) {
		return null;
	}

	const match = trimmed.match(/-?[\d.,\s]+/);
	if (!match) {
		return null;
	}

	let extracted = match[0].replace(/\s+/g, "");
	if (!extracted) {
		return null;
	}

	const isNegative = extracted.startsWith("-");
	if (isNegative) {
		extracted = extracted.slice(1);
	}

	extracted = extracted.replace(/[^\d.,]/g, "");
	if (!extracted) {
		return null;
	}

	const countOccurrences = (char: string) =>
		(extracted.match(new RegExp(`\\${char}`, "g")) ?? []).length;

	const hasComma = extracted.includes(",");
	const hasDot = extracted.includes(".");

	let decimalSeparator: "," | "." | null = null;

	if (hasComma && hasDot) {
		decimalSeparator =
			extracted.lastIndexOf(",") > extracted.lastIndexOf(".") ? "," : ".";
	} else if (hasComma) {
		const commaCount = countOccurrences(",");
		if (commaCount > 1) {
			decimalSeparator = null;
		} else {
			const digitsAfterComma =
				extracted.length - extracted.lastIndexOf(",") - 1;
			decimalSeparator =
				digitsAfterComma > 0 && digitsAfterComma <= 2 ? "," : null;
		}
	} else if (hasDot) {
		const dotCount = countOccurrences(".");
		if (dotCount > 1) {
			decimalSeparator = null;
		} else {
			const digitsAfterDot = extracted.length - extracted.lastIndexOf(".") - 1;
			const decimalCandidate = extracted.slice(extracted.lastIndexOf(".") + 1);
			const allZeros = /^0+$/.test(decimalCandidate);
			const shouldTreatAsDecimal =
				digitsAfterDot > 0 &&
				digitsAfterDot <= 3 &&
				!(digitsAfterDot === 3 && allZeros);
			decimalSeparator = shouldTreatAsDecimal ? "." : null;
		}
	}

	let integerPart = extracted;
	let decimalPart = "";

	if (decimalSeparator) {
		const decimalIndex = extracted.lastIndexOf(decimalSeparator);
		integerPart = extracted.slice(0, decimalIndex);
		decimalPart = extracted.slice(decimalIndex + 1);
	}

	integerPart = integerPart.replace(/[^\d]/g, "");
	decimalPart = decimalPart.replace(/[^\d]/g, "");

	if (!integerPart) {
		integerPart = "0";
	}

	let normalized = integerPart;
	if (decimalPart) {
		normalized = `${integerPart}.${decimalPart}`;
	}

	if (isNegative && Number(normalized) !== 0) {
		normalized = `-${normalized}`;
	}

	if (!/^(-?\d+(\.\d+)?)$/.test(normalized)) {
		return null;
	}

	const numericValue = Number(normalized);
	if (!Number.isFinite(numericValue)) {
		return null;
	}

	return normalized;
}