#include "../KSGKlient.h"
#include "../KSGServer.h"
#include <Datei.h>
#include "../../Global/Variablen.h"

// Inhalt der KartenKlient Klasse aus KSGKlient.h
// Konstruktor
KartenKlient::KartenKlient()
{
    verbunden = 0;
    klient = 0;
    fehler = new Text( "" );
    klientId = getKlientId();
    ref = 1;
    InitializeCriticalSection( &cs );
}

// Destruktor
KartenKlient::~KartenKlient()
{
    LOCK( &cs );
    if( verbunden )
        trenne();
    fehler = fehler->release();
    UNLOCK( &cs );
    DeleteCriticalSection( &cs );
}

// nicht constant
bool KartenKlient::verbinde( unsigned short port, char *ip ) // verbindet ich mit dem Karten Server
{
    if( klient && verbunden && klient->getServerPort() == port && Text( ip ).istGleich( klient->getServerIp() ) )
        return 1;
    if( klient || verbunden )
        trenne();
    klient = new Klient();
    unsigned char schlüssel[ 20 ] = { 24, 15, 53, 87, 38, 73, 154, 38, 246, 90, 39, 133, 11, 199, 22, 80, 26, 132, 95, 54 };
    klient->setSendeSchlüssel( (char*)schlüssel, 20 );
    klient->setEmpfangSchlüssel( (char*)schlüssel, 20 );
    if( !klient->verbinde( (unsigned short)port, ip ) )
    {
        klient = klient->release();
        fehler->setText( "Fehler beim verbinden mit dem Editor Server." );
        return 0;
    }
    klient->sendeVerschlüsselt( "\1", 1 );
    klient->sendeVerschlüsselt( (char*)&klientId, 4 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 3 )
    {
        char län = 0;
        klient->getNachrichtVerschlüsselt( &län, 1 );
        char *nachricht = new char[ län + 1 ];
        nachricht[ län ] = 0;
        klient->getNachrichtVerschlüsselt( nachricht, län );
        fehler->setText( nachricht );
        delete[]nachricht;
        trenne();
        return 0;
    }
    if( ret == 1 )
    {
        char *sl = 0;
        char slLän = getSchlüssel( &sl );
        klient->setSendeSchlüssel( sl, slLän );
        klient->setEmpfangSchlüssel( sl, slLän );
        delete[] sl;
        verbunden = 1;
    }
    return 1;
}

bool KartenKlient::downloadKarte( int id ) // läd die Karte herunter
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x6", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 2 )
        { // update
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Die Karte wird momentan aktualisiert." ), new Text( "Ok" ) );
            UNLOCK( &cs );
            return 0;
        }
        else if( ret == 1 )
        {
            int anz = 0;
            klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                char län = 0;
                klient->getNachrichtVerschlüsselt( &län, 1 );
                if( !län )
                    continue;
                char *pf = new char[ län + 1 ];
                pf[ län ] = 0;
                klient->getNachrichtVerschlüsselt( pf, län );
                __int64 größe = 0;
                klient->getNachrichtVerschlüsselt( (char*)&größe, 8 );
                char *buffer = new char[ 2048 ];
                Text pfad = "data/tmp/Karten/";
                pfad += id;
                pfad += "/spiel";
                pfad += pf;
                delete[] pf;
                Datei d;
                d.setDatei( pfad );
                d.erstellen();
                d.öffnen( Datei::Style::schreiben );
                while( größe )
                {
                    int l = größe >= 2048 ? 2048 : (int)größe;
                    klient->getNachricht( buffer, l );
                    d.schreibe( buffer, l );
                    größe -= l;
                }
                d.schließen();
                delete[] buffer;
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 1;
}

bool KartenKlient::downloadKarteTitel( int id ) // läd das Titelbild einer Karte herunter
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x8", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 2 )
        { // update
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Die Karte wird momentan aktualisiert." ), new Text( "Ok" ) );
            UNLOCK( &cs );
            return 0;
        }
        else if( ret == 1 )
        {
            __int64 größe = 0;
            klient->getNachrichtVerschlüsselt( (char*)&größe, 8 );
            char *buffer = new char[ 2048 ];
            Text pfad = "data/tmp/Karten/";
            pfad += id;
            pfad += "/titel.ltdb";
            Datei d;
            d.setDatei( pfad );
            d.erstellen();
            d.öffnen( Datei::Style::schreiben );
            while( größe )
            {
                int l = größe >= 2048 ? 2048 : (int)größe;
                klient->getNachricht( buffer, l );
                d.schreibe( buffer, l );
                größe -= l;
            }
            d.schließen();
            delete[] buffer;
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 1;
}

bool KartenKlient::downloadKarteBeschreibung( int id ) // läd die Beschreibung einer Karte herunter
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x9", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 2 )
        { // update
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Die Karte wird momentan aktualisiert." ), new Text( "Ok" ) );
            UNLOCK( &cs );
            return 0;
        }
        else if( ret == 1 )
        {
            __int64 größe = 0;
            klient->getNachrichtVerschlüsselt( (char*)&größe, 8 );
            char *buffer = new char[ 2048 ];
            Text pfad = "data/tmp/Karten/";
            pfad += id;
            pfad += "/beschreibung.ksgs";
            Datei d;
            d.setDatei( pfad );
            d.erstellen();
            d.öffnen( Datei::Style::schreiben );
            while( größe )
            {
                int l = größe >= 2048 ? 2048 : (int)größe;
                klient->getNachricht( buffer, l );
                d.schreibe( buffer, l );
                größe -= l;
            }
            d.schließen();
            delete[] buffer;
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 1;
}

bool KartenKlient::downloadKarteMinimap( int id ) // läd die Minimap einer Karte herunter
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\xA", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 2 )
        { // update
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Die Karte wird momentan aktualisiert." ), new Text( "Ok" ) );
            UNLOCK( &cs );
            return 0;
        }
        else if( ret == 1 )
        {
            __int64 größe = 0;
            klient->getNachrichtVerschlüsselt( (char*)&größe, 8 );
            char *buffer = new char[ 2048 ];
            Text pfad = "data/tmp/Karten/";
            pfad += id;
            pfad += "/minimap.ltdb";
            Datei d;
            d.setDatei( pfad );
            d.erstellen();
            d.öffnen( Datei::Style::schreiben );
            while( größe )
            {
                int l = größe >= 2048 ? 2048 : (int)größe;
                klient->getNachricht( buffer, l );
                d.schreibe( buffer, l );
                größe -= l;
            }
            d.schließen();
            delete[] buffer;
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 1;
}

bool KartenKlient::downloadKarteLadebild( int id ) // läd das Ladebild einer Karte herunter
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\xB", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 2 )
        { // update
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Die Karte wird momentan aktualisiert." ), new Text( "Ok" ) );
            UNLOCK( &cs );
            return 0;
        }
        else if( ret == 1 )
        {
            __int64 größe = 0;
            klient->getNachrichtVerschlüsselt( (char*)&größe, 8 );
            char *buffer = new char[ 2048 ];
            Text pfad = "data/tmp/Karten/";
            pfad += id;
            pfad += "/ladebild.ltdb";
            Datei d;
            d.setDatei( pfad );
            d.erstellen();
            d.öffnen( Datei::Style::schreiben );
            while( größe )
            {
                int l = größe >= 2048 ? 2048 : (int)größe;
                klient->getNachricht( buffer, l );
                d.schreibe( buffer, l );
                größe -= l;
            }
            d.schließen();
            delete[] buffer;
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 1;
}

bool KartenKlient::keepAlive() // Erhält die Verbindung aufrecht
{
    if( !verbunden )
        return 0;
    char res = 0;
    if( !TryEnterCriticalSection( &cs ) )
        return 1;
    klient->sendeVerschlüsselt( "\x5", 1 );
    klient->getNachrichtVerschlüsselt( &res, 1 );
    UNLOCK( &cs );
    if( res != 1 )
    {
        trenne();
        fehler->setText( "Verbindung unterbrochen: 'Keep Alive' nicht erfolgreich." );
    }
    return res == 1;
}

bool KartenKlient::trenne() // trennt sich von dem Editor Server
{
    if( !klient || !verbunden )
    {
        if( klient )
            klient = klient->release();
        return 1;
    }
    char serverReturn;
    klient->sendeVerschlüsselt( "\4", 1 );
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtVerschlüsselt( &län, 1 );
        char *nachricht = new char[ län + 1 ];
        nachricht[ län ] = 0;
        klient->getNachrichtVerschlüsselt( nachricht, län );
        delete[]nachricht;
    }
    klient->sendeVerschlüsselt( "\3", 1 );
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    klient->trenne();
    klient = klient->release();
    return 1;
}

// constant
bool KartenKlient::istVerbunden() const // prüft, ob mit Editor Server verbunden
{
    return verbunden;
}

char *KartenKlient::getLetzterFehler() const // gibt den Letzten Fehlertext zuück
{
    return fehler->getText();
}

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

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