#include <rte_mbuf.h>
#include <rte_malloc.h>

#include <mrapp.h>
#include <mr_vnode.h>
#include <mr_stat.h>
#include <mr_rtdev.h>
#include <mr_runtime.h>
#include <mr_device.h>

#include <marsio.h>

extern struct mrapp_instance * instance;
extern int __option_set_raw_device(struct mrapp_config * config, const char * devsym);
extern int __option_set_stack_device(struct mrapp_config * config, const char * devsym);

// 打开的Socket记录表增删查操作。将已经打开的Socket记录下来，避免用户重复打开造成错误。
int raw_socket_close(struct raw_socket * socket)
{
	struct raw_socket * _socket = (struct raw_socket *)socket;
	mr_rt_device_close(_socket->rtdev_desc);
	return 0;
}

struct raw_socket * raw_socket_open(const char * devsym, 
	unsigned int nr_rx_stream, unsigned int nr_tx_stream, unsigned int flags)
{
	struct mr_global_ctx * g_ctx = mr_global_ctx_get();
	struct raw_socket * socket = rte_zmalloc(NULL, sizeof(struct raw_socket), 0);
	if(unlikely(socket == NULL))
	{
		MR_LOG(ERR, MRLIB, "Cannot alloc memory for RawSocket"
			"(devsym=%s, nr_rx_stream=%d, nr_tx_stream=%d, flags=%x)\n",
			devsym, nr_rx_stream, nr_tx_stream, flags);
		goto errout;
	}

	snprintf(socket->devsym, sizeof(socket->devsym), "%s", devsym);
	socket->nr_rxstream = nr_rx_stream;
	socket->nr_txstream = nr_tx_stream;

	// 打开运行时设备
	struct rtdev_app_desc * _rtdev_desc = NULL;
	_rtdev_desc = mr_rt_device_open(g_ctx->ctx_core, devsym, instance->appsym,
		nr_rx_stream, nr_tx_stream);
	
	if(unlikely(_rtdev_desc == NULL))
	{
		MR_LOG(ERR, MRLIB, "MarsioRawSocket: Open rt-device %s"
			"(nr_rx_stream=%d, nr_tx_stream=%d, flags=%x) failed. \n",
			devsym, nr_rx_stream, nr_tx_stream, flags);
		goto errout;
	}

	socket->rtdev_desc = _rtdev_desc;
	return socket;

errout:
	if (socket != NULL) rte_free(socket);
	return NULL;
}

static int __set_all_raw_device_open(struct mrapp_instance * instance, 
	struct mrapp_config * config)
{
	struct mr_dev * dev_list[MR_DEVICE_MAX];
	int nr_dev_list = 0;

	// 获得当前启用的所有物理设备
	nr_dev_list = mr_device_list(instance->core_instance, dev_list, MR_DEVICE_MAX, 0);
	if (nr_dev_list < 0) return nr_dev_list;

	// 启用所有的物理设备
	for(int i = 0; i < nr_dev_list; i++)
		__option_set_raw_device(config, dev_list[i]->symbol);
	
	return 0;
}

int mrapp_init_open_raw_device(struct mrapp_instance * instance)
{
	struct mrapp_config * config = &instance->config;

	// 没有设置启用的设备，应当使用全部设备
	if (config->nr_raw_device == 0)
		__set_all_raw_device_open(instance, config);

	for(int i = 0; i < config->nr_raw_device; i++)
	{
		struct __devinfo * devinfo = &config->raw_open_device[i];
		struct raw_socket * socket = raw_socket_open(devinfo->devsym,
			config->nr_raw_rxstream, config->nr_raw_txstream, 0);

		if(socket == NULL)
		{
			MR_LOG(INFO, MRLIB, "Raw device %s(device_id=%d) open failed. \n",
				devinfo->devsym, devinfo->dev_id);
			continue;
		}
	
		instance->raw_socket[devinfo->dev_id] = socket;
		MR_LOG(INFO, MRLIB, "Raw device %s(device_id=%d) open successfully. \n",
			devinfo->devsym, devinfo->dev_id);
	}
	
	return 0;
}


void mrapp_destory_close_raw_device(struct mrapp_instance * instance)
{
	for(int i = 0; i < MR_DEVICE_MAX; i++)
	{
		if (instance->raw_socket[i] == NULL) continue;
		raw_socket_close(instance->raw_socket[i]);
	}

	return;
}

int marsio_raw_recv_burst(device_id_t dev_id, thread_id_t sid,
	marsio_buff_t * mbufs[], int nr_max_mbufs)
{
	struct raw_socket * _socket = instance->raw_socket[dev_id];
	if (unlikely(_socket == NULL))
	{
		MR_LOG(DEBUG, MRLIB, "%s: Invalid Parameters - dev_id=%d is invalid.\n",
			__FUNCTION__, dev_id);	return -EINVAL;
	}
	
	if (unlikely(sid >= _socket->nr_rxstream))
	{
		MR_LOG(DEBUG, MRLIB, "%s: Invalid Parameters - sid=%d is invalid.\n",
			__FUNCTION__, sid);	return -EINVAL;
	}
		
	mr_thread_hook();

	int ret = vnode_dequeue_burst(_socket->rtdev_desc->vnode_cons_rx,
		&_socket->rtdev_desc->ops, sid, (void **)mbufs, nr_max_mbufs);
	return ret;
}

static inline hash_t __raw_send_pkt_hash(struct rte_mbuf * mbuf)
{
	return mbuf->hash.rss;
}

int marsio_raw_send_burst(device_id_t dev_id, thread_id_t sid,
	marsio_buff_t * mbufs[], int nr_mbufs)
{
	struct raw_socket * _socket = instance->raw_socket[dev_id];
	if (unlikely(_socket == NULL))
	{
		MR_LOG(DEBUG, MRLIB, "%s: Invalid Parameters - dev_id=%d is invalid.\n",
			__FUNCTION__, dev_id);	return -EINVAL;
	}

	if (unlikely(sid >= _socket->nr_txstream))
	{
		MR_LOG(DEBUG, MRLIB, "%s: Invalid Parameters - sid=%d is invalid.\n",
			__FUNCTION__, dev_id);	return -EINVAL;
	}

	return 0;
}