/**
 * Função utilitária para extrair o IP do cliente de um Request HTTP
 * Sem usar APIs externas - usa apenas headers HTTP
 */

/**
 * Extrai o IP do cliente de um Request HTTP
 * Considera headers como X-Forwarded-For, X-Real-IP, etc.
 */
export function getClientIP(request: Request): string | undefined {
	// Headers que podem conter o IP do cliente (case-insensitive)
	const getHeader = (name: string): string | null => {
		// Tentar diferentes variações de case
		const variations = [
			name,
			name.toLowerCase(),
			name.toUpperCase(),
			name.charAt(0).toUpperCase() + name.slice(1).toLowerCase()
		];

		for (const variation of variations) {
			const value = request.headers.get(variation);
			if (value) return value;
		}

		// As variações de case já cobrem a maioria dos casos
		// Se não encontrou, retorna null
		return null;
	};

	const forwardedFor = getHeader('x-forwarded-for');
	const realIP = getHeader('x-real-ip');
	const cfConnectingIP = getHeader('cf-connecting-ip'); // Cloudflare
	const trueClientIP = getHeader('true-client-ip'); // Cloudflare Enterprise
	const xClientIP = getHeader('x-client-ip');
	const forwarded = getHeader('forwarded');
	const remoteAddr = getHeader('remote-addr');

	// Log para debug
	console.log('Procurando IP nos headers:', {
		'x-forwarded-for': forwardedFor,
		'x-real-ip': realIP,
		'cf-connecting-ip': cfConnectingIP,
		'true-client-ip': trueClientIP,
		'x-client-ip': xClientIP,
		forwarded: forwarded,
		'remote-addr': remoteAddr
	});

	// Prioridade: X-Forwarded-For pode conter múltiplos IPs (proxy chain)
	// O primeiro IP é geralmente o IP original do cliente
	if (forwardedFor) {
		const ips = forwardedFor.split(',').map((ip) => ip.trim());
		// Pegar o primeiro IP válido
		for (const ip of ips) {
			if (isValidIP(ip)) {
				console.log('IP encontrado em X-Forwarded-For:', ip);
				return ip;
			}
		}
	}

	// Forwarded header (RFC 7239)
	if (forwarded) {
		// Formato: for=192.0.2.60;proto=http;by=203.0.113.43
		const forMatch = forwarded.match(/for=([^;,\s]+)/i);
		if (forMatch && forMatch[1]) {
			const ip = forMatch[1].replace(/^\[|\]$/g, ''); // Remove brackets de IPv6
			if (isValidIP(ip)) {
				console.log('IP encontrado em Forwarded:', ip);
				return ip;
			}
		}
	}

	// Outros headers com IP único
	if (realIP && isValidIP(realIP)) {
		console.log('IP encontrado em X-Real-IP:', realIP);
		return realIP;
	}

	if (cfConnectingIP && isValidIP(cfConnectingIP)) {
		console.log('IP encontrado em CF-Connecting-IP:', cfConnectingIP);
		return cfConnectingIP;
	}

	if (trueClientIP && isValidIP(trueClientIP)) {
		console.log('IP encontrado em True-Client-IP:', trueClientIP);
		return trueClientIP;
	}

	if (xClientIP && isValidIP(xClientIP)) {
		console.log('IP encontrado em X-Client-IP:', xClientIP);
		return xClientIP;
	}

	if (remoteAddr && isValidIP(remoteAddr)) {
		console.log('IP encontrado em Remote-Addr:', remoteAddr);
		return remoteAddr;
	}

	// Tentar extrair do URL (último recurso)
	try {
		const url = new URL(request.url);
		// Se o servidor estiver configurado para passar IP via query param
		const ipFromQuery = url.searchParams.get('ip');
		if (ipFromQuery && isValidIP(ipFromQuery)) {
			console.log('IP encontrado em query param:', ipFromQuery);
			return ipFromQuery;
		}
	} catch {
		// Ignorar erro de parsing do URL
	}

	console.log('Nenhum IP válido encontrado nos headers');
	return undefined;
}

/**
 * Valida se uma string é um endereço IP válido (IPv4 ou IPv6)
 */
function isValidIP(ip: string): boolean {
	if (!ip || ip.length === 0) {
		return false;
	}

	// Validar IPv4
	const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
	if (ipv4Regex.test(ip)) {
		const parts = ip.split('.');
		return parts.every((part) => {
			const num = parseInt(part, 10);
			return num >= 0 && num <= 255;
		});
	}

	// Validar IPv6 (formato simplificado)
	const ipv6Regex = /^([0-9a-fA-F]{0,4}:){2,7}[0-9a-fA-F]{0,4}$/;
	if (ipv6Regex.test(ip)) {
		return true;
	}

	// Validar IPv6 comprimido (com ::)
	const ipv6CompressedRegex = /^([0-9a-fA-F]{0,4}:)*::([0-9a-fA-F]{0,4}:)*[0-9a-fA-F]{0,4}$/;
	if (ipv6CompressedRegex.test(ip)) {
		return true;
	}

	return false;
}