/**
 * @file network_id.c
 * @date 16 Sep 2014
 * @brief File containing network interface detection functions for Windows.
 *
 * The only public function of this module is #getAdapterInfos(OsAdapterInfo *,
 *		size_t *), other functions are either static or inline.
 *
 * Responsibility of this module is to fill OsAdapterInfo structures, in a predictable way (skip loopback/vpn interfaces)
 */

#define _CRTDBG_MAP_ALLOC
#define NOMINMAX

#ifdef _MSC_VER
#include <Windows.h>
#endif
#include <iphlpapi.h>
#include <unordered_map>
#include <stdio.h>
#include <algorithm>
#include <cctype>
#pragma comment(lib, "IPHLPAPI.lib")

#include "../../base/string_utils.h"
#include "../../base/logger.h"
#include "../network.hpp"

#define MALLOC(x) HeapAlloc(GetProcessHeap(), 0, (x))
#define FREE(x) HeapFree(GetProcessHeap(), 0, (x))

namespace license {
namespace os {
using namespace std;

static int translate(const char ipStringIn[16], unsigned char ipv4[4]) {
	size_t index = 0;

	const char *str2 = ipStringIn; /* save the pointer */
	while (*str2) {
		if (isdigit((unsigned char)*str2)) {
			ipv4[index] *= 10;
			ipv4[index] += *str2 - '0';
		} else {
			index++;
		}
		str2++;
	}
	return 0;
}

int score(const OsAdapterInfo &a) {
	int score = 0;
	bool allzero = true;
	const char *bads[] = {"virtual", "ppp", "tunnel", "vpn"};
	const char *goods[] = {"realtek", "intel", "wireless"};

	for (int i = 0; i < sizeof(a.description) && allzero; i++) {
		allzero = allzero && (a.description[i] == 0);
	}
	if (!allzero) {
		score++;
	}

	string descr=string(a.description);
	std::transform(descr.begin(), descr.end(), descr.begin(), [](unsigned char c) { return std::tolower(c); });
	for (auto bad: bads) {
		score += descr.find(bad) == std::string::npos ? 1 : -1;
	}
	for (auto good : goods) {
		score += descr.find(good) == std::string::npos ? -1 : 1;
	}
	return score;
}

bool cmp(const OsAdapterInfo &a, const OsAdapterInfo &b) { return score(a) > score(b); }
	/**
 *
 * @param adapterInfos
 * @param adapter_info_size
 * @return
 */
FUNCTION_RETURN getAdapterInfos(vector<OsAdapterInfo> &adapterInfos) {
	vector<OsAdapterInfo> tmpAdapters;
	FUNCTION_RETURN f_return = FUNC_RET_OK;
	DWORD dwStatus;

	ULONG ulOutBufLen = sizeof(IP_ADAPTER_INFO) *10;
	IP_ADAPTER_INFO *pAdapterInfo = (IP_ADAPTER_INFO *)MALLOC(sizeof(IP_ADAPTER_INFO) * 10);

	if (pAdapterInfo == nullptr) {
		return FUNC_RET_ERROR;
	}

	dwStatus = GetAdaptersInfo(
		pAdapterInfo,  // [out] buffer to receive data
		&ulOutBufLen  // [in] size of receive data buffer
	);

	// Incase the buffer was too small, reallocate with the returned dwBufLen
	if (dwStatus == ERROR_BUFFER_OVERFLOW) {
		FREE(pAdapterInfo);
		pAdapterInfo = (IP_ADAPTER_INFO *)MALLOC(ulOutBufLen);

		// Will only fail if buffer cannot be allocated (out of memory)
		if (pAdapterInfo == nullptr) {
			return FUNC_RET_BUFFER_TOO_SMALL;
		}

		dwStatus = GetAdaptersInfo(	 // Call GetAdapterInfo
			pAdapterInfo,  // [out] buffer to receive data
			&ulOutBufLen  // [in] size of receive data buffer
		);

		switch (dwStatus) {
			case NO_ERROR:
				break;

			case ERROR_BUFFER_OVERFLOW:
				FREE(pAdapterInfo);
				return FUNC_RET_BUFFER_TOO_SMALL;

			default:
				FREE(pAdapterInfo);
				return FUNC_RET_ERROR;
		}
	}

	IP_ADAPTER_INFO* pAdapter = pAdapterInfo;
	while (pAdapter) {
		if (pAdapter->Type == MIB_IF_TYPE_ETHERNET) {
			OsAdapterInfo ai = {};
			LOG_DEBUG("Ethernet found %s, %s, mac_l: %d", pAdapter->AdapterName, pAdapter->Description, pAdapter->AddressLength);
			if (pAdapter->AddressLength > 0) {
				bool allzero = true;
				const size_t size_to_be_copied = std::min(sizeof(ai.mac_address), (size_t)pAdapter->AddressLength);
				for (int i = 0; i < size_to_be_copied && allzero; i++) {
					allzero = allzero && (pAdapter->Address[i] == 0);
				}
				if (!allzero) {
					strncpy(ai.description, pAdapter->Description,
						min(sizeof(ai.description) - 1, (size_t)MAX_ADAPTER_DESCRIPTION_LENGTH));
					memcpy(ai.mac_address, pAdapter->Address, size_to_be_copied);
					translate(pAdapter->IpAddressList.IpAddress.String, ai.ipv4_address);
					ai.type = IFACE_TYPE_ETHERNET;
					tmpAdapters.push_back(ai);
				}
			}
		}
		pAdapter = pAdapter->Next;
	}
	if (pAdapterInfo!=nullptr) {
		FREE(pAdapterInfo);
	}

	if (tmpAdapters.size() == 0) {
		f_return = FUNC_RET_NOT_AVAIL;
	} else {
		std::sort(tmpAdapters.begin(), tmpAdapters.end(), cmp);
		adapterInfos = std::move(tmpAdapters);
	}
	return f_return;
}

}  // namespace os
}  // namespace license