#include "SimpleUDPPeer.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>

#include <pthread.h>

struct AsyncStub
{
	pthread_t async_recv_thid;
	SimpleUDPPeer& sock;
	SimpleUDPPeer::proc_func_t proc;
	bool running;
	void* args;
    static AsyncStub* m_this;
	
	AsyncStub(SimpleUDPPeer& _sock) : async_recv_thid(0), sock(_sock), proc(nullptr), running(false), args(nullptr)
	{
        m_this = this;
    }
	
	bool start()
	{
		if (async_recv_thid != 0)
			return false;
		
		running = true;
		
		int ret = pthread_create(&async_recv_thid, NULL, async_recv_thd, this);
		if(ret != 0)
			return false;
	}
	
	void stop()
	{
		running = false;
		//#todo join thread
	}
	
	static void* async_recv_thd(void* arg)
	{
		AsyncStub* stub = (AsyncStub*)arg;
		uint8_t* buffer = new uint8_t[stub->sock.cfg.maxBuffSize];
		size_t buffSize = 0;
		
		while (stub->running)
		{
			buffSize = stub->sock.cfg.maxBuffSize;

			bool ret = stub->sock.recv_sync(buffer, buffSize);
			if (ret && stub->proc != nullptr)
				stub->proc(m_this->args, buffer, buffSize);
		}

		delete[] buffer;
		buffer = nullptr;
	}
};

SimpleUDPPeer::SimpleUDPPeer() : cfg(), remote_address(), fd(-1), asyncStub(nullptr)
{
}

SimpleUDPPeer::~SimpleUDPPeer()
{
	//#todo dlete asyncStub
	// close fd
}

void SimpleUDPPeer::set_config(const Config& _cfg)
{
	cfg = _cfg;
}

const SimpleUDPPeer::Config& SimpleUDPPeer::get_config() const
{
}

bool SimpleUDPPeer::init()
{
	if (fd != -1)
		return false;

	memset(&local_address, sizeof(local_address), 0);
	local_address.sin_family = AF_INET;
	if (cfg.local_ip.empty())
		local_address.sin_addr.s_addr = htonl(INADDR_ANY);
	else
		local_address.sin_addr.s_addr = inet_addr(cfg.local_ip.c_str());
	local_address.sin_port = htons(cfg.local_port);

	memset(&remote_address, sizeof(remote_address), 0);
	remote_address.sin_family = AF_INET;
	remote_address.sin_addr.s_addr = inet_addr(cfg.remote_ip.c_str());
	remote_address.sin_port = htons(cfg.remote_port);

	socklen_t sin_len = sizeof(sockaddr_in);

	fd = socket(AF_INET, SOCK_DGRAM, 0);
	if (fd <= 0)
		return false;

	if (cfg.defaultTimeout.tv_sec != 0 || cfg.defaultTimeout.tv_usec != 0)
	{
		int ret = setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (const char *) &(cfg.defaultTimeout), sizeof(timeval));
		if (ret != 0)
			return false;
	}

	int ret = bind(fd, (struct sockaddr *)&local_address, sizeof(local_address));
	if (ret != 0)
		return false;

	return true;
}

void SimpleUDPPeer::teardown()
{
}

bool SimpleUDPPeer::send_sync(const uint8_t* buffer, size_t& buffSize)
{
	if (fd == -1)
		return -1;

	ssize_t ret = sendto(fd, buffer, buffSize, 0, (struct sockaddr *)&remote_address, sizeof(remote_address));
	if (ret <= 0)
	{
		buffSize = 0;
		return false;
	}
	else
	{
		buffSize = ret;
		return true;
	}
}

bool SimpleUDPPeer::recv_sync(uint8_t* buffer, size_t& buffSize)
{
	if (fd == -1)
		return -1;

	ssize_t ret = recv(fd, buffer, buffSize, 0);
	int _errno = errno;
	if(ret <= 0)
	{
		buffSize = 0;
		return false;
	}
	else
	{
		buffSize = ret;
		return true;
	}
}

bool SimpleUDPPeer::recv_async_start(proc_func_t proc, void* args)
{
	if (asyncStub == nullptr)
		asyncStub = new AsyncStub(*this);
	
	asyncStub->args = args;
	asyncStub->proc = proc;
	return asyncStub->start();
}

void SimpleUDPPeer::recv_async_stop()
{
	if (asyncStub == nullptr)
		asyncStub = new AsyncStub(*this);

	asyncStub->stop();
}