/*
   net/netclient.cc
   This file is part of the Osirion project and is distributed under
   the terms of the GNU General Public License version 2
*/

#include <iostream>
#include <sstream>

#include "sys/sys.h"
#include "core/net.h"
#include "core/application.h"
#include "core/stats.h"

namespace core
{

NetClient::NetClient(std::string host, int port) :
		client_host(host)
{
	client_error = true;
	client_state = Connecting;

	con_print << host  << ":" << port << " connected." << std::endl;

	client_host = host;
	client_port = port;

	client_addr.sin_family = AF_INET;
	client_addr.sin_port = htons(port);
	client_addr.sin_addr.s_addr = inet_addr(host.c_str());
	memset(client_addr.sin_zero, '\0', sizeof(client_addr.sin_zero));

	if (client_addr.sin_addr.s_addr == INADDR_NONE) {
		con_warn << "Network invalid client address " << host << "!" << std::endl;
		abort();
		return;
	}
	
	sendq.clear();
	messageblock.clear();
	
	client_keepalive = application()->time();
	client_timeout = application()->time();

	client_error = false;
}

NetClient::~NetClient()
{
	con_print << host()  << ":" << port() << " disconnected." << std::endl;
}

void NetClient::abort()
{
	client_error = true;
}

std::string NetClient::host() const
{
        return client_host;
}

int NetClient::port() const
{
        return client_port;
}

Player *NetClient::player() 
{
	return &client_player;
}

bool NetClient::has_messages() const {
	return (recvq.size() > 0 );
}

void NetClient::retreive(std::string & message) {
	if (recvq.size() > 0 ) {
		message.assign(recvq.front());
		recvq.pop_front();
	} else {
		message.clear();
	}
}

// receive data and decode it into lines
void NetClient::receive(char *data)
{
	std::string datablock;
	datablock.assign(data);

	if (!datablock.size())
		return;

	while(datablock.size() > 0 ) {
		// scan the datablock for enters				
		if (datablock[0] == '\n' || datablock[0] == '\r') {
			// TODO detect "begin binary block" message for zlib compression
			if (messageblock.size() > 0 ) {
 				recvq.push_back(messageblock);
				messageblock.clear();
			}
		} else {
			if (messageblock.size() < FRAMESIZE) {
				messageblock.append(datablock.substr(0,1));
			} else {
				con_warn << "Incoming message exceeds " << FRAMESIZE << " bytes!\n";
				messageblock.clear();
			}
		}
		datablock.erase(0,1);
	}

	client_timeout = application()->time();	
}

void NetClient::send(std::string const &msg)
{
	sendq.append(msg);
}

void NetClient::transmit(int serverfd)
{
	if (!sendq.size()) {
		if (client_keepalive + NETTIMEOUT/2 < application()->time()) {
			sendq.assign("ping\n");
		} else {
			return;
		}
	} else if (sendq.size() >= FRAMESIZE) {
		con_warn << "Outgoing message exceeds " << FRAMESIZE -1 << " bytes!\n";
		//sendq.clear();
		//return;
	}

	ssize_t 	bytes_sent = 0;

	while (sendq.size() && !error()) {
		bytes_sent = ::sendto(serverfd, sendq.c_str(), sendq.size()+1, 0, 
				(struct sockaddr *)&client_addr, sizeof(client_addr));

		if (bytes_sent < 0) {
			abort();
			return;
		}

		sendq.erase(0, bytes_sent);
		Stats::network_bytes_sent += bytes_sent;
	}
	sendq.clear();

	client_keepalive = application()->time();
}

}