/* $Id: clientconnectiontcp.cpp,v 1.5.4.2 2006/03/09 14:59:42 chfreund Exp $ */

#include "clientconnectiontcp.hpp"
#include "global.hpp"
#include "wopsettings.hpp"
#include "tcpconnection.hpp"

ClientConnectionTCP::ClientConnectionTCP( TCPsocket socket )
	: m_socket( socket ), m_eventMessage( 0 ) {
	LOG( 2 ) INFO( "ClientConnectionTCP::ClientConnectionTCP: creating\n" );
	
	m_socketSet = SDLNet_AllocSocketSet( 1 );
	SDLNet_TCP_AddSocket( m_socketSet, m_socket );
}

ClientConnectionTCP::~ClientConnectionTCP() {
	LOG( 2 ) INFO( "ClientConnectionTCP::~ClientConnectionTCP: cleaning up\n" );
	
	// delete all remaining messages
	if ( m_eventMessage )
		delete m_eventMessage;
	for ( std::deque<Message*>::iterator it = m_messageQueue.begin();
	      it != m_messageQueue.end(); it++ )
		delete *it;
	
	if ( m_socket )
		SDLNet_TCP_Close( m_socket );
	
	SDLNet_FreeSocketSet( m_socketSet );
}

void ClientConnectionTCP::openConnection( Uint8 clientID ) {
	LOG( 2 ) INFO( "ClientConnectionTCP::openConnection: establishing connection\n" );
	Message* message = 0;
	int result = TCPConnection::recvMessage( m_socket, message );
	CHECK( !result,
	       "ClientConnectionTCP::openConnection: connection lost\n" );
	CHECK( message && message->type == Message::REQUEST,
	       "ClientConnectionTCP::openConnection: expected REQUEST message\n" );
	RequestMessage* requestMessage = static_cast<RequestMessage*>( message );
	
	if ( requestMessage->request != Message::CONNECT ) {
		LOG( 2 ) INFO( "ClientConnectionTCP::openConnection: expected REQUEST CONNECT message\n" );
		return;
	}
	
	ConnectMessage connectMessage;
	connectMessage.clientID = clientID;
	TCPConnection::sendMessage( m_socket, &connectMessage );
	
	delete requestMessage;
	
	m_id = clientID;
	m_lag = 0;
}

void ClientConnectionTCP::closeConnection() {
	LOG( 2 ) INFO( "ClientConnectionTCP::closeConnection: closing connection\n" );
	
	if ( m_socket ) {
		// Send quit message to the server
		QuitMessage quitMessage;
		TCPConnection::sendMessage( m_socket, &quitMessage );
		
		// Remove socket from socket set
		SDLNet_TCP_DelSocket( m_socketSet, m_socket );
		
		// Close socket
		SDLNet_TCP_Close( m_socket );
		m_socket = 0;
	}
}

EventMessage* ClientConnectionTCP::getEventMessage() {
	while ( recvMessage() )
		;
	
	// TODO: multithreaded access would require synchronisation
	EventMessage* message = m_eventMessage;
	m_eventMessage = 0;
	
	if ( !message )
		m_lag++;
	else
		m_lag = 0;
	
	return message;
}

Message* ClientConnectionTCP::getMessage() {
	while ( recvMessage() )
		;
	
	if ( m_messageQueue.size() > 0 ) {
		Message* message = m_messageQueue.front();
		m_messageQueue.pop_front();
		return message;
	}
	
	return 0;
}

void ClientConnectionTCP::sendMessage( Message* message ) {
	if ( m_socket )
		TCPConnection::sendMessage( m_socket, message, m_compress, m_listener );
}

void ClientConnectionTCP::sendEchoMessage( Message* echoMessage ) {
	if ( m_socket )
		TCPConnection::sendMessage( m_socket, echoMessage, m_compress, m_listener );
}

bool ClientConnectionTCP::recvMessage() {
	if ( SDLNet_CheckSockets( m_socketSet, 0 ) == 0 )
		return false;
	
	Message* message = 0;
	int result = TCPConnection::recvMessage( m_socket, message, m_listener );
	if ( result == -1 ) {
		// the connection has been lost
		// Remove socket from socket set
		SDLNet_TCP_DelSocket( m_socketSet, m_socket );
		// Close socket
		SDLNet_TCP_Close( m_socket );
		m_socket = 0;
	}
	else {
		if ( message ) {
			if ( message->type == Message::EVENT ) {
				// TODO: multithreaded access would require synchronisation!
				if ( m_eventMessage )
					delete m_eventMessage;
				m_eventMessage = static_cast<EventMessage*>( message );
			}
			else
				m_messageQueue.push_back( message );
			return true;
		}
	}
	
	return false;
}