#include "../lib/InetAddress.hpp"
#include <cassert>
#include <iostream>
#include <unordered_set>

void test_ipv4_construction()
{
	std::cout << "Testing IPv4 address construction...\n";

	reactor::InetAddress addr1(8080);
	assert(addr1.port() == 8080);
	assert(!addr1.isIpV6());
	assert(addr1.toIp() == "0.0.0.0");

	reactor::InetAddress addr2(9000, false, true);
	assert(addr2.port() == 9000);
	assert(addr2.toIp() == "127.0.0.1");

	reactor::InetAddress addr3("192.168.1.100", 3000);
	assert(addr3.port() == 3000);
	assert(addr3.toIp() == "192.168.1.100");

	std::cout << "✓ IPv4 construction passed\n";
}

void test_ipv6_construction()
{
	std::cout << "Testing IPv6 address construction...\n";

	reactor::InetAddress addr1(8080, true);
	assert(addr1.port() == 8080);
	assert(addr1.isIpV6());
	assert(addr1.toIp() == "::");

	reactor::InetAddress addr2(9000, true, true);
	assert(addr2.port() == 9000);
	assert(addr2.toIp() == "::1");

	reactor::InetAddress addr3("::1", 3000);
	assert(addr3.port() == 3000);
	assert(addr3.toIp() == "::1");
	assert(addr3.isIpV6());

	std::cout << "✓ IPv6 construction passed\n";
}

void test_address_comparison()
{
	std::cout << "Testing address comparison...\n";

	reactor::InetAddress addr1("127.0.0.1", 8080);
	reactor::InetAddress addr2("127.0.0.1", 8080);
	reactor::InetAddress addr3("127.0.0.1", 9000);
	reactor::InetAddress addr4("192.168.1.1", 8080);

	assert(addr1 == addr2);
	assert(addr1 != addr3);
	assert(addr1 != addr4);

	reactor::InetAddress addr5("::1", 8080);
	reactor::InetAddress addr6("::1", 8080);
	assert(addr5 == addr6);
	assert(addr1 != addr5);

	std::cout << "✓ Address comparison passed\n";
}

void test_address_ordering()
{
	std::cout << "Testing address ordering...\n";

	reactor::InetAddress addr1("127.0.0.1", 8080);
	reactor::InetAddress addr2("127.0.0.1", 9000);
	reactor::InetAddress addr3("192.168.1.1", 8080);
	reactor::InetAddress addr4("::1", 8080);

	// Use asserts for proper testing
	assert(addr1 < addr2);
	assert(addr1 < addr3);
	assert(addr1 < addr4); // IPv4 is less than IPv6 in this implementation

	std::cout << "✓ Address ordering passed\n";
}

void test_string_conversion()
{
	std::cout << "Testing string conversion...\n";

	reactor::InetAddress addr1("192.168.1.100", 8080);
	assert(addr1.toIpPort() == "192.168.1.100:8080");

	reactor::InetAddress addr2("::1", 8080);
	assert(addr2.toIpPort() == "[::1]:8080");

	assert(addr1.familyToString() == "IPv4");
	assert(addr2.familyToString() == "IPv6");

	std::cout << "✓ String conversion passed\n";
}

void test_socket_address_conversion()
{
	std::cout << "Testing socket address conversion...\n";

	reactor::InetAddress addr("127.0.0.1", 8080);
	const sockaddr* sa = addr.getSockAddr();
	socklen_t len = addr.getSockLen();

	assert(sa != nullptr);
	assert(len == sizeof(sockaddr_in));

	const sockaddr_in* sa4 = reinterpret_cast<const sockaddr_in*>(sa);
	assert(sa4->sin_family == AF_INET);
	assert(ntohs(sa4->sin_port) == 8080);

	std::cout << "✓ Socket address conversion passed\n";
}

void test_hash_functionality()
{
	std::cout << "Testing hash functionality...\n";

	std::unordered_set<reactor::InetAddress> addr_set;

	addr_set.insert(reactor::InetAddress("127.0.0.1", 8080));
	addr_set.insert(reactor::InetAddress("127.0.0.1", 9000));
	addr_set.insert(reactor::InetAddress("192.168.1.1", 8080));
	addr_set.insert(reactor::InetAddress("::1", 8080));

	assert(addr_set.size() == 4);

	addr_set.insert(reactor::InetAddress("127.0.0.1", 8080));
	assert(addr_set.size() == 4);

	std::cout << "✓ Hash functionality passed\n";
}

void test_hostname_resolution()
{
	std::cout << "Testing hostname resolution...\n";

	reactor::InetAddress result;
	bool success = reactor::InetAddress::resolve("localhost", result);

	if (success) {
		std::cout << "Resolved localhost to: " << result.toIpPort() << "\n";
		assert(result.toIp() == "127.0.0.1");
	}

	bool failed = reactor::InetAddress::resolve("invalid.hostname.test", result);
	assert(!failed);

	std::cout << "✓ Hostname resolution passed\n";
}

void test_edge_cases()
{
	std::cout << "Testing edge cases...\n";

	reactor::InetAddress addr1(0);
	assert(addr1.port() == 0);

	reactor::InetAddress addr2(65535);
	assert(addr2.port() == 65535);

	reactor::InetAddress addr3("0.0.0.0", 0);
	assert(addr3.toIp() == "0.0.0.0");
	assert(addr3.port() == 0);

	std::cout << "✓ Edge cases passed\n";
}

int main()
{
	std::cout << "=== InetAddress Tests ===\n";

	test_ipv4_construction();
	test_ipv6_construction();
	test_address_comparison();
	test_address_ordering();
	test_string_conversion();
	test_socket_address_conversion();
	test_hash_functionality();
	test_hostname_resolution();
	test_edge_cases();

	std::cout << "All InetAddress tests passed! ✓\n";
	return 0;
}