#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <netdb.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <netinet/in.h>

#include <mellanox/vma_extra.h>

#include "types.h"

#define BUFFER_SIZE	1024

#define TIMEOUT	5

extern struct config_t		config;

typedef vma_recv_callback_retval_t (*vma_recv_callback_t)(int fd, size_t sz_iov, struct iovec iov[],

                                                          struct vma_info_t* vma_info, void *context);

vma_recv_callback_retval_t myapp_vma_recv_pkt_notify_callback(

                                                              int fd,

                                                              size_t iov_sz,

                                                              struct iovec iov[],

                                                              struct vma_info_t* vma_info,

                                                              void *context);

void free_packet(void* packet_id, int fd);

int server_management(int *mangSocket);

int get_sock_fd(int *sock, int mangSock);

int receive_data(int *sock, int mangSock);

struct vma_api_t *vma_api = NULL;

int server_main(){

	int		sock	= INVALID_SOCKET;

	int		mangSock	= INVALID_SOCKET;

	int		result	= -1;

	int		rc;

	struct 	timeval timeout;

	struct 	pending_packet_t pending_packet;

	printf("Enter Function server_main\n");

	if (config.callbackReturn == HOLD) {	

		pending_packet.valid = 0;

	}

	rc =  server_management(&mangSock);

    CHECK_VALUE("server_management", rc, 0, goto cleanup);

	rc = get_sock_fd(&sock, mangSock);

	CHECK_VALUE("get_sock_fd", rc, 0, goto cleanup);

	if(config.nonBlocking){

	  	rc = make_socket_non_blocking(sock);

		CHECK_VALUE("make_socket_non_blocking", rc, 0, goto cleanup);

	}

	else {

		timeout.tv_sec = TIMEOUT;

		timeout.tv_usec = 0;

		rc = setsockopt (sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout,

				 sizeof(timeout));

		CHECK_VALUE("setsockopt", rc, 0, goto cleanup);

	}

	vma_api = vma_get_api();

	CHECK_NOT_EQUAL("vma_get_api", vma_api, NULL, goto cleanup);

	printf("Server gets VMA APIs\n");

	rc = vma_api->register_recv_callback(sock, myapp_vma_recv_pkt_notify_callback, &pending_packet);

	CHECK_VALUE("register_recv_callback", rc, 0, goto cleanup);

	printf("Callback function registered with VMA\n");

	rc = receive_data(&sock, mangSock);

	CHECK_VALUE("receive_data", rc, 0, goto cleanup);

	if (config.callbackReturn == HOLD) {

		CHECK_VALUE("pending_packet.valid", pending_packet.valid, 1, goto cleanup);

		free_packet(pending_packet.vma_info->packet_id, sock);

		free(pending_packet.vma_info);

	}

	/* sync for termination */

	rc = sync_side(mangSock, 1);

	CHECK_VALUE("sync_side", rc, 0, goto cleanup);

	result = 0;

 cleanup:

  	if(sock != INVALID_SOCKET){

		rc = close(sock);

		CHECK_VALUE("close", rc, 0, result = -1);

	}

	if(mangSock != INVALID_SOCKET) {

		rc = close(mangSock);

		CHECK_VALUE("close", rc, 0, result = -1);

	}

	return result;

}

void myapp_processes_packet_func(

                            struct iovec* iov,

                            size_t iov_sz,

                            void* packet_id,

                            int s){

  printf("Enter Function myapp_processes_packet_func\n");

  /*myapp_processes_packet_func(.....);*/

  /* Return zero copied packet buffer back to VMA

  // Would be better to collect a bunch of buffers and return them all at once

  // which will save locks inside VMA

  */

	free_packet(packet_id, s);

}

/**

 * Free VMA buffer reserved for given packet

 * Params:

 *		*packet_id	: ID of packet to remove

 *		fd			: File descriptor for socket.

 **/

void free_packet(void* packet_id, int fd){

  struct vma_packet_t* vma_packet;

  vma_packet = malloc(sizeof(vma_packet->packet_id));

  vma_packet->packet_id = packet_id;

  vma_api->free_packets(fd, vma_packet, 1);

  free(vma_packet);

}

vma_recv_callback_retval_t myapp_vma_recv_pkt_notify_callback(

                                                              int fd,

                                                              size_t iov_sz,

                                                              struct iovec iov[],

                                                              struct vma_info_t* vma_info,

                                                              void *context)

{

	struct pending_packet_t *p_pending_packet;

	printf("Enter Function myapp_vma_recv_pkt_notify_callback\n");

	if (strcmp(iov[0].iov_base, "recv") == 0) {

		printf("VMA's info struct is not something we recognize so un register the application's callback function\n");

		printf("VMA extra API filtered to VMA_PACKET_RECV\n");

		return VMA_PACKET_RECV;

	}

	if (strcmp(iov[0].iov_base, "drop") == 0){

		printf("VMA extra API filtered to VMA_PACKET_DROP\n");

		return VMA_PACKET_DROP;

	}

	if (strcmp(iov[0].iov_base, "hold") == 0){

		printf("VMA extra API filtered to VMA_PACKET_HOLD\n");

		/* In hold case we check pending_packet,free its holding buffer if its valid and then fill it with new packet data,

		   so each packet will be freed in the next callback */

		p_pending_packet = (struct pending_packet_t *)context;

		if (p_pending_packet->valid)

			myapp_processes_packet_func(p_pending_packet->iov, p_pending_packet->iovec_size, p_pending_packet->vma_info->packet_id, fd);

		memcpy(p_pending_packet->iov, iov, sizeof(struct iovec)*iov_sz);

		p_pending_packet->iovec_size = iov_sz;

		p_pending_packet->vma_info = malloc(sizeof(struct vma_info_t));

		memcpy (p_pending_packet->vma_info, vma_info, sizeof(struct vma_info_t));

		p_pending_packet->valid = 1;

		return VMA_PACKET_HOLD;

	}

	printf("VMA extra API filtered to VMA_PACKET_RECV\n");

	return VMA_PACKET_RECV;

}

int server_management(

                      int            *mangSocket){

	int                     rc;

	int                     result          = -1;

	int                     on              = 1;

	int                     mainSocket      = INVALID_SOCKET;

	socklen_t               clilen;

	struct sockaddr_in      servAddr;

	struct sockaddr_in      cliAddr;

	printf("Enter Function server_management\n");

	mainSocket = socket(AF_INET, SOCK_STREAM, 0);

	CHECK_NOT_EQUAL("socket", mainSocket, INVALID_SOCKET, goto cleanup);

	bzero((char *) &servAddr, sizeof(servAddr));

	servAddr.sin_family = AF_INET;

	servAddr.sin_addr.s_addr = inet_addr(config.mngip);

	servAddr.sin_port = htons(config.port + 15);

	rc = setsockopt(mainSocket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

	CHECK_VALUE("setsockopt", rc, 0, goto cleanup);

	rc = bind(mainSocket, (struct sockaddr *) &servAddr, sizeof(servAddr));

	CHECK_VALUE("bind", rc, 0, goto cleanup);

	listen(mainSocket,1);

	CHECK_VALUE("listen", rc, 0, goto cleanup);

	clilen = sizeof(cliAddr);

	*mangSocket = accept(mainSocket, (struct sockaddr *) &cliAddr, &clilen);

	CHECK_NOT_EQUAL("accept", *mangSocket, INVALID_SOCKET, goto cleanup);

	printf("server Accepting new client\n");

	result = 0;

 cleanup:

	return result;

}

/**

 *Generate TCP socket, bind it to specific address, listen and accept new connection.

 *

 * Params:

 *		*sock	: File descriptor represent generated socket

 *		mangSock	: File descriptor used for management

 * Returns:

 *		These calls return 0, or -1 if an error occurred.

 **/

int get_sock_fd(int *sock, int mangSock){

	int		rc;

	int		on		= 1;

	int		result	= -1;

	int		mainSocket	= INVALID_SOCKET;

	struct 	sockaddr_in	sAddr;

	struct		sockaddr_in	cliAddr;

	socklen_t	clilen;

	printf("Enter Function get_sock_fd\n");

	memset(&sAddr, 0, sizeof(sAddr)); 

	mainSocket = socket(AF_INET, SOCK_STREAM, 0);

	CHECK_NOT_EQUAL("socket", mainSocket, INVALID_SOCKET, goto cleanup);

	/* Set server Address */

	sAddr.sin_family		= AF_INET;

	sAddr.sin_port			= htons(config.port);

	sAddr.sin_addr.s_addr	= inet_addr(config.sip);

	if(config.reuseAddr){

		rc = setsockopt(mainSocket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

		CHECK_VALUE("setsockopt", rc, 0, goto cleanup);

	}

	/* Bind socket to server address */

	rc = bind(mainSocket, (struct sockaddr *) &sAddr, sizeof(sAddr));

	CHECK_VALUE("bind", rc, 0, goto cleanup);

	memset(&cliAddr, 0, sizeof(cliAddr));

	rc = listen(mainSocket, 1);

	CHECK_VALUE("listen", rc, 0, goto cleanup);

	/* sync to connect from other side */

	rc = sync_side(mangSock, 1);

	CHECK_VALUE("sync_side", rc, 0, goto cleanup);

	clilen = sizeof(cliAddr);

	*sock = accept(mainSocket, (struct sockaddr *) &cliAddr, &clilen);

	CHECK_NOT_EQUAL("accept", *sock, INVALID_SOCKET, goto cleanup);

	printf("server Accepting new client\n");

	result = 0;

cleanup:

	return result;

}

/**

 *Receive data from given TCP socket fd.

 *

 * Params:

 *		*sock	: File descriptor represent test socket

 *		mangSock	: File descriptor used for management

 * Returns:

 *		These calls return 0, or -1 if an error occurred.

 **/

int receive_data(int *sock, int mangSock){

	int	result	= -1;

	int	rc;

	void* recv_data;

	printf("Enter Function receive_data\n");

	recv_data = malloc(sizeof(char) * BUFFER_SIZE);

	CHECK_NOT_EQUAL("malloc", recv_data, NULL, goto cleanup);

	rc = sync_side(mangSock, 1);

	CHECK_VALUE("sync_side", rc, 0, goto cleanup);

	if(config.nonBlocking){

		rc = select_read(sock, TIMEOUT, 0);

		if (config.callbackReturn == DROP) {

			CHECK_VALUE("select_read", rc, 0, goto cleanup);

		}	

		else {

			CHECK_NOT_EQUAL("select_read", rc, 0, goto cleanup);

			CHECK_NOT_EQUAL("select_read", rc, -1, goto cleanup);

		}

	}

	rc = recv(*sock, recv_data, BUFFER_SIZE, 0);

	if (config.callbackReturn == RECV) {

		CHECK_NOT_EQUAL("recv", rc, -1, goto cleanup);

		CHECK_NOT_EQUAL("recv", rc, 0, goto cleanup);

	}

	else {

		CHECK_VALUE("recv", rc, -1, goto cleanup);

		CHECK_VALUE("recv", errno, EAGAIN, goto cleanup);

	}

	result = 0;

cleanup:

	if (recv_data)

		free(recv_data);

	return result;

}