#include "dns.h"

/**
 * Resolves a domainname to an ip address
 * It makes use of net_gethostbyname from libogc, which in turn makes use of a Wii BIOS function
 * Just like the net_gethostbyname function this function is NOT threadsafe!
 *
 * @param char* The domain name to resolve
 * @return u32 The ipaddress represented by four bytes inside an u32 (in network order)
 */
u32 getipbyname(char *domain)
{
	//Care should be taken when using net_gethostbyname,
	//it returns a static buffer which makes it not threadsafe
	//TODO: implement some locking mechanism to make below code atomic
	struct hostent *host = net_gethostbyname(domain);

	if (host == NULL)
	{
		return 0;
	}

	u32 *ip = (u32*) host->h_addr_list[0];
	return *ip;
}

//Defines how many DNS entries should be cached by getipbynamecached()
#define MAX_DNS_CACHE_ENTRIES 20

//The cache is defined as a linked list,
//The last resolved domain name will always be at the front
//This will allow heavily used domainnames to always stay cached
struct dnsentry
{
	char *domain;
	u32 ip;
	struct dnsentry *nextnode;
};

static struct dnsentry *firstdnsentry = NULL;
static int dnsentrycount = 0;

/**
 * Performs the same function as getipbyname(),
 * except that it will prevent extremely expensive net_gethostbyname() calls by caching the result
 */
u32 getipbynamecached(char *domain)
{
	//Search if this domainname is already cached
	struct dnsentry *node = firstdnsentry;
	struct dnsentry *previousnode = NULL;

	while (node != NULL)
	{
		if (strcmp(node->domain, domain) == 0)
		{
			//DNS node found in the cache, move it to the front of the list
			if (previousnode != NULL) previousnode->nextnode = node->nextnode;

			if (node != firstdnsentry) node->nextnode = firstdnsentry;
			firstdnsentry = node;

			return node->ip;
		}
		//Go to the next element in the list
		previousnode = node;
		node = node->nextnode;
	}
	u32 ip = getipbyname(domain);

	//No cache of this domain could be found, create a cache node and add it to the front of the cache
	struct dnsentry *newnode = malloc(sizeof(struct dnsentry));
	if (newnode == NULL)
	{
		return ip;
	}

	newnode->ip = ip;
	newnode->domain = malloc(strlen(domain) + 1);
	if (newnode->domain == NULL)
	{
		free(newnode);
		return ip;
	}
	strcpy(newnode->domain, domain);

	newnode->nextnode = firstdnsentry;
	firstdnsentry = newnode;
	dnsentrycount++;

	//If the cache grows too big delete the last (and probably least important) node of the list
	if (dnsentrycount > MAX_DNS_CACHE_ENTRIES)
	{
		struct dnsentry *node = firstdnsentry;
		struct dnsentry *previousnode = NULL;

		//Fetch the last two elements of the list
		while (node->nextnode != NULL)
		{
			previousnode = node;
			node = node->nextnode;
		}

		if (node == NULL)
		{
			printf("Configuration error, MAX_DNS_ENTRIES reached while the list is empty\n");
			exit(1);
		}
		else if (previousnode == NULL)
		{
			firstdnsentry = NULL;
		}
		else
		{
			previousnode->nextnode = NULL;
		}

		free(node->domain);
		free(node);
		dnsentrycount--;
	}

	return newnode->ip;
}