#include "Server.h"
#ifndef WIN32
#include <string.h>
#endif
#include <Key.h>

using namespace Network;

// Inhalt der Server Klasse aus Server.h
// Konstruktor 
Server::Server()
{
	sock = 0;
	memset( &addresse, 0, sizeof( addresse ) ); // Adresse setzen
	addresse.sin_family = AF_INET;
	addresse.sin_addr.s_addr = ADDR_ANY;
	ref = 1;
	klients = 0;
}

// Destruktor 
Server::~Server()
{

}

// nicht constant 
bool Server::verbinde( unsigned short port, int warteschlangenLen ) // Öffnet das Socket
{
	sock = socket( AF_INET, SOCK_STREAM, 0 ); // Socket erstellen
	addresse.sin_port = htons( port ); // port setzen
	if( bind( sock, ( struct sockaddr* )&addresse, sizeof( addresse ) ) == -1 ) // socket öffnen
		return 0; // Fehler
	if( listen( sock, warteschlangenLen ) == -1 ) // Klients annehmen
		return 0; // Fehler
	return 1;
}

SKlient *Server::getKlient() // nimmt Klient an
{
	if( !sock )
		return 0;
	sockaddr_in client;
	int len = sizeof( addresse );
#ifdef WIN32
	SOCKET cls = accept( sock, (sockaddr*)&client, &len ); // Klient empfangen
	if( cls == INVALID_SOCKET )
		return 0;
#else
	SOCKET cls = accept( sock, (sockaddr*)&client, (socklen_t*)&len ); // Klient empfangen
	if( !cls )
		return 0;
#endif
	client.sin_port = addresse.sin_port;
	klients++;
	return new SKlient( client, cls ); // Klient Handle Klasse zurückgeben
}

int Server::getKlients( bool reset ) // gibt die Anzahl der Klients zurück
{
	int ret = klients;
	if( reset )
		klients = 0;
	return ret;
}

bool Server::trenne() // beendet den Server
{
	if( !sock )
		return 1;
	if( closesocket( sock ) < 0 ) // socket schließen
		return 0;
	sock = 0;
	return 1;
}

// constant
unsigned short Server::getPort() const // gibt den Port zurück
{
	return htons( addresse.sin_port );
}

// Reference Counting 
Server *Server::getThis()
{
	ref++;
	return this;
}

Server *Server::release()
{
	ref--;
	if( !ref )
		delete this;
	return 0;
}

// Inhalt der SKlient Klasse aus Server.h
// Konstruktor 
SKlient::SKlient( sockaddr_in addresse, SOCKET sock )
{
	clientAddr = addresse;
	this->sock = sock;
	ref = 1;
	downStreamBytes = 0;
	upStreamBytes = 0;
	sendeKey = 0;
	empfangKey = 0;
}

// Destruktor 
SKlient::~SKlient()
{
    trenne();
	if( sendeKey )
		sendeKey->release();
	if( empfangKey )
		empfangKey->release();
}

// nicht constant 
void SKlient::setSendeKeyZ( Encryption::Key *key ) // Setzt den Key fürs Senden
{
	if( sendeKey )
		sendeKey->release();
	sendeKey = key;
}

void SKlient::setEmpfangKeyZ( Encryption::Key *key ) // Setzt den Key fürs Empfangen
{
	if( empfangKey )
		empfangKey->release();
	empfangKey = key;
}

void SKlient::setSendeKey( char *key, int len ) // Setzt den Key fürs Senden
{
	if( !sendeKey )
		sendeKey = new Encryption::Key();
	sendeKey->setKey( key, len );
}

void SKlient::setEmpfangKey( char *key, int len ) // Setzt den Key fürs Empfangen
{
	if( !empfangKey )
		empfangKey = new Encryption::Key();
	empfangKey->setKey( key, len );
}

bool SKlient::sende( const char *nachricht, int len ) // sendet zum Klient
{
	if( !sock )
		return 0;
    int ll = 0;
    while( len > 0 )
    {
#ifdef WIN32
        int l = send( sock, nachricht + ll, len, 0 );
#else
        int l = (int)send( sock, nachricht + ll, len, MSG_NOSIGNAL );
#endif
        if( l < 0 )
            return 0; // Fehler
        len -= l;
        ll += l;
    }
	upStreamBytes += ll;
	return 1;
}

bool SKlient::getNachricht( char *nachricht, int len ) // empfängt Nachricht von Klient
{
	if( !sock )
		return 0;
    int ll = 0;
    while( len > 0 )
    {
        int l = (int)recv( sock, nachricht + ll, len, MSG_WAITALL );
        if( l < 0 )
            return 0; // Fehler
        len -= l;
        ll += l;
    }
	downStreamBytes += ll;
	return 1;
}

bool SKlient::sendeEncrypted( const char *nachricht, int len ) // sendet zum Server
{
	if( !sendeKey )
		return sende( nachricht, len );
	Encryption::Bytes *n = new Encryption::Bytes( nachricht, len );
	sendeKey->codieren( n->getThis() ); int ll = 0;
    while( len > 0 )
    {
#ifdef WIN32
        int l = send( sock, n->getBytes() + ll, len, 0 );
#else
        int l = (int)send( sock, n->getBytes() + ll, len, MSG_NOSIGNAL );
#endif
        if( l < 0 )
        {
            n->release();
            return 0; // Fehler
        }
        len -= l;
        ll += l;
    }
    upStreamBytes += ll;
	n->release();
	return 1;
}

bool SKlient::getNachrichtEncrypted( char *nachricht, int len ) // empfängt Nachricht
{
	if( !empfangKey )
		return getNachricht( nachricht, len );
    int ll = 0;
    while( len > 0 )
    {
        int l = (int)recv( sock, nachricht + ll, len, MSG_WAITALL );
        if( l < 0 )
            return 0; // Fehler
        len -= l;
        ll += l;
    }
	Encryption::Bytes *n = new Encryption::Bytes();
	n->setBytesZ( nachricht, ll );
	empfangKey->decodieren( n );
	downStreamBytes += ll;
	return 1;
}

int SKlient::getDownloadBytes( bool reset ) // gibt die anzahl von empfangen bytes zurück
{
	int ret = downStreamBytes;
	if( reset )
		downStreamBytes = 0;
	return ret;
}

int SKlient::getUploadBytes( bool reset ) // gibt die anzahl von versendeter bytes zurück
{
	int ret = upStreamBytes;
	if( reset )
		upStreamBytes = 0;
	return ret;
}

bool SKlient::trenne() // trennt die Verbindung zum Klient
{
	if( !sock )
		return 0;
	if( closesocket( sock ) < 0 ) // trennen
		return 0;
	sock = 0;
	return 1;
}

// constant 
unsigned short SKlient::getPort() const // gibt den Port zurück
{
	return htons( clientAddr.sin_port );
}

const char *SKlient::getIp() const // gibt die Ip des Klients zurück
{
	return inet_ntoa( clientAddr.sin_addr );
}

// Reference Counting 
SKlient *SKlient::getThis()
{
	ref++;
	return this;
}

SKlient *SKlient::release()
{
	ref--;
	if( !ref )
		delete this;
	return 0;
}