#include "StatistikLeser.h"

// Inhalt der StatistikLeser Klasse aus StatistikLeser.h
// Konstruktor
StatistikLeser::StatistikLeser( int spielId )
    : ReferenceCounter()
{
    nachrichten = new SpielNachricht( spielId );
    bestenliste = new VideoBestenliste( Framework::defaultUI( 0, 0 ) );
    map = new VideoKarte();
    spieler = new RCArray< VideoSpieler >();
    ssdgs = new Array< SSDGesamtSpieler * >();
    ssdgt = new Array< SSDGesamtTeam * >();
    ssdr = new Array< SSDRunde * >();
    spielerAnzahl = 0;
    teamAnzahl = 0;
    rundenAnzahl = 0;
    Text f;
    fehler = nachrichten->hatFehler( &f );
    if( fehler )
        return;
    // Spiel Initialisieren
    spielerAnzahl = nachrichten->getSVD()->spielerAnzahl;
    teamAnzahl = nachrichten->getTeamAnzahl();
    int maxTeam = 0;
    for( int i = 0; i < spielerAnzahl; i++ )
    {
        SpielerVideoDaten *dat = nachrichten->getSPVD( i );
        VideoSpieler *tmp = new VideoSpieler( dat );
        bestenliste->addSpieler( tmp );
        spieler->set( tmp, i );
        maxTeam = maxTeam < dat->team ? dat->team : maxTeam;
    }
    maxTeam++;
    bestenliste->setTeamAnzahl( maxTeam );
    for( int i = 0; i < nachrichten->getTeamAnzahl(); i++ )
    {
        TeamVideoDaten *dat = nachrichten->getTVD( i );
        bestenliste->setTeamMaxPunkte( dat->teamNummer, dat->maxPunkte );
        bestenliste->setTeamPunkte( dat->teamNummer, dat->punkte );
    }
    RundeVideoDaten *rDat = nachrichten->getRVD();
    map->setSize( rDat->mapBreite, rDat->mapHöhe );
    for( int i = 0; i < spielerAnzahl; i++ )
    {
        RundeSpielerVideoDaten *dat = nachrichten->getRSVD( i );
        spieler->z( i )->neuRunde( 1, dat, 1 );
    }
    Array< int > rundenSieger;
    Array< int > rundenDauer;
    VideoMSG *nMsg = 0;
    double sZeit = 0;
    // Spiel nachstellen
    while( 1 )
    {
        while( !nMsg || nMsg->typ )
        {
            if( !nMsg )
                nMsg = nachrichten->GetNextNachricht();
            if( !nMsg )
                break;
            if( !nMsg->typ )
                break;
            VideoAktionMSG *ak = (VideoAktionMSG *)nMsg;
            switch( ak->aktion )
            {
            case 0: // T_Links Press
                for( int i = 0; i < spielerAnzahl; i++ )
                {
                    if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
                    {
                        spieler->z( i )->setLinksKurve( 1 );
                        break;
                    }
                }
                break;
            case 1: // T_Links Release
                for( int i = 0; i < spielerAnzahl; i++ )
                {
                    if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
                    {
                        spieler->z( i )->setLinksKurve( 0 );
                        break;
                    }
                }
                break;
            case 2: // T_Rechts Press
                for( int i = 0; i < spielerAnzahl; i++ )
                {
                    if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
                    {
                        spieler->z( i )->setRechtsKurve( 1 );
                        break;
                    }
                }
                break;
            case 3: // T_Rechts Release
                for( int i = 0; i < spielerAnzahl; i++ )
                {
                    if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
                    {
                        spieler->z( i )->setRechtsKurve( 0 );
                        break;
                    }
                }
                break;
            case 5: // Linien Unterbrechung
                if( 1 )
                {
                    VideoLinieMSG *lMsg = (VideoLinieMSG *)ak;
                    for( int i = 0; i < spielerAnzahl; i++ )
                    {
                        if( spieler->z( i )->getSpielerNummer() == ak->spielerNummer )
                        {
                            spieler->z( i )->setLinienUnterbrechung( lMsg->unterbrechung != 0 );
                            break;
                        }
                    }
                }
                break;
            }
            nMsg = 0;
        }
        if( !nMsg )
            break;
        sZeit += TICK;
        bool rEnd = 0;
        int tmpTeam = -1;
        for( int i = 0; i < spielerAnzahl; i++ )
        {
            VideoSpieler *tmp = spieler->z( i );
            if( tmp )
            {
                bool amLeben = tmp->istAmLeben();
                tmp->tick( map->zMap(), TICK );
                if( amLeben != tmp->istAmLeben() )
                {
                    for( int j = 0; j < spielerAnzahl; j++ )
                    {
                        VideoSpieler *s = spieler->z( j );
                        if( s && s->getFarbe() == tmp->getKillFarbe() )
                            s->addKill();
                        if( s && s != tmp && s->istAmLeben() )
                            bestenliste->addPunkt( s->getTeam(), s->getSpielerNummer(), 1 );
                    }
                }
                if( amLeben && !tmp->istAmLeben() )
                { // gestorben
                    int team = tmp->getTeam();
                    bool teamLebt = 0;
                    for( int k = 0; k < spielerAnzahl; k++ )
                    {
                        if( spieler->z( k ) && spieler->z( k )->getTeam() == team )
                            teamLebt |= spieler->z( k )->istAmLeben();
                    }
                    if( !teamLebt )
                    {
                        int teamAmLebenAnzahl = 0;
                        for( int k = 0; k < maxTeam; k++ )
                        {
                            if( !bestenliste->teamExistiert( k ) )
                                continue;
                            bool amLeben = 0;
                            for( int l = 0; l < spielerAnzahl; l++ )
                            {
                                if( spieler->z( l ) && spieler->z( l )->getTeam() == k )
                                    amLeben |= spieler->z( l )->istAmLeben();
                            }
                            if( amLeben )
                            {
                                tmpTeam = k;
                                teamAmLebenAnzahl++;
                                bestenliste->addPunkt( k, 1 );
                            }
                            else
                                bestenliste->addPunkt( k, 0 );
                            if( !bestenliste->getTeamPunkte( k ) )
                                bestenliste->setTeamStatus( k, "tod", 0xFFFF0000 );
                        }
                        if( teamAmLebenAnzahl <= 1 )
                            rEnd = 1;
                    }
                }
            }
        }
        if( rEnd )
        { // Runden Ende
            rundenSieger.set( tmpTeam, rundenAnzahl );
            rundenDauer.set( (int)sZeit, rundenAnzahl );
            rundenAnzahl++;
            sZeit = 0;
            int nAnz = 0;
            int nAnz2 = 0;
            for( int i = 0; i < maxTeam; i++ )
            {
                if( bestenliste->teamExistiert( i ) )
                {
                    nAnz += bestenliste->hatTeamGewonnen( i );
                    nAnz2 += bestenliste->getTeamPunkte( i ) >= 0;
                }
            }
            if( nAnz || nAnz2 <= 1 || rundenAnzahl >= 10 )
            {
                RundeSpielerVideoDaten dat;
                for( int i = 0; i < spielerAnzahl; i++ )
                    spieler->z( i )->neuRunde( 1, &dat, 1 );
                break; // Spiel Ende
            }
            int r = nachrichten->setRundenEnde( 1 );
            bestenliste->updatePunkte();
            map->nextRunde( 1 );
            RundeVideoDaten *dat = nachrichten->getRVD();
            map->setSize( dat->mapBreite, dat->mapHöhe );
            for( int i = 0; i < spielerAnzahl; i++ )
                spieler->z( i )->neuRunde( 1, nachrichten->getRSVD( i ), bestenliste->getTeamPunkte( spieler->z( i )->getTeam() ) != 0 );
        }
        nMsg = 0;
    }
    // Statistik erstellen
    for( int i = 0; i < spielerAnzahl; i++ )
    {
        SSDGesamtSpieler *ssdgs = new SSDGesamtSpieler();
        VideoSpieler *tmp = spieler->z( i );
        ssdgs->spielerNummer = tmp->getSpielerNummer();
        ssdgs->spielerName.setText( tmp->zName()->getText() );
        ssdgs->teamName.setText( tmp->zTeamName()->getText() );
        ssdgs->spielerFarbe = tmp->getFarbe();
        ssdgs->teamFarbe = tmp->getTeamFarbe();
        ssdgs->gewonneneRunden = tmp->getGewonneneRunden();
        ssdgs->punkte = bestenliste->getSpielerPunkte( tmp->getTeam(), tmp->getSpielerNummer() );
        ssdgs->linienLänge = tmp->getLinienLänge();
        ssdgs->zeitAmLeben = tmp->getZeitAmLeben();
        ssdgs->zeitTod = tmp->getZeitTod();
        ssdgs->kills = tmp->getKills();
        ssdgs->tode = tmp->getTode();
        this->ssdgs->set( ssdgs, i );
    }
    Array< int > teams;
    for( int i = 0; i < teamAnzahl; i++ )
    {
        for( int j = 0; j < spielerAnzahl; j++ )
        {
            if( teams.getWertIndex( spieler->z( j )->getTeam() ) < 0 )
            {
                teams.set( spieler->z( j )->getTeam(), i );
                break;
            }
        }
        if( teams.hat( i ) )
        {
            SSDGesamtTeam *ssdgt = new SSDGesamtTeam();
            ssdgt->teamNummer = teams.get( i );
            for( int j = 0; j < spielerAnzahl; j++ )
            {
                VideoSpieler *tmp = spieler->z( j );
                if( tmp->getTeam() == ssdgt->teamNummer )
                {
                    ssdgt->teamName.setText( tmp->zTeamName()->getText() );
                    ssdgt->teamFarbe = tmp->getTeamFarbe();
                    break;
                }
            }
            ssdgt->gewonneneRunden = 0;
            for( int j = 0; j < rundenAnzahl; j++ )
            {
                if( rundenSieger.get( j ) == ssdgt->teamNummer )
                    ssdgt->gewonneneRunden++;
            }
            ssdgt->punkte = 0;
            ssdgt->linienLänge = 0;
            ssdgt->kills = 0;
            ssdgt->tode = 0;
            for( int j = 0; j < spielerAnzahl; j++ )
            {
                VideoSpieler *tmp = spieler->z( j );
                if( tmp->getTeam() == ssdgt->teamNummer )
                {
                    ssdgt->punkte += bestenliste->getSpielerPunkte( tmp->getTeam(), tmp->getSpielerNummer() );
                    ssdgt->linienLänge += tmp->getLinienLänge();
                    ssdgt->kills += tmp->getKills();
                    ssdgt->tode += tmp->getTode();
                }
            }
            this->ssdgt->set( ssdgt, i );
        }
    }
    for( int i = 0; i < rundenAnzahl; i++ )
    {
        SSDRunde *ssdr = new SSDRunde();
        ssdr->rundenNummer = i;
        ssdr->rundenDauer = rundenDauer.get( i );
        ssdr->rundenSieger = rundenSieger.get( i );
        ssdr->rundenBild.neuBild( map->zMap( i )->getBreite(), map->zMap( i )->getHeight(), 0 );
        ssdr->rundenBild.drawBild( 0, 0, map->zMap( i )->getBreite(), map->zMap( i )->getHeight(), *map->zMap( i ) );
        ssdr->spielfeldNutzung = 0;
        int *rbBuff = ssdr->rundenBild.getBuffer();
        for( int j = 0; j < ssdr->rundenBild.getBreite() * ssdr->rundenBild.getHeight(); j++ )
        {
            if( rbBuff[ j ] )
                ssdr->spielfeldNutzung++;
        }
        ssdr->spielfeldNutzung = (int)( ( ssdr->spielfeldNutzung / ( (double)( ssdr->rundenBild.getBreite() * ssdr->rundenBild.getHeight() ) / 25 ) ) * 100 );
        for( int j = 0; j < spielerAnzahl; j++ )
        {
            VideoSpieler *tmp = spieler->z( j );
            SSDRundeSpieler *ssdrs = new SSDRundeSpieler();
            ssdrs->spielerNummer = tmp->getSpielerNummer();
            ssdrs->spielerName.setText( tmp->zName()->getText() );
            ssdrs->teamName.setText( tmp->zTeamName()->getText() );
            ssdrs->spielerFarbe = tmp->getFarbe();
            ssdrs->teamFarbe = tmp->getTeamFarbe();
            ssdrs->linienLänge = tmp->getLinienLänge( i );
            ssdrs->kills = tmp->getKills( i );
            ssdrs->todesZeit = tmp->getTodesZeit( i );
            ssdr->spieler.set( ssdrs, j );
        }
        for( int j = 0; j < teamAnzahl; j++ )
        {
            SSDRundeTeam *ssdrt = new SSDRundeTeam();
            ssdrt->teamNummer = teams.get( j );
            for( int k = 0; k < spielerAnzahl; k++ )
            {
                if( spieler->z( k )->getTeam() == ssdrt->teamNummer )
                {
                    ssdrt->teamName.setText( spieler->z( k )->zTeamName()->getText() );
                    ssdrt->teamFarbe = spieler->z( k )->getTeamFarbe();
                    break;
                }
            }
            ssdrt->ergebnis = rundenSieger.get( i ) == ssdrt->teamNummer;
            ssdrt->linienLänge = 0;
            ssdrt->kills = 0;
            ssdrt->tode = 0;
            for( int k = 0; k < spielerAnzahl; k++ )
            {
                VideoSpieler *tmp = spieler->z( j );
                if( tmp->getTeam() == ssdrt->teamNummer )
                {
                    ssdrt->linienLänge += tmp->getLinienLänge( i );
                    ssdrt->kills += tmp->getKills( i );
                    ssdrt->tode += tmp->getTodesZeit( i ) != 0;
                }
            }
            ssdr->teams.set( ssdrt, j );
        }
        this->ssdr->set( ssdr, i );
    }
}

// Destruktor
StatistikLeser::~StatistikLeser()
{
    nachrichten->release();
    bestenliste->release();
    map->release();
    spieler->release();
    ssdgs->release();
    ssdgt->release();
    ssdr->release();
}

// constant
bool StatistikLeser::hatFehler() const
{
    return fehler;
}

int StatistikLeser::getSpielerAnzahl() const
{
    return spielerAnzahl;
}

int StatistikLeser::getTeamAnzahl() const
{
    return teamAnzahl;
}

int StatistikLeser::getRundenAnzahl() const
{
    return rundenAnzahl;
}

SSDGesamtSpieler *StatistikLeser::getSSDGS( int index ) const
{
    return ssdgs->get( index );
}

SSDGesamtTeam *StatistikLeser::getSSDGT( int index ) const
{
    return ssdgt->get( index );
}

SSDRunde *StatistikLeser::getSSDR( int runde ) const
{
    return ssdr->get( runde );
}