#include "ChatClient.h"
#include "Keys.h"
#include <Klient.h>
#include <Globals.h>

using namespace KSGClient;

// Inhalt der ChatClient Klasse

// Konstruktor
ChatClient::ChatClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
{
    ref = 1;
    this->ip = ip;
    this->port = port;
    cId = klientId;
    senden = 0;
    empfangen = 0;
    this->key = new char[ keyLen ];
    memcpy( this->key, key, keyLen );
    this->keyLen = keyLen;
}

// Destruktor
ChatClient::~ChatClient()
{
    trenne( 1 );
    delete[] key;
}

// verbindet sich mit dem zugewiesenen Chat Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::verbinde()
{
    cs.lock();
    if( senden )
    {
        cs.unlock();
        return 1;
    }
    senden = new Network::Klient();
    int keyLen = 0;
    char *key = 0;
    Keys::getServerKey( &key, keyLen, Keys::CHAT, Keys::SENDEN );
    senden->setSendeKey( key, keyLen );
    delete[] key;
    Keys::getServerKey( &key, keyLen, Keys::CHAT, Keys::EMPFANGEN );
    senden->setEmpfangKey( key, keyLen );
    delete[] key;
    if( senden->verbinde( port, ip ) )
    {
        if( senden->sendeEncrypted( "\1", 1 ) )
        {
            senden->sendeEncrypted( (char*)&cId, 4 );
            char ret = 0;
            senden->getNachrichtEncrypted( &ret, 1 );
            if( ret != 1 )
            {
                char byte = 0;
                senden->getNachrichtEncrypted( &byte, 1 );
                char *f = new char[ byte + 1 ];
                f[ byte ] = 0;
                senden->getNachrichtEncrypted( f, byte );
                err = f;
                delete[]f;
                senden->sendeEncrypted( "\3", 1 );
                char serverReturn = 0;
                senden->getNachrichtEncrypted( &serverReturn, 1 );
                senden->trenne();
                senden = senden->release();
                cs.unlock();
                return 0;
            }
            senden->setSendeKey( this->key, this->keyLen );
            senden->setEmpfangKey( this->key, this->keyLen );
            empfangen = new Network::Klient();
            int keyLen = 0;
            char *key = 0;
            Keys::getServerKey( &key, keyLen, Keys::CHAT, Keys::SENDEN );
            empfangen->setSendeKey( key, keyLen );
            delete[] key;
            Keys::getServerKey( &key, keyLen, Keys::CHAT, Keys::EMPFANGEN );
            empfangen->setEmpfangKey( key, keyLen );
            delete[] key;
            if( empfangen->verbinde( senden->getServerPort(), senden->getServerIp() ) )
            {
                empfangen->sendeEncrypted( "\1", 1 );
                empfangen->sendeEncrypted( (char*)&cId, 4 );
                char res = 0;
                empfangen->getNachrichtEncrypted( &res, 1 );
                if( res == 1 )
                {
                    empfangen->setSendeKey( this->key, this->keyLen );
                    empfangen->setEmpfangKey( this->key, this->keyLen );
                    cs.unlock();
                    return 1;
                }
                if( res == 3 )
                {
                    char län = 0;
                    senden->getNachrichtEncrypted( &län, 1 );
                    char *nachricht = new char[ län + 1 ];
                    nachricht[ län ] = 0;
                    senden->getNachrichtEncrypted( nachricht, län );
                    err = nachricht;
                    delete[]nachricht;
                }
                trenne( 0 );
            }
            else
            {
                err = "Der dir zugewiesene Chat Server kann dir keine Nachrichten senden.";
                empfangen = empfangen->release();
                senden->sendeEncrypted( "\3", 1 );
                char serverReturn = 0;
                senden->getNachrichtEncrypted( &serverReturn, 1 );
                senden->trenne();
                senden = senden->release();
                cs.unlock();
                return 0;
            }
        }
        else
        {
            err = "Der dir zugewiesene Chat Server hat die Verbindung abgebrochen. Bitte versuche es Später erneut.";
            senden = senden->release();
            cs.unlock();
            return 0;
        }
    }
    else
    {
        err = "Der dir zugewiesene Chat Server antwortet nicht. Bitte versuche es Später erneut.";
        senden = senden->release();
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// sendet eine Chat Nachricht zu einem Account
//  zuAccount: Id des Ziel Accounts
//  nachricht: Die Nachricht
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::chatNachricht( int zuAccount, const char *nachricht )
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char län = textLength( nachricht );
    if( !län )
    {
        cs.unlock();
        return 1;
    }
    senden->sendeEncrypted( "\6", 1 );
    char serverReturn = 0;
    senden->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn )
    {
        senden->sendeEncrypted( (char*)&zuAccount, 4 );
        senden->sendeEncrypted( &län, 1 );
        senden->sendeEncrypted( nachricht, län );
    }
    else
    {
        err = "Fehler beim senden der Nachricht.";
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

// ändert den angezeigten Account Namen
//  name: der neue Name
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::accountNameÄndern( const char *name )
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char län = textLength( name );
    if( !län )
    {
        cs.unlock();
        return 0;
    }
    senden->sendeEncrypted( "\x8", 1 );
    char serverReturn = 0;
    senden->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn )
    {
        senden->sendeEncrypted( &län, 1 );
        senden->sendeEncrypted( name, län );
        senden->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    err = "Fehler beim ändern des Namens.";
    cs.unlock();
    return 0;
}

// beendet die Freundschaft mit einem Account
//  accountId: Die Id des Accounts
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::freundschaftBeenden( int accountId )
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    senden->sendeEncrypted( "\x9", 1 );
    char serverReturn = 0;
    senden->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn )
    {
        senden->sendeEncrypted( (char*)&accountId, 4 );
        senden->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    err = "Fehler beim beenden der Freundschaft.";
    cs.unlock();
    return 0;
}

// sendet eine Freundesanfragezu einem Account
//  accountId: Die Id des Accounts
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::freundesAnfrage( int accountId )
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    senden->sendeEncrypted( "\xA", 1 );
    char serverReturn = 0;
    senden->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn )
    {
        senden->sendeEncrypted( (char*)&accountId, 4 );
        senden->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    err = "Fehler beim senden der Freundschaftsanfrage.";
    cs.unlock();
    return 0;
}

// beantwortet eine Freundesanfrage
//  accountId: Die Id des Accounts
//  ja: 1:=annehmen,0:=ablehnen
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::freundesAnfrageBeantworten( int accountId, bool ja )
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    senden->sendeEncrypted( "\xB", 1 );
    char serverReturn = 0;
    senden->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn )
    {
        senden->sendeEncrypted( (char*)&accountId, 4 );
        char ok = (char)ja;
        senden->sendeEncrypted( &ok, 1 );
        senden->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    err = "Fehler beim beantworten der Freundschaftsanfrage.";
    cs.unlock();
    return 0;
}

// erstellt ein chatroom
//  name: Der Name des Chatrooms
//  Gibt bei erfolg die Id des Chatrooms zurück, 0 sonst
int ChatClient::chatroomErstellen( const char *name )
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char län = textLength( name );
    if( !län )
    {
        cs.unlock();
        return 0;
    }
    senden->sendeEncrypted( "\xC", 1 );
    char serverReturn = 0;
    senden->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn )
    {
        senden->sendeEncrypted( &län, 1 );
        senden->sendeEncrypted( name, län );
        senden->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            int ret = 0;
            senden->getNachrichtEncrypted( (char*)&ret, 4 );
            cs.unlock();
            return ret;
        }
    }
    err = "Fehler beim erstellen des Chatrooms.";
    cs.unlock();
    return 0;
}

// Sendet eine Einladung zum Chatroom
//  accountId: Die Id des Accounts der eingeladen werden soll
//  chatroomId: Die Id des Chatrooms
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::chatroomEinladung( int accountId, int chatroomId )
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    senden->sendeEncrypted( "\xD", 1 );
    char serverReturn = 0;
    senden->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn )
    {
        senden->sendeEncrypted( (char*)&accountId, 4 );
        senden->sendeEncrypted( (char*)&chatroomId, 4 );
        senden->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    err = "Fehler beim senden der Chatroomeinladung.";
    cs.unlock();
    return 0;
}

// Einladung zum Chatroom wird abgelehnt
//  accountId: Die Id des Accounts
//  chatroomId: Die Id des Chatrooms
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::chatroomEinladungAblehnen( int accountId, int chatroomId )
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    senden->sendeEncrypted( "\xE", 1 );
    char serverReturn = 0;
    senden->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn )
    {
        senden->sendeEncrypted( (char*)&accountId, 4 );
        senden->sendeEncrypted( (char*)&chatroomId, 4 );
        senden->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    err = "Fehler beim beantworten der Chatroomeinladung.";
    cs.unlock();
    return 0;
}

// betritt ein chatroom
//  chatroomId: Die Id des Chatrooms
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::chatroomBetreten( int chatroomId )
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    senden->sendeEncrypted( "\xF", 1 );
    char serverReturn = 0;
    senden->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn )
    {
        senden->sendeEncrypted( (char*)&chatroomId, 4 );
        senden->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    err = "Fehler beim betreten des Chatrooms.";
    cs.unlock();
    return 0;
}

// chatroom Nachricht senden
//  chatroomId: Die Id des Chatrooms
//  nachricht: Die Nachricht die gesendet werden soll
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::chatroomNachricht( int chatroomId, const char *nachricht )
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char län = textLength( nachricht );
    if( !län )
    {
        cs.unlock();
        return 0;
    }
    senden->sendeEncrypted( "\x10", 1 );
    char serverReturn = 0;
    senden->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn )
    {
        senden->sendeEncrypted( (char*)&chatroomId, 4 );
        senden->sendeEncrypted( &län, 1 );
        senden->sendeEncrypted( nachricht, län );
        senden->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    err = "Fehler beim senden der Nachricht.";
    cs.unlock();
    return 0;
}

// verlässt chatroom
//  chatroomId: Die Id des Chatrooms
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::chatroomVerlassen( int chatroomId )
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    senden->sendeEncrypted( "\x11", 1 );
    char serverReturn = 0;
    senden->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn )
    {
        senden->sendeEncrypted( (char*)&chatroomId, 4 );
        senden->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    err = "Fehler beim verlassen des Chatrooms.";
    cs.unlock();
    return 0;
}

// kickt Account aus Chatroom (nur wenn als admin des Chatrooms eingeloggt)
//  chatroomId: Die Id des Chatrooms
//  accountId: Die Id des Accounts
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::chatroomKick( int chatroomId, int accountId )
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    senden->sendeEncrypted( "\x12", 1 );
    char serverReturn = 0;
    senden->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn )
    {
        senden->sendeEncrypted( (char*)&chatroomId, 4 );
        senden->sendeEncrypted( (char*)&accountId, 4 );
        senden->getNachrichtEncrypted( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            cs.unlock();
            return 1;
        }
    }
    err = "Fehler beim kicken eines Spielers aus dem Chatroom.";
    cs.unlock();
    return 0;
}

// fragt nach allen freunden
//  Die Liste der Freunde kann über getNextMessage empfangen werden
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::freundesListeAnfragen()
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char serverReturn = 0;
    senden->sendeEncrypted( "\x13", 1 );
    senden->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 1 )
    {
        cs.unlock();
        return 1;
    }
    err = "Fehler beim Anfragen der Freundesliste.";
    cs.unlock();
    return 0;
}

// fragt nach allen chatnachrichten, die gesendet wurden, während der Account in den der Client eingeloggt ist, offline war
//  Die einzelnen Nachrichten können über getNextMessage empfangen werden
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::chatNachrichtAnfrage()
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char serverReturn = 0;
    senden->sendeEncrypted( "\x14", 1 );
    senden->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 1 )
    {
        cs.unlock();
        return 1;
    }
    err = "Fehler beim Anfragen der Chatnachrichten.";
    cs.unlock();
    return 0;
}

// Erhält die Verbindung aufrecht
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
bool ChatClient::keepAlive()
{
    if( !senden )
        return 0;
    char res = 0;
    if( !cs.tryLock() )
        return 1;
    Framework::logLine( ( char* )"Verbindungstest zum Chat Server..." );
    bool ok = senden->sendeEncrypted( "\x15", 1 );
    ok &= senden->getNachrichtEncrypted( &res, 1 );
    cs.unlock();
    if( res != 1 || !ok )
    {
        Framework::logLine( ( char* )"Verbindungsabbruch." );
        trenne( 0 );
    }
    else
        Framework::logLine( ( char* )"Verbindung besteht." );
    return res == 1;
}

// Trennt die Verbindung zum Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
bool ChatClient::trenne( bool abmelden )
{
    if( !senden )
        return 1;
    cs.lock();
    senden->sendeEncrypted( "\3", 1 );
    char serverReturn = 0;
    senden->getNachrichtEncrypted( &serverReturn, 1 );
    senden->trenne();
    senden = senden->release();
    if( empfangen )
    {
        empfangen->trenne();
        empfangen = empfangen->release();
    }
    cs.unlock();
    return 1;
}

// Wartet auf eine Nachricht vom Chatserver und gibt diese zurück.
bool ChatClient::getNextMessage( ChatServerNachricht &nachricht )
{
    cs.lock();
    if( !empfangen )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    do
    {
        if( !empfangen->getNachrichtEncrypted( &nachricht.type, 1 ) )
        {
            err = "Fehler beim Empfangen der Nachricht.";
            cs.unlock();
            return 0;
        }
        switch( nachricht.type )
        {
        case 3: // Fehler
            if( 1 )
            {
                char länge = 0;
                empfangen->getNachrichtEncrypted( &länge, 1 );
                char *txt = new char[ länge + 1 ];
                txt[ länge ] = 0;
                empfangen->getNachrichtEncrypted( txt, länge );
                nachricht.message = txt;
                delete[] txt;
            }
            break;
        case 4: // Chat Nachricht
            if( 1 )
            {
                empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
                char länge = 0;
                empfangen->getNachrichtEncrypted( &länge, 1 );
                char *txt = new char[ länge + 1 ];
                txt[ länge ] = 0;
                empfangen->getNachrichtEncrypted( txt, länge );
                nachricht.message = txt;
                delete[] txt;
            }
            break;
        case 5: // Spiel Einladung
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
            break;
        case 6: // Account Status ändert sich
            if( 1 )
            {
                empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
                char län = 0;
                empfangen->getNachrichtEncrypted( &län, 1 );
                char *status = new char[ län + 1 ];
                status[ län ] = 0;
                empfangen->getNachrichtEncrypted( status, län );
                nachricht.message = status;
                delete[] status;
            }
            break;
        case 7: // Account Name ändert sich
            if( 1 )
            {
                empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
                char län = 0;
                empfangen->getNachrichtEncrypted( &län, 1 );
                char *name = new char[ län + 1 ];
                name[ län ] = 0;
                empfangen->getNachrichtEncrypted( name, län );
                nachricht.message = name;
                delete[] name;
            }
            break;
        case 8: // kein Freund mehr
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            break;
        case 9: // Freundesanfrage
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            break;
        case 0xA: // Neuer Freund
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            break;
        case 0xB: // Freundesanfrage abgelehnt
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            break;
        case 0xC: // Einladung zum Chatroom
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            empfangen->getNachrichtEncrypted( (char*)&nachricht.chatroom, 4 );
            break;
        case 0xD: // Einladung zum Chatroom abgelehnt
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            empfangen->getNachrichtEncrypted( (char*)&nachricht.chatroom, 4 );
            break;
        case 0xE: // Spieler betritt Chatroom
            empfangen->getNachrichtEncrypted( (char*)&nachricht.chatroom, 4 );
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            break;
        case 0xF: // Chatroom Nachricht
            if( 1 )
            {
                empfangen->getNachrichtEncrypted( (char*)&nachricht.chatroom, 4 );
                empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
                char län = 0;
                empfangen->getNachrichtEncrypted( &län, 1 );
                char *txt = new char[ län + 1 ];
                txt[ län ] = 0;
                if( län )
                {
                    empfangen->getNachrichtEncrypted( txt, län );
                    nachricht.message = txt;
                }
                delete[] txt;
            }
            break;
        case 0x10: // Spieler verlässt Chatroom
            empfangen->getNachrichtEncrypted( (char*)&nachricht.chatroom, 4 );
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            break;
        case 0x11: // Freunde
            if( 1 )
            {
                char freundeAnzahl;
                empfangen->getNachrichtEncrypted( &freundeAnzahl, 1 );
                for( int i = 0; i < freundeAnzahl; i++ )
                {
                    int accountId = 0;
                    empfangen->getNachrichtEncrypted( (char*)&accountId, 4 );
                    nachricht.ids.add( accountId );
                }
            }
            break;
        case 0x12: // Spieler im Chatroom
            if( 1 )
            {
                empfangen->getNachrichtEncrypted( (char*)&nachricht.chatroom, 4 );
                char anzahl = 0;
                empfangen->getNachrichtEncrypted( &anzahl, 1 );
                for( char i = 0; i < anzahl; i++ )
                {
                    int accountId = 0;
                    empfangen->getNachrichtEncrypted( (char*)&accountId, 4 );
                    nachricht.ids.add( accountId );
                }
            }
            break;
        case 0x13: // Freund online
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            break;
        case 0x14: // Freund offline
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            break;
        case 0x15: // Chatroom Admin
            empfangen->getNachrichtEncrypted( (char*)&nachricht.chatroom, 4 );
            break;
        case 0x16: // Chatroom Kick
            empfangen->getNachrichtEncrypted( (char*)&nachricht.chatroom, 4 );
            break;
        case 0x17: // Spieler betritt Gruppe
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
            break;
        case 0x18: // Spieler verlässt Gruppe
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
            break;
        case 0x19: // gruppe Nachricht
            if( 1 )
            {
                char län = 0;
                empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
                empfangen->getNachrichtEncrypted( &län, 1 );
                if( län )
                {
                    char *txt = new char[ län + 1 ];
                    txt[ län ] = 0;
                    empfangen->getNachrichtEncrypted( txt, län );
                    nachricht.message = txt;
                    delete[] txt;
                }
            }
            break;
        case 0x1A: // gruppe Angemeldet
            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
            break;
        case 0x1B: // gruppe Abgemeldet
            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
            break;
        case 0x1C: // gruppe Spiel starten
            if( 1 )
            {
                char starten = 0;
                empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
                empfangen->getNachrichtEncrypted( &starten, 1 );
                nachricht.account = starten;
            }
            break;
        case 0x1D: // kick aus Gruppe
            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
            break;
        case 0x1E: // gruppe Admin
            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            break;
        case 0x1F: // gruppe Einladung abgelehnt
            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            break;
        case 0x20: // SpielServer Verbindungs Anfrage
            if( 1 )
            {
                unsigned short port;
                unsigned char *ip = new unsigned char[ 4 ];
                empfangen->getNachrichtEncrypted( (char*)&port, 2 );
                empfangen->getNachrichtEncrypted( (char*)ip, 4 );
                nachricht.account = port;
                Text *ipT = new Text( "" );
                ipT->append( (int)ip[ 0 ] );
                ipT->append( "." );
                ipT->append( (int)ip[ 1 ] );
                ipT->append( "." );
                ipT->append( (int)ip[ 2 ] );
                ipT->append( "." );
                ipT->append( (int)ip[ 3 ] );
                nachricht.message = ipT->getText();
                delete[] ip;
                ipT->release();
            }
            break;
        case 0x21: // Gruppe Einladung abgebrochen
            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            break;
        case 0x22: // Gruppe Einladung hinzufügen
            empfangen->getNachrichtEncrypted( (char*)&nachricht.gruppe, 4 );
            empfangen->getNachrichtEncrypted( (char*)&nachricht.account, 4 );
            break;
        case 0x23: // ping
            empfangen->sendeEncrypted( "\1", 1 );
            break;
        }
    } while( nachricht.type == 0x23 );
}

// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
bool ChatClient::istVerbunden() const
{
    return senden != 0;
}

// gibt den Letzten Fehlertext zuück
//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
char *ChatClient::getLetzterFehler() const
{
    return err;
}

// Erhöht den Reference Counter um 1 un gibt this zurück
ChatServerClient *ChatClient::getThis()
{
    ref++;
    return this;
}

// Verringert den Reference Counter um 1 und gibt 0 zurück.
//  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
ChatServerClient *ChatClient::release()
{
    if( !--ref )
        delete this;
    return 0;
}