/*
 * Copyright 2006-2015, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Axel Dörfler, axeld@pinc-software.de
 *		Oliver Tappe, zooey@hirschkaefer.de
 *		Atis Elsts, the.kfx@gmail.com
 */


#include "MediaTypes.h"

#include <stdint.h>
#include <string.h>

extern "C" {
#	include <freebsd_network/compat/net/if_media.h>
}


struct media_type {
	int			type;
	const char*	name;
	const char* pretty;
	int 		subtype_mask;
	struct {
		int subtype;
		const char* name;
		const char* pretty;
	} subtypes [10];
	struct {
		int option;
		bool read_only;
		const char* name;
		const char* pretty;
	} options [6];
};


const media_type kMediaTypes[] = {
	{
		IFM_ETHER,
		"ether",
		"Ethernet",
		IFM_TMASK,
		{
			//{ IFM_AUTO, "auto", "Auto-select" },
			//{ IFM_AUI, "AUI", "10 MBit, AUI" },
			//{ IFM_10_2, "10base2", "10 MBit, 10BASE-2" },
			{ IFM_10_T, "10baseT", "10 MBit, 10BASE-T" },
			{ IFM_100_TX, "100baseTX", "100 MBit, 100BASE-TX" },
			{ IFM_1000_T, "1000baseT", "1 GBit, 1000BASE-T" },
			{ IFM_1000_SX, "1000baseSX", "1 GBit, 1000BASE-SX" },
			{ IFM_10G_T, "10GbaseT", "10 GBit, 10GBASE-T" },
			{ IFM_10G_SR, "10GbaseSR", "10 Gbit, 850 nm Fibre"},
			{ IFM_10G_LR, "10GbaseLR", "10 Gbit, 1310 nm Fibre"},
			{ IFM_10G_LRM, "10GbaseLRM", "10 Gbit, 1300 nm Fibre"},
			{ IFM_10G_TWINAX, "10GbaseCR", "10 Gbit, Direct Attach"},
			{ -1, NULL, NULL }
		},
		{
			{ -1, false, NULL, NULL }
		}
	},
	{
		IFM_IEEE80211,
		"80211",
		"Wireless Ethernet",
		IFM_MMASK,
		{
			{ IFM_IEEE80211_11A, "802.11a", "802.11a" },
			{ IFM_IEEE80211_11B, "802.11b", "802.11b" },
			{ IFM_IEEE80211_11G, "802.11g", "802.11g" },
			{ IFM_IEEE80211_FH, "802.11 FH", "802.11 FH" },
			{ IFM_IEEE80211_11NA, "802.11n(a)", "802.11n(a)" },
			{ IFM_IEEE80211_11NG, "802.11n(g)", "802.11n(g)" },
			{ IFM_IEEE80211_VHT5G, "802.11ac", "802.11ac" },
			{ -1, NULL, NULL }
		},
		{
			{ -1, false, NULL, NULL }
		}
	},
	{
		0, // for generic options
		"all",
		"All",
		IFM_TMASK,
		{
			{ IFM_AUTO, "auto", "Auto-select" },
			{ -1, NULL, NULL }
		},
		{
			{ IFM_FDX, true, "fullduplex", "Full Duplex" },
			{ IFM_HDX, true, "halfduplex", "Half Duplex" },
			{ IFM_LOOP, true, "loop", "Loop" },
			//{ IFM_ACTIVE, false, "active", "Active" },
			{ -1, false, NULL, NULL }
		}
	},
	{ -1, NULL, NULL, -1, {{ -1, NULL, NULL }}, {{ -1, false, NULL, NULL }} }
};


const char*
get_media_type_name(size_t index)
{
	if (index < sizeof(kMediaTypes) / sizeof(kMediaTypes[0]))
		return kMediaTypes[index].pretty;

	return NULL;
}


const char*
get_media_subtype_name(size_t typeIndex, size_t subIndex)
{
	if (typeIndex < sizeof(kMediaTypes) / sizeof(kMediaTypes[0])) {
		if (kMediaTypes[typeIndex].subtypes[subIndex].subtype >= 0)
			return kMediaTypes[typeIndex].subtypes[subIndex].name;
	}

	return NULL;
}


bool
media_parse_subtype(const char* string, int media, int* type)
{
	for (size_t i = 0; kMediaTypes[i].type >= 0; i++) {
		// only check for generic or correct subtypes
		if (kMediaTypes[i].type &&
			kMediaTypes[i].type != media)
			continue;
		for (size_t j = 0; kMediaTypes[i].subtypes[j].subtype >= 0; j++) {
			if (strcmp(kMediaTypes[i].subtypes[j].name, string) == 0) {
				// found a match
				*type = kMediaTypes[i].subtypes[j].subtype;
				return true;
			}
		}
	}
	return false;
}


const char*
media_type_to_string(int media)
{
	for (size_t i = 0; kMediaTypes[i].type >= 0; i++) {
		// loopback doesn't really have a media anyway
		if (IFM_TYPE(media) == 0)
			break;

		// only check for generic or correct subtypes
		if (kMediaTypes[i].type
			&& kMediaTypes[i].type != IFM_TYPE(media))
			continue;

		const int subtype = (media & kMediaTypes[i].subtype_mask);
		for (size_t j = 0; kMediaTypes[i].subtypes[j].subtype >= 0; j++) {
			if (kMediaTypes[i].subtypes[j].subtype == subtype) {
				// found a match
				return kMediaTypes[i].subtypes[j].pretty;
			}
		}
	}

	return NULL;
}