#include "Datenbank.h"
#include <Zeit.h>
#include "AccountHistorieDaten.h"
#include "KartenLeser.h"

// Inhalt der LSDatenbank Klasse aus Datenbank.h
// Konstruktor
ISDatenbank::ISDatenbank( InitDatei *zIni )
{
    datenbank = new Datenbank( zIni->zWert( "DBBenutzer" )->getText(), zIni->zWert( "DBPasswort" )->getText(),
                               zIni->zWert( "DBName" )->getText(), zIni->zWert( "DBIP" )->getText(),
                               (unsigned short)TextZuInt( zIni->zWert( "DBPort" )->getText(), 10 ) );
    if( !datenbank->istOk() )
    {
        std::cout << "IS: Die Verbindung zur Datenbank konnte nicht hergestellt werden.\nDas Programm wird beendet.";
        exit( 1 );
    }
    InitializeCriticalSection( &cs );
    ref = 1;
    Text befehl = "SELECT port, admin_port  FROM server WHERE id = ";
    befehl += zIni->zWert( "ServerId" )->getText();
    lock();
    datenbank->befehl( befehl );
    Result res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl == 1 )
    {
        zIni->addWert( "ServerPort", res.values[ 0 ] );
        zIni->addWert( "AdminServerPort", res.values[ 1 ] );
    }
    res.destroy();
}

// Destruktor
ISDatenbank::~ISDatenbank()
{
    datenbank->release();
    DeleteCriticalSection( &cs );
}

// nicht constant
void ISDatenbank::lock()
{
    EnterCriticalSection( &cs );
}

void ISDatenbank::unlock()
{
    LeaveCriticalSection( &cs );
}

int ISDatenbank::istAdministrator( const char *name, const char *passwort )
{
    Text *befehl = new Text( "SELECT id FROM benutzer WHERE name = '" );
    befehl->append( name );
    befehl->append( "' AND passwort = md5('" );
    befehl->append( passwort );
    befehl->append( "')" );
    lock();
    datenbank->befehl( befehl->getText() );
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    int ret = 0;
    if( res.zeilenAnzahl > 0 )
        ret = TextZuInt( res.values[ 0 ].getText(), 10 );
    res.destroy();
    return ret;
}

bool ISDatenbank::adminHatRecht( int id, int recht )
{
    Text *befehl = new Text( "SELECT * FROM benutzer_rechte WHERE benutzer_id = " );
    befehl->append( id );
    befehl->append( " AND rechte_id = " );
    befehl->append( recht );
    lock();
    datenbank->befehl( befehl->getText() );
    int ret = datenbank->getZeilenAnzahl();
    unlock();
    befehl->release();
    return ret != 0;
}

bool ISDatenbank::proveKlient( int num, int sNum )
{
    Text *befehl = new Text( "SELECT * FROM server_client WHERE server_id = " );
    befehl->append( sNum );
    befehl->append( " AND client_id = " );
    befehl->append( num );
    lock();
    datenbank->befehl( befehl->getText() );
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    bool ret = 0;
    if( res.zeilenAnzahl == 1 )
        ret = 1;
    res.destroy();
    return ret;
}

Text *ISDatenbank::getKlientKey( int cId )
{
    lock();
    if( !datenbank->befehl( Text( "SELECT schluessel FROM client WHERE id = " ) += cId ) )
    {
        unlock();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    Text *ret = new Text( res.values[ 0 ].getText() );
    res.destroy();
    return ret;
}

void ISDatenbank::unregisterKlient( int num, int sNum )
{
    Text *befehl = new Text( "DELETE FROM server_client WHERE client_id = " );
    befehl->append( num );
    befehl->append( " AND server_id = " );
    befehl->append( sNum );
    lock();
    datenbank->befehl( befehl->getText() );
    int za = datenbank->getZeilenAnzahl();
    unlock();
    if( za == 1 )
    {
        befehl->setText( "UPDATE server SET tasks = tasks - 1 WHERE id = " );
        befehl->append( sNum );
        lock();
        datenbank->befehl( befehl->getText() );
        unlock();
    }
    befehl->release();
}

bool ISDatenbank::setServerStatus( int id, int status )
{
    Text *befehl = new Text( "UPDATE server SET server_status_id = " );
    *befehl += status;
    *befehl += "WHERE id = ";
    *befehl += id;
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    bool ret = datenbank->getZeilenAnzahl() != 0;
    unlock();
    befehl->release();
    return ret;
}

bool ISDatenbank::setMaxClients( int id, int maxC )
{
    Text *befehl = new Text( "UPDATE server SET max_tasks = " );
    befehl->append( maxC );
    befehl->append( " WHERE id = " );
    befehl->append( id );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    bool ret = datenbank->getZeilenAnzahl() > 0;
    unlock();
    befehl->release();
    return ret;
}

bool ISDatenbank::serverIstNichtPausiert( int id )
{
    Text *befehl = new Text( "SELECT server_status_id FROM server WHERE id = " );
    befehl->append( id );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    bool ret = (int)res.values[ 0 ] == 3;
    res.destroy();
    return ret;
}

Text *ISDatenbank::getInformationsText( char *typ )
{
    lock();
    if( !datenbank->befehl( "SELECT text, typ FROM info_text ORDER BY insert_datum DESC LIMIT 1" ) )
    {
        unlock();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        *typ = 0;
        return 0;
    }
    *typ = (char)TextZuInt( res.values[ 1 ].getText(), 10 );
    Text *ret = new Text( res.values[ 0 ].getText() );
    res.destroy();
    return ret;
}

bool ISDatenbank::istSpielErlaubt( int spielId )
{
    Text *befehl = new Text( "SELECT erlaubt FROM spiel_art WHERE id = " );
    befehl->append( spielId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    bool ret = 0;
    if( res.zeilenAnzahl > 0 && res.values[ 0 ].istGleich( "t" ) )
        ret = 1;
    res.destroy();
    return ret;
}

bool ISDatenbank::istKarteErlaubt( int karteId )
{
    Text *befehl = new Text( "SELECT erlaubt FROM karte WHERE id = " );
    befehl->append( karteId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    bool ret = 0;
    if( res.zeilenAnzahl > 0 && res.values[ 0 ].istGleich( "t" ) )
        ret = 1;
    res.destroy();
    return ret;
}

Text *ISDatenbank::getAccountRufName( int accountId )
{
    Text *befehl = new Text( "SELECT ruf_name FROM account WHERE id = " );
    befehl->append( accountId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    Text *ret = new Text( res.values[ 0 ].getText() );
    res.destroy();
    return ret;
}

int ISDatenbank::getAccountId( char *rufName )
{
    Text *befehl = new Text( "SELECT id FROM account WHERE ruf_name = '" );
    befehl->append( rufName );
    befehl->append( "' LIMIT 1" );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
    res.destroy();
    return ret;
}

Array< int > *ISDatenbank::getAccountSpielStatistik( int accountId, int spielId )
{
    Text *befehl = new Text( "SELECT gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5 FROM spiel_statistik WHERE account_id = " );
    befehl->append( accountId );
    befehl->append( " AND spiel_art_id = " );
    befehl->append( spielId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    Array< int > *ret = new Array< int >();
    if( !res.zeilenAnzahl )
    {
        for( int i = 0; i < res.feldAnzahl; i++ )
            ret->add( 0, i );
        res.destroy();
        return ret;
    }
    for( int i = 0; i < res.feldAnzahl; i++ )
        ret->add( TextZuInt( res.values[ i ].getText(), 10 ), i );
    res.destroy();
    return ret;
}

int ISDatenbank::getAccountKarteSpiele( int accountId, int karteId )
{
    Text *befehl = new Text( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.id = b.spiel_id AND b.account_id = " );
    befehl->append( accountId );
    befehl->append( " AND a.karte_id = " );
    befehl->append( karteId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    int ret = res.values[ 0 ];
    res.destroy();
    return ret;
}

int ISDatenbank::getAccountKarteSpieleGewonnen( int accountId, int karteId )
{
    Text *befehl = new Text( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.id = b.spiel_id "
                             "AND b.spiel_spieler_status_id = 2 AND b.account_id = " );
    befehl->append( accountId );
    befehl->append( " AND a.karte_id = " );
    befehl->append( karteId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    int ret = res.values[ 0 ];
    res.destroy();
    return ret;
}

Text *ISDatenbank::getKarteName( int karteId )
{
    Text *befehl = new Text( "SELECT name FROM karte WHERE id = " );
    befehl->append( karteId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    Text *ret = new Text( res.values[ 0 ].getText() );
    res.destroy();
    return ret;
}

Text *ISDatenbank::getSpielName( int spielId )
{
    Text *befehl = new Text( "SELECT name FROM spiel_art WHERE id = " );
    befehl->append( spielId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    Text *ret = new Text( res.values[ 0 ].getText() );
    res.destroy();
    return ret;
}

Text *ISDatenbank::getChatroomName( int chatroomId )
{
    Text *befehl = new Text( "SELECT name FROM chatroom WHERE id = " );
    befehl->append( chatroomId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    Text *ret = new Text( res.values[ 0 ].getText() );
    res.destroy();
    return ret;
}

int ISDatenbank::getChatroomId( char *name )
{
    Text *befehl = new Text( "SELECT id FROM chatroom WHERE name = '" );
    befehl->append( name );
    befehl->append( "' LIMIT 1" );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
    res.destroy();
    return ret;
}

int ISDatenbank::getSpielId( int karteId )
{
    Text *befehl = new Text( "SELECT spiel_art_id FROM karte WHERE id = " );
    befehl->append( karteId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
    res.destroy();
    return ret;
}

int ISDatenbank::getSpielId( char *name )
{
    Text *befehl = new Text( "SELECT id FROM spiel_art WHERE name = '" );
    befehl->append( name );
    befehl->append( "'" );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
    res.destroy();
    return ret;
}

int ISDatenbank::getKarteId( char *name )
{
    Text *befehl = new Text( "SELECT id FROM karte WHERE name = '" );
    befehl->append( name );
    befehl->append( "'" );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
    res.destroy();
    return ret;
}

int ISDatenbank::getGruppenKarteId( int gruppeId )
{
    Text *befehl = new Text( "SELECT karte_id FROM gruppe WHERE id = " );
    befehl->append( gruppeId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
    res.destroy();
    return ret;
}

int ISDatenbank::getGruppeAdminId( int gruppeId )
{
    Text *befehl = new Text( "SELECT admin_account_id FROM gruppe WHERE id = " );
    befehl->append( gruppeId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
    res.destroy();
    return ret;
}

int ISDatenbank::getSpielerPunkte( int spielId, int accountId )
{
    Text *befehl = new Text( "SELECT sum( b.punkte ) FROM spiel a, spiel_spieler b, karte c WHERE a.karte_id = c.id "
                             "AND a.spiel_status_id = 5 AND c.spiel_art_id = " );
    befehl->append( spielId );
    befehl->append( " AND b.spiel_id = a.id AND b.account_id = " );
    befehl->append( accountId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
    res.destroy();
    return ret;
}

Array< int > *ISDatenbank::getAccountSpielArtListe( int cId )
{
    Text *befehl = new Text( "SELECT a.spiel_art_id FROM spiel_art_account a, account_client b "
                             "WHERE a.account_id = b.account_id AND a.end_dat IS NULL AND b.client_id = " );
    befehl->append( cId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    Array< int > *ret = new Array< int >();
    for( int i = 0; i < res.zeilenAnzahl; i++ )
        ret->add( TextZuInt( res.values[ i ].getText(), 10 ) );
    res.destroy();
    return ret;
}

int ISDatenbank::getNeusteSpielVersion( int sId )
{
    Text *befehl = new Text( "SELECT a.version FROM datei_gruppe a, spiel_art b WHERE a.id = b.datei_gruppe_id AND b.id = " );
    befehl->append( sId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
    res.destroy();
    return ret;
}

int ISDatenbank::getKupfer( int cId )
{
    Text *befehl = new Text( "SELECT a.kupfer FROM account a, account_client b WHERE a.id = b.account_id AND b.client_id = " );
    befehl->append( cId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
    res.destroy();
    return ret;
}

int ISDatenbank::getDateiGruppeVonSpiel( int sId )
{
    Text *befehl = new Text( "SELECT datei_gruppe_id FROM spiel_art WHERE id = " );
    befehl->append( sId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
    res.destroy();
    return ret;
}

Text *ISDatenbank::getDateiGruppePfad( int dgId )
{
    Text *befehl = new Text( "SELECT pfad FROM datei_gruppe WHERE id = " );
    befehl->append( dgId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    Text *ret = new Text( res.values[ 0 ].getText() );
    res.destroy();
    return ret;
}

Array< int > *ISDatenbank::getAccountKarteListe( int cId, int sId )
{
    Text *befehl = new Text( "SELECT a.karte_id FROM karte_account a, account_client b, karte c "
                             "WHERE c.id = a.karte_id AND a.account_id = b.account_id AND a.end_dat IS NULL AND b.client_id = " );
    befehl->append( cId );
    befehl->append( " AND c.spiel_art_id = " );
    befehl->append( sId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    Array< int > *ret = new Array< int >();
    for( int i = 0; i < res.zeilenAnzahl; i++ )
        ret->add( TextZuInt( res.values[ i ].getText(), 10 ) );
    res.destroy();
    return ret;
}

bool ISDatenbank::hatAccountKarte( int account, int karte )
{
    Text *befehl = new Text( "SELECT karte_id FROM karte_account WHERE end_dat IS NULL AND karte_id = " );
    befehl->append( karte );
    befehl->append( " AND account_id = " );
    befehl->append( account );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    bool ret = datenbank->getZeilenAnzahl() != 0;
    unlock();
    befehl->release();
    return ret;
}

bool ISDatenbank::hatAccountSpiel( int account, int spiel )
{
    Text *befehl = new Text( "SELECT spiel_art_id FROM spiel_art_account WHERE end_dat IS NULL AND spiel_art_id = " );
    befehl->append( spiel );
    befehl->append( " AND account_id = " );
    befehl->append( account );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    bool ret = datenbank->getZeilenAnzahl() != 0;
    unlock();
    befehl->release();
    return ret;
}

Array< int > *ISDatenbank::getAccountKarteGespieltListe( int accountId, int spielArt )
{
    Text *befehl = new Text( "SELECT distinct( c.id ) FROM spiel a, spiel_spieler b, karte c WHERE "
                             "a.karte_id = c.id AND b.spiel_id = a.id AND b.account_id = " );
    befehl->append( accountId );
    befehl->append( " AND c.spiel_art_id = " );
    befehl->append( spielArt );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    Array< int > *ret = new Array< int >();
    for( int i = 0; i < res.zeilenAnzahl; i++ )
        ret->set( res.values[ i ], i );
    res.destroy();
    return ret;
}

Array< int > *ISDatenbank::getAccountSpielGespieltListe( int accountId )
{
    Text *befehl = new Text( "SELECT distinct( c.spiel_art_id ) FROM spiel a, spiel_spieler b, karte c WHERE "
                             "a.karte_id = c.id AND b.spiel_id = a.id AND b.account_id = " );
    befehl->append( accountId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    Array< int > *ret = new Array< int >();
    for( int i = 0; i < res.zeilenAnzahl; i++ )
        ret->set( res.values[ i ], i );
    res.destroy();
    return ret;
}

int ISDatenbank::getDateiGruppeVonPfad( char *pfad )
{
    Text *befehl = new Text( "SELECT id FROM datei_gruppe WHERE pfad = '" );
    befehl->append( pfad );
    befehl->append( "'" );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
    res.destroy();
    return ret;
}

int ISDatenbank::getNeusteDateiGruppe( int dg )
{
    Text *befehl = new Text( "SELECT version FROM datei_gruppe WHERE id = " );
    befehl->append( dg );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
    res.destroy();
    return ret;
}

bool ISDatenbank::getGruppeSpielerAdd( int gruppeId )
{
    Text *befehl = new Text( "SELECT spiel_starten FROM gruppe WHERE id = " );
    befehl->append( gruppeId );
    lock();
    if( !datenbank->befehl( befehl->getText() ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    bool ret = res.values[ 0 ].istGleich( "f" );
    res.destroy();
    return ret;
}

Result ISDatenbank::getSpielerListe( char *suche, int *seite, int *maxSeite, int sortStalte, bool backwords )
{
    Text *befehl = new Text( "SELECT count( a.id ) FROM account a, "
                             "( SELECT a.id, max( b.datum ) "
                             "  FROM account a LEFT JOIN "
                             "  ( SELECT g.spiel_art_id, i.account_id"
                             "    FROM karte g, spiel h, spiel_spieler i "
                             "    WHERE i.spiel_id = h.id AND h.karte_id = g.id AND h.beginn_datum = "
                             "   ( SELECT max( x.beginn_datum ) FROM spiel x, spiel_spieler y WHERE y.spiel_id = x.id AND y.account_id = i.account_id ) ) f ON a.id = f.account_id "
                             "  LEFT JOIN account_online b ON b.account_id = a.id "
                             "  LEFT JOIN spiel_statistik e ON e.account_id = a.id "
                             "  LEFT JOIN spiel_art c ON c.id = f.spiel_art_id "
                             "  LEFT JOIN karte d ON c.id = d.spiel_art_id "
                             "  WHERE a.name LIKE '" );
    befehl->append( suche );
    befehl->append( "' AND d.spiel_art_id = c.id "
                    "  AND e.spiel_art_id = f.spiel_art_id "
                    "  GROUP BY a.id ) b "
                    "WHERE a.id = b.id" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        Result res = { 0, 0, 0, 0 };
        return res;
    }
    Result res = datenbank->getResult();
    unlock();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        befehl->release();
        Result res = { 0, 0, 0, 0 };
        return res;
    }
    int entrys = res.values[ 0 ];
    res.destroy();
    *maxSeite = entrys / 21;
    if( entrys % 21 )
        ( *maxSeite )++;
    if( *seite > *maxSeite )
        *seite = *maxSeite;
    if( !( *seite ) )
    {
        befehl->release();
        Result res = { 0, 0, 0, 0 };
        return res;
    }
    befehl->setText( "SELECT a.id, a.ruf_name, max( b.datum ), c.name, d.name, e.punkte "
                     "FROM account a LEFT JOIN "
                     "( SELECT g.spiel_art_id, i.account_id "
                     "  FROM karte g, spiel h, spiel_spieler i "
                     "  WHERE i.spiel_id = h.id AND h.karte_id = g.id AND h.beginn_datum = "
                     "( SELECT max( x.beginn_datum ) FROM spiel x, spiel_spieler y WHERE y.spiel_id = x.id AND y.account_id = i.account_id ) ) f ON a.id = f.account_id "
                     "LEFT JOIN account_online b ON b.account_id = a.id "
                     "LEFT JOIN spiel_statistik e ON e.account_id = a.id "
                     "LEFT JOIN spiel_art c ON c.id = f.spiel_art_id "
                     "LEFT JOIN karte d ON c.id = d.spiel_art_id "
                     "WHERE a.name LIKE '" );
    befehl->append( suche );
    befehl->append( "' AND ( d.spiel_art_id = c.id "
                    "AND e.spiel_art_id = f.spiel_art_id ) "
                    "OR d.spiel_art_id IS NULL "
                    "GROUP BY a.id, a.ruf_name, c.name, d.name, e.punkte ORDER BY " );
    befehl->append( sortStalte + 2 );
    if( backwords )
        befehl->append( " DESC" );
    befehl->append( " OFFSET " );
    befehl->append( ( ( *seite ) - 1 ) * 21 );
    befehl->append( " LIMIT 21" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        Result res = { 0, 0, 0, 0 };
        return res;
    }
    res = datenbank->getResult();
    unlock();
    befehl->release();
    return res;
}

bool ISDatenbank::getSpielerAktivity( int accountId, RCArray< Text > *datum, Array< double > *stOnline, Array< double > *stGespielt,
                                      Array< int > *anzSpiele, Array< int > *anzGewonnen )
{
    Datum *beg = getDatum();
    Datum *end = getDatum();
    beg->minusTag( 29 );
    end->minusTag( 29 );
    end->plusTag( 1 );
    for( int i = 0; i < 30; i++ )
    { // 30 Tage Rückblick
        datum->set( beg->getDatum( "d-m-y" ), i );
        Text *b = beg->getDatum( "y-m-d" );
        Text *e = end->getDatum( "y-m-d" );
        stOnline->set( getOnlineSeconds( accountId, *b, *e ) / ( 60.0 * 60 ), i );
        stGespielt->set( getGespieltSeconds( accountId, *b, *e ) / ( 60.0 * 60 ), i );
        anzSpiele->set( getGespieltSpiele( accountId, *b, *e ), i );
        anzGewonnen->set( getGewonnenSpiele( accountId, *b, *e ), i );
        b->release();
        e->release();
        beg->plusTag( 1 );
        end->plusTag( 1 );
    }
    return 1;
}

int ISDatenbank::getOnlineSeconds( int accountId, char *beg, char *end )
{
    int sec = 0;
    Text *befehl = new Text( "SELECT date_part( 'epoch', ( SELECT sum( now() - '" );
    befehl->append( beg );
    befehl->append( "' ) FROM account_online WHERE datum < '" );
    befehl->append( beg );
    befehl->append( "' AND now() < '" );
    befehl->append( end );
    befehl->append( "' AND now() > '" );
    befehl->append( beg );
    befehl->append( "' AND end_datum IS NULL AND account_id = " );
    befehl->append( accountId );
    befehl->append( " )::INTERVAL )" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        sec += (int)res.values[ 0 ];
    res.destroy();
    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( now() - datum ) FROM account_online WHERE datum > '" );
    befehl->append( beg );
    befehl->append( "' AND now() < '" );
    befehl->append( end );
    befehl->append( "' AND end_datum IS NULL AND account_id = " );
    befehl->append( accountId );
    befehl->append( " )::INTERVAL )" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        sec += (int)res.values[ 0 ];
    res.destroy();
    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
    befehl->append( end );
    befehl->append( "' - datum ) FROM account_online WHERE datum > '" );
    befehl->append( beg );
    befehl->append( "' AND datum < '" );
    befehl->append( end );
    befehl->append( "' AND now() > '" );
    befehl->append( end );
    befehl->append( "' AND end_datum IS NULL AND account_id = " );
    befehl->append( accountId );
    befehl->append( " )::INTERVAL )" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        sec += (int)res.values[ 0 ];
    res.destroy();
    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
    befehl->append( end );
    befehl->append( "'::TIMESTAMP WITH TIME ZONE - '" );
    befehl->append( beg );
    befehl->append( "' ) FROM account_online WHERE datum < '" );
    befehl->append( beg );
    befehl->append( "' AND now() > '" );
    befehl->append( end );
    befehl->append( "' AND end_datum IS NULL AND account_id = " );
    befehl->append( accountId );
    befehl->append( " )::INTERVAL )" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        sec += (int)res.values[ 0 ];
    res.destroy();
    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( end_datum - '" );
    befehl->append( beg );
    befehl->append( "' ) FROM account_online WHERE datum < '" );
    befehl->append( beg );
    befehl->append( "' AND end_datum < '" );
    befehl->append( end );
    befehl->append( "' AND end_datum > '" );
    befehl->append( beg );
    befehl->append( "' AND account_id = " );
    befehl->append( accountId );
    befehl->append( " )::INTERVAL )" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        sec += (int)res.values[ 0 ];
    res.destroy();
    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( end_datum - datum ) FROM account_online WHERE datum > '" );
    befehl->append( beg );
    befehl->append( "' AND end_datum < '" );
    befehl->append( end );
    befehl->append( "' AND account_id = " );
    befehl->append( accountId );
    befehl->append( " )::INTERVAL )" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        sec += (int)res.values[ 0 ];
    res.destroy();
    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
    befehl->append( end );
    befehl->append( "' - datum ) FROM account_online WHERE datum > '" );
    befehl->append( beg );
    befehl->append( "' AND datum < '" );
    befehl->append( end );
    befehl->append( "' AND end_datum > '" );
    befehl->append( end );
    befehl->append( "' AND account_id = " );
    befehl->append( accountId );
    befehl->append( " )::INTERVAL )" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        sec += (int)res.values[ 0 ];
    res.destroy();
    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
    befehl->append( end );
    befehl->append( "'::TIMESTAMP WITH TIME ZONE - '" );
    befehl->append( beg );
    befehl->append( "' ) FROM account_online WHERE datum < '" );
    befehl->append( beg );
    befehl->append( "' AND end_datum > '" );
    befehl->append( end );
    befehl->append( "' AND account_id = " );
    befehl->append( accountId );
    befehl->append( " )::INTERVAL )" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        sec += (int)res.values[ 0 ];
    res.destroy();
    befehl->release();
    return sec;
}

int ISDatenbank::getGespieltSeconds( int accountId, char *beg, char *end )
{
    int sec = 0;
    Text *befehl = new Text( "SELECT date_part( 'epoch', ( SELECT sum( now() - '" );
    befehl->append( beg );
    befehl->append( "' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
    befehl->append( beg );
    befehl->append( "' AND now() < '" );
    befehl->append( end );
    befehl->append( "' AND now() > '" );
    befehl->append( beg );
    befehl->append( "' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = " );
    befehl->append( accountId );
    befehl->append( " )::INTERVAL )" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        sec += (int)res.values[ 0 ];
    res.destroy();
    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( now() - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
    befehl->append( beg );
    befehl->append( "' AND now() < '" );
    befehl->append( end );
    befehl->append( "' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = " );
    befehl->append( accountId );
    befehl->append( " )::INTERVAL )" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        sec += (int)res.values[ 0 ];
    res.destroy();
    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
    befehl->append( end );
    befehl->append( "' - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
    befehl->append( beg );
    befehl->append( "' AND a.beginn_datum < '" );
    befehl->append( end );
    befehl->append( "' AND now() > '" );
    befehl->append( end );
    befehl->append( "' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = " );
    befehl->append( accountId );
    befehl->append( " )::INTERVAL )" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        sec += (int)res.values[ 0 ];
    res.destroy();
    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
    befehl->append( end );
    befehl->append( "'::TIMESTAMP WITH TIME ZONE - '" );
    befehl->append( beg );
    befehl->append( "' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
    befehl->append( beg );
    befehl->append( "' AND now() > '" );
    befehl->append( end );
    befehl->append( "' AND a.end_datum IS NULL AND a.id = b.spiel_id AND b.account_id = " );
    befehl->append( accountId );
    befehl->append( " )::INTERVAL )" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        sec += (int)res.values[ 0 ];
    res.destroy();
    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( a.end_datum - '" );
    befehl->append( beg );
    befehl->append( "' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
    befehl->append( beg );
    befehl->append( "' AND a.end_datum < '" );
    befehl->append( end );
    befehl->append( "' AND a.end_datum > '" );
    befehl->append( beg );
    befehl->append( "' AND a.id = b.spiel_id AND b.account_id = " );
    befehl->append( accountId );
    befehl->append( " )::INTERVAL )" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        sec += (int)res.values[ 0 ];
    res.destroy();
    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( a.end_datum - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
    befehl->append( beg );
    befehl->append( "' AND a.end_datum < '" );
    befehl->append( end );
    befehl->append( "' AND a.id = b.spiel_id AND b.account_id = " );
    befehl->append( accountId );
    befehl->append( " )::INTERVAL )" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        sec += (int)res.values[ 0 ];
    res.destroy();
    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
    befehl->append( end );
    befehl->append( "' - a.beginn_datum ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
    befehl->append( beg );
    befehl->append( "' AND a.beginn_datum < '" );
    befehl->append( end );
    befehl->append( "' AND a.end_datum > '" );
    befehl->append( end );
    befehl->append( "' AND a.id = b.spiel_id AND account_id = " );
    befehl->append( accountId );
    befehl->append( " )::INTERVAL )" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        sec += (int)res.values[ 0 ];
    res.destroy();
    befehl->setText( "SELECT date_part( 'epoch', ( SELECT sum( '" );
    befehl->append( end );
    befehl->append( "'::TIMESTAMP WITH TIME ZONE - '" );
    befehl->append( beg );
    befehl->append( "' ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
    befehl->append( beg );
    befehl->append( "' AND a.end_datum > '" );
    befehl->append( end );
    befehl->append( "' AND a.id = b.spiel_id AND account_id = " );
    befehl->append( accountId );
    befehl->append( " )::INTERVAL )" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        sec += (int)res.values[ 0 ];
    res.destroy();
    befehl->release();
    return sec;
}

int ISDatenbank::getGespieltSpiele( int accountId, char *beg, char *end )
{
    int anz = 0;
    Text *befehl = new Text( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
    befehl->append( beg );
    befehl->append( "' AND a.end_datum < '" );
    befehl->append( end );
    befehl->append( "' AND a.end_datum > '" );
    befehl->append( beg );
    befehl->append( "' AND a.id = b.spiel_id AND b.account_id = " );
    befehl->append( accountId );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        anz += (int)res.values[ 0 ];
    res.destroy();
    befehl->setText( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
    befehl->append( beg );
    befehl->append( "' AND a.end_datum < '" );
    befehl->append( end );
    befehl->append( "' AND a.id = b.spiel_id AND b.account_id = " );
    befehl->append( accountId );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        anz += (int)res.values[ 0 ];
    res.destroy();
    befehl->release();
    return anz;
}

int ISDatenbank::getGewonnenSpiele( int accountId, char *beg, char *end )
{
    int anz = 0;
    Text *befehl = new Text( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum < '" );
    befehl->append( beg );
    befehl->append( "' AND a.end_datum < '" );
    befehl->append( end );
    befehl->append( "' AND a.end_datum > '" );
    befehl->append( beg );
    befehl->append( "' AND a.id = b.spiel_id AND b.spiel_spieler_status_id = 2 AND b.account_id = " );
    befehl->append( accountId );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        anz += (int)res.values[ 0 ];
    res.destroy();
    befehl->setText( "SELECT count( a.id ) FROM spiel a, spiel_spieler b WHERE a.beginn_datum > '" );
    befehl->append( beg );
    befehl->append( "' AND a.end_datum < '" );
    befehl->append( end );
    befehl->append( "' AND a.id = b.spiel_id AND b.spiel_spieler_status_id = 2 AND b.account_id = " );
    befehl->append( accountId );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    res = datenbank->getResult();
    unlock();
    if( res.zeilenAnzahl )
        anz += (int)res.values[ 0 ];
    res.destroy();
    befehl->release();
    return anz;
}

Result ISDatenbank::getSpielPartnerListe( int accountId )
{
    Text *befehl = new Text( "SELECT account_id_b, anzahl, karte_id FROM account_mitspieler WHERE account_id_a = " );
    befehl->append( accountId );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        Result res = { 0, 0, 0, 0 };
        return res;
    }
    Result res = datenbank->getResult();
    unlock();
    befehl->release();
    return res;
}

Result ISDatenbank::getSpielStatistikListe( int accountId, int *seite, int *maxSeite, int sortStalte, bool backwords )
{
    Text *befehl = new Text( "SELECT count( spiel_art_id ) FROM spiel_statistik WHERE account_id = " );
    befehl->append( accountId );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        Result res = { 0, 0, 0, 0 };
        return res;
    }
    Result res = datenbank->getResult();
    unlock();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        befehl->release();
        Result res = { 0, 0, 0, 0 };
        return res;
    }
    int entrys = res.values[ 0 ];
    res.destroy();
    *maxSeite = entrys / 21;
    if( entrys % 21 )
        ( *maxSeite )++;
    if( *seite > *maxSeite )
        *seite = *maxSeite;
    if( !( *seite ) )
    {
        befehl->release();
        Result res = { 0, 0, 0, 0 };
        return res;
    }
    befehl->setText( "SELECT a.id, a.name, b.gespielt, b.gewonnen, b.verloren, b.punkte, b.bw0, b.bw1, b.bw2, b.bw3, "
                     "b.bw4, b.bw5 FROM spiel_art a, spiel_statistik b WHERE a.id = b.spiel_art_id AND b.account_id = " );
    befehl->append( accountId );
    befehl->append( " ORDER BY " );
    befehl->append( sortStalte + 2 );
    if( backwords )
        befehl->append( " DESC" );
    befehl->append( " OFFSET " );
    befehl->append( ( ( *seite ) - 1 ) * 18 );
    befehl->append( " LIMIT 18" );
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        Result res = { 0, 0, 0, 0 };
        return res;
    }
    res = datenbank->getResult();
    unlock();
    befehl->release();
    return res;
}

AHDaten *ISDatenbank::getSpielHistorie( int accountId, InformationServer *is )
{
    Text *befehl = new Text( "SELECT a.id, a.karte_id, c.name, d.name, substring( a.beginn_datum::CHARACTER VARYING FOR 16 ), "
                             "b.spiel_spieler_status_id, a.spiel_status_id, count( e.spiel_id ) "
                             "FROM spiel a, spiel_spieler b, spiel_art c, karte d, (SELECT spiel_id FROM spiel_spieler) e "
                             "WHERE a.id = e.spiel_id AND a.karte_id = d.id AND d.spiel_art_id = c.id "
                             "AND a.id = b.spiel_id AND b.account_id = " );
    *befehl += accountId;
    *befehl += " GROUP BY a.id, a.karte_id, c.name, d.name, a.beginn_datum, b.spiel_spieler_status_id, a.spiel_status_id "
        "ORDER BY beginn_datum DESC LIMIT 20";
    lock();
    if( !datenbank->befehl( *befehl ) )
    {
        unlock();
        befehl->release();
        return 0;
    }
    Result spielListe = datenbank->getResult();
    unlock();
    AHDaten *ret = new AHDaten();
    for( int i = 0; i < spielListe.zeilenAnzahl; i++ )
    {
        SpielerTeamStruktur *sts = new SpielerTeamStruktur();
        bool stsOK = 1;
        KartenLeser *reader = new KartenLeser( spielListe.values[ 1 + i * spielListe.feldAnzahl ], is );
        if( !reader->ladeSpielerTeamStruktur( sts ) )
            stsOK = 0;
        reader->release();
        AHSpielDaten *spiel = new AHSpielDaten();
        spiel->id = spielListe.values[ i * spielListe.feldAnzahl ];
        spiel->karteId = spielListe.values[ 1 + i * spielListe.feldAnzahl ];
        spiel->spiel->setText( spielListe.values[ 2 + i * spielListe.feldAnzahl ] );
        spiel->karte->setText( spielListe.values[ 3 + i * spielListe.feldAnzahl ] );
        spiel->datum->setText( spielListe.values[ 4 + i * spielListe.feldAnzahl ] );
        switch( (int)spielListe.values[ 5 + i * spielListe.feldAnzahl ] )
        {
        case 1:
            spiel->status->setText( "Verloren" );
            break;
        case 2:
            spiel->status->setText( "Gewonnen" );
            break;
        case 3:
            spiel->status->setText( "Nicht Anwesend" );
            break;
        case 4:
            spiel->status->setText( "Beobachter" );
            break;
        case 5:
            spiel->status->setText( "Unentschieden" );
            break;
        }
        switch( (int)spielListe.values[ 6 + i * spielListe.feldAnzahl ] )
        {
        case 1:
            spiel->spielStatus->setText( "Beginnt" );
            break;
        case 2:
            spiel->spielStatus->setText( "Läuft" );
            break;
        case 3:
            spiel->spielStatus->setText( "Abgebrochen" );
            break;
        case 4:
            spiel->spielStatus->setText( "Fehlerhaft" );
            break;
        case 5:
            spiel->spielStatus->setText( "Beendet" );
            break;
        case 6:
            spiel->spielStatus->setText( "Unbewertet" );
            break;
        }
        spiel->sAnzahl = spielListe.values[ 7 + i * spielListe.feldAnzahl ];
        *befehl = "SELECT substring( (end_datum - beginn_datum)::CHARACTER VARYING FOR 8) FROM spiel WHERE id = ";
        *befehl += spielListe.values[ i * spielListe.feldAnzahl ].getText();
        lock();
        if( datenbank->befehl( *befehl ) )
        {
            Result dauer = datenbank->getResult();
            unlock();
            if( dauer.zeilenAnzahl && dauer.values[ 0 ].getLength() )
                spiel->dauer->setText( dauer.values[ 0 ] );
        }
        else
            unlock();
        int gewinnerTeam = -1;
        if( stsOK )
        {
            *befehl = "SELECT team_id FROM spiel_spieler WHERE spiel_spieler_status_id = 2 AND spiel_id = ";
            *befehl += spielListe.values[ i * spielListe.feldAnzahl ].getText();
            lock();
            if( datenbank->befehl( *befehl ) )
            {
                Result team = datenbank->getResult();
                unlock();
                if( team.zeilenAnzahl && team.values[ 0 ].getLength() && sts->teamName->z( team.values[ 0 ] ) )
                {
                    spiel->gewinner->setText( sts->teamName->z( team.values[ 0 ] )->getText() );
                    gewinnerTeam = team.values[ 0 ];
                }
            }
            else
                unlock();
        }
        *befehl = "SELECT a.ruf_name, b.team_id, b.punkte, b.spiel_spieler_status_id, b.spieler_nummer FROM account a, spiel_spieler b WHERE b.account_id = a.id AND spiel_id = ";
        *befehl += spielListe.values[ i * spielListe.feldAnzahl ].getText();
        *befehl += " ORDER BY team_id";
        lock();
        if( datenbank->befehl( *befehl ) )
        {
            Result spielerListe = datenbank->getResult();
            unlock();
            for( int j = 0; j < spielerListe.zeilenAnzahl; j++ )
            {
                int tAnz = spiel->teams->getEintragAnzahl();
                int index = -1;
                for( int k = 0; k < tAnz; k++ )
                {
                    if( spiel->teams->z( k )->id == (int)spielerListe.values[ 1 + j * spielerListe.feldAnzahl ] )
                    {
                        index = k;
                        break;
                    }
                }
                if( index < 0 )
                {
                    index = tAnz;
                    AHSpielTeamDaten *team = new AHSpielTeamDaten();
                    team->id = spielerListe.values[ 1 + j * spielerListe.feldAnzahl ];
                    if( sts->teamName->z( team->id ) )
                        team->name->setText( sts->teamName->z( team->id )->getText() );
                    team->sAnzahl = 0;
                    if( team->id == gewinnerTeam )
                        team->status->setText( "Gewonnen" );
                    else
                        team->status->setText( "Verloren" );
                    if( sts->teamFarbe->hat( team->id ) )
                        team->farbe = sts->teamFarbe->get( team->id );
                    else
                        team->farbe = 0;
                    spiel->teams->set( team, index );
                }
                AHSpielSpielerDaten *spieler = new AHSpielSpielerDaten();
                spieler->name->setText( spielerListe.values[ j * spielerListe.feldAnzahl ] );
                spieler->punkte = spielerListe.values[ 2 + j * spielerListe.feldAnzahl ];
                if( sts->spielerFarbe->hat( (int)spielerListe.values[ 4 + j * spielerListe.feldAnzahl ] - 1 ) )
                    spieler->farbe = sts->spielerFarbe->get( (int)spielerListe.values[ 4 + j * spielerListe.feldAnzahl ] - 1 );
                else
                    spieler->farbe = 0;
                switch( (int)spielerListe.values[ 3 + j * spielerListe.feldAnzahl ] )
                {
                case 1:
                    spieler->status->setText( "Verloren" );
                    break;
                case 2:
                    spieler->status->setText( "Gewonnen" );
                    break;
                case 3:
                    spieler->status->setText( "Nicht Anwesend" );
                    break;
                case 4:
                    spieler->status->setText( "Beobachter" );
                    break;
                case 5:
                    spieler->status->setText( "Unentschieden" );
                    break;
                }
                spiel->teams->z( index )->sAnzahl++;
                spiel->teams->z( index )->spieler->add( spieler );
            }
        }
        else
            unlock();
        sts->release();
        ret->spiele->set( spiel, i );
    }
    return ret;
}

bool ISDatenbank::getHistorieServerPortIp( int clientId, int spielId, int *port, Text *ip )
{
    lock();
    if( !datenbank->befehl( Text( "SELECT a.id, a.port, a.ip FROM server a, server_historie_spiel b "
                                  "WHERE a.id = b.server_historie_id AND a.tasks < a.max_tasks - 1 AND "
                                  "a.server_status_id = 3 AND b.spiel_id = " ) += spielId ) )
    {
        unlock();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    if( !res.zeilenAnzahl )
    {
        res.destroy();
        return 0;
    }
    int id = res.values[ 0 ];
    *port = res.values[ 1 ];
    *ip = res.values[ 2 ].getText();
    res.destroy();
    Text *befehl = new Text( "INSERT INTO server_client( client_id, server_id ) VALUES ( " );
    befehl->append( clientId );
    befehl->append( ", " );
    befehl->append( id );
    befehl->append( " )" );
    bool ret = 1;
    lock();
    ret &= datenbank->befehl( Text( "DELETE FROM server_client a USING server b WHERE b.server_typ_name = 'historie' AND b.id = a.server_id AND a.client_id = " ) += clientId );
    ret &= datenbank->befehl( *befehl );
    unlock();
    befehl->release();
    return ret;
}

bool ISDatenbank::hatKlientRecht( int kId, int recht )
{
    Text befehl = "SELECT a.* FROM account_user_rechte a, account_client b WHERE a.account_id = b.account_id AND b.client_id = ";
    befehl += kId;
    befehl += " AND a.user_rechte_id = ";
    befehl += recht;
    lock();
    datenbank->befehl( befehl );
    int num = datenbank->getZeilenAnzahl();
    unlock();
    return num == 1;
}

Result ISDatenbank::getKartenListe( int kId, char *suchFilter, char sortSpalte, char sortRichtung )
{
    Text befehl = "SELECT a.id, a.name, b.name, c.kupfer, a.verkauft, a.max_spieler FROM karte a ";
    befehl += "INNER JOIN spiel_art b ON a.spiel_art_id = b.id ";
    befehl += "LEFT JOIN karte_kauf_erlaubt c ON a.id = c.karte_id ";
    befehl += "INNER JOIN account_client d ON d.account_id = a.account_id ";
    befehl += "WHERE d.client_id = ";
    befehl += kId;
    befehl += " AND a.name LIKE'%";
    befehl += suchFilter;
    befehl += "%' ORDER BY ";
    befehl += sortSpalte + 2;
    if( sortRichtung ) // absteigend
        befehl += " DESC";
    lock();
    if( !datenbank->befehl( befehl ) )
    {
        unlock();
        Result res = { 0, 0, 0, 0 };
        return res;
    }
    Result res = datenbank->getResult();
    unlock();
    return res;
}

bool ISDatenbank::getEditorServerPortIp( int clientId, int karteId, int *port, Text *ip )
{
    Text befehl = "SELECT a.port, a.ip, a.id FROM server a, karte b, account_client c ";
    befehl += "WHERE a.id = b.server_editor_id AND b.account_id = c.account_id AND a.server_status_id = 3 AND c.client_id = ";
    befehl += clientId;
    befehl += " AND b.id = ";
    befehl += karteId;
    lock();
    if( !datenbank->befehl( befehl ) )
    {
        unlock();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    *port = res.values[ 0 ];
    ip->setText( res.values[ 1 ] );
    int id = res.values[ 2 ];
    res.destroy();
    befehl = "INSERT INTO server_client( client_id, server_id ) VALUES ( ";
    befehl += clientId;
    befehl += ", ";
    befehl += id;
    befehl += " )";
    bool ret = 1;
    lock();
    ret &= datenbank->befehl( Text( "SELECT a.server_id FROM server_client a, server b WHERE a.server_id = b.id AND b.server_typ_name = 'editor' AND a.client_id = " ) += clientId );
    ret &= datenbank->befehl( Text( "DELETE FROM server_client a USING server b WHERE b.id = a.server_id AND b.server_typ_name = 'editor' AND a.client_id = " ) += clientId );
    ret &= datenbank->befehl( befehl );
    unlock();
    return 1;
}

bool ISDatenbank::getKartenServerPortIp( int clientId, int karteId, int *port, Text *ip )
{
    Text befehl = "SELECT a.port, a.ip, a.id FROM server a, karte b ";
    befehl += "WHERE a.id = b.server_karten_id AND a.server_status_id = 3 AND b.id = ";
    befehl += karteId;
    if( !karteId )
        befehl = "SELECT port, ip, id FROM server WHERE server_typ_name = 'karten' AND server_status_id = 3 LIMIT 1";
    lock();
    if( !datenbank->befehl( befehl ) )
    {
        unlock();
        return 0;
    }
    Result res = datenbank->getResult();
    unlock();
    if( !res.zeilenAnzahl )
        return 0;
    *port = res.values[ 0 ];
    ip->setText( res.values[ 1 ] );
    int id = res.values[ 2 ];
    res.destroy();
    if( clientId )
    {
        befehl = "INSERT INTO server_client( client_id, server_id ) VALUES ( ";
        befehl += clientId;
        befehl += ", ";
        befehl += id;
        befehl += " )";
        bool ret = 1;
        lock();
        ret &= datenbank->befehl( Text( "SELECT a.server_id FROM server_client a, server b WHERE b.id = a.server_id AND b.server_typ_name = 'karten' AND a.client_id = " ) += clientId );
        ret &= datenbank->befehl( Text( "DELETE FROM server_client a USING server b WHERE b.id = a.server_id AND b.server_typ_name = 'karten' AND a.client_id = " ) += clientId );
        ret &= datenbank->befehl( befehl );
        unlock();
    }
    return 1;
}

// constant
Text *ISDatenbank::getLetzterFehler() const
{
    return datenbank->getLetzterFehler();
}

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

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