#include "Bestenliste.h"
#include "..\Spieler\Spieler.h"
#include <Rahmen.h>
#include <Schrift.h>
#include <Punkt.h>
#include <Scroll.h>

// Inhalt der BLSpieler Klasse aus Bestenliste.h
// Konstruktor
BLSpieler::BLSpieler( int sNum, int farbe, UIInit &uiFactory )
    : ReferenceCounter()
{
    this->sNum = sNum;
    this->farbe = farbe;
    p = 0;
    nP = 0;

    rahmen = new LRahmen();
    rahmen->setFarbe( farbe );
    rahmen->setRamenBreite( 1 );
    rahmen->setSize( 400, 20 );

    name = uiFactory.createTextFeld( uiFactory.initParam );
    name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    name->setSchriftFarbe( farbe );
    name->setSize( 100, 20 );
    name->setPosition( 0, 0 );
    name->setText( "" );

    punkte = uiFactory.createTextFeld( uiFactory.initParam );
    punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    punkte->setSchriftFarbe( farbe );
    punkte->setSize( 100, 20 );
    punkte->setPosition( 100, 0 );
    punkte->setText( "" );

    neuPunkte = uiFactory.createTextFeld( uiFactory.initParam );
    neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    neuPunkte->setSchriftFarbe( farbe );
    neuPunkte->setSize( 100, 20 );
    neuPunkte->setPosition( 200, 0 );
    neuPunkte->setText( "" );

    status = uiFactory.createTextFeld( uiFactory.initParam );
    status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    status->setSchriftFarbe( 0xFF00FF00 );
    status->setSize( 100, 20 );
    status->setPosition( 300, 0 );
    status->setText( "lebt" );
}

// Destruktor
BLSpieler::~BLSpieler()
{
    rahmen->release();
    name->release();
    punkte->release();
    neuPunkte->release();
    status->release();
}

// nicht constant
bool BLSpieler::updateStatus( Spieler *zSpieler )
{
    if( sNum != zSpieler->getSpielerNummer() )
        return 0;
    if( zSpieler->istAmLeben() )
    {
        status->setSchriftFarbe( 0xFF00FF00 );
        status->setText( "lebt" );
    }
    else
    {
        status->setSchriftFarbe( 0xFFFF0000 );
        status->setText( "tot" );
    }
    name->setText( zSpieler->zName()->getText() );
    return 1;
}

void BLSpieler::setPunkte( int p )
{
    this->p = p;
}

void BLSpieler::addPunkt( bool plus )
{
    if( plus )
        nP++;
    else
        nP--;
}

void BLSpieler::updatePunkte()
{
    p += nP;
    nP = 0;
}

void BLSpieler::render( int y, Bild &zRObj )
{
    if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
        return;
    punkte->setText( "" );
    if( nP == 0 )
    {
        neuPunkte->setText( "" );
        neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
    }
    else if( nP > 0 )
    {
        neuPunkte->setText( "+" );
        neuPunkte->setSchriftFarbe( 0xFF00FF00 );
    }
    else
    {
        neuPunkte->setText( "" );
        neuPunkte->setSchriftFarbe( 0xFFFF0000 );
    }
    punkte->zText()->append( p );
    neuPunkte->zText()->append( nP );
    rahmen->render( zRObj );
    name->render( zRObj );
    punkte->render( zRObj );
    neuPunkte->render( zRObj );
    status->render( zRObj );
    zRObj.releaseDrawOptions();
}

// constant
int BLSpieler::getSpielerNummer() const
{
    return sNum;
}

int BLSpieler::getPunkte() const
{
    return p + nP;
}

// Inhalt der BLTeam Klasse aus Bestenliste.h
// Konstruktor
BLTeam::BLTeam( int id, int farbe, UIInit &uiFactory )
    : ReferenceCounter()
{
    teamId = id;
    spielerAnzahl = 0;
    p = 0;
    mP = 0;
    nP = 0;
    this->farbe = farbe;
    this->uiFactory = uiFactory;

    rahmen = new LRahmen();
    rahmen->setFarbe( farbe );
    rahmen->setRamenBreite( 1 );

    spieler = new RCArray< BLSpieler >();

    name = uiFactory.createTextFeld( uiFactory.initParam );
    name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    name->setSchriftFarbe( farbe );
    name->setSize( 100, 20 );
    name->setPosition( 0, 0 );
    name->setText( "" );

    punkte = uiFactory.createTextFeld( uiFactory.initParam );
    punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    punkte->setSchriftFarbe( farbe );
    punkte->setSize( 100, 20 );
    punkte->setPosition( 100, 0 );
    punkte->setText( "" );

    neuPunkte = uiFactory.createTextFeld( uiFactory.initParam );
    neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    neuPunkte->setSchriftFarbe( farbe );
    neuPunkte->setSize( 100, 20 );
    neuPunkte->setPosition( 200, 0 );
    neuPunkte->setText( "" );

    status = uiFactory.createTextFeld( uiFactory.initParam );
    status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    status->setSchriftFarbe( 0xFF00FF00 );
    status->setSize( 100, 20 );
    status->setPosition( 300, 0 );
    status->setText( "lebt" );
}

// Destruktor
BLTeam::~BLTeam()
{
    rahmen->release();
    spieler->release();
    name->release();
    punkte->release();
    neuPunkte->release();
    status->release();
}

// nicht constant
bool BLTeam::addSpieler( Spieler *zSpieler )
{
    bool gefunden = 0;
    for( int i = 0; i < spielerAnzahl; i++ )
    {
        if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
        {
            gefunden = 1;
            break;
        }
    }
    if( gefunden )
        return 0;
    BLSpieler *tmp = new BLSpieler( zSpieler->getSpielerNummer(), zSpieler->getFarbe(), uiFactory );
    spieler->set( tmp, spielerAnzahl );
    spielerAnzahl++;
    return 1;
}

void BLTeam::setName( char *name )
{
    this->name->setText( name );
}

bool BLTeam::updateSpielerStatus( Spieler *zSpieler )
{
    for( int i = 0; i < spielerAnzahl; i++ )
    {
        if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
        {
            spieler->z( i )->updateStatus( zSpieler );
            return 1;
        }
    }
    return 0;
}

void BLTeam::setStatus( const char *txt, int f )
{
    status->setText( txt );
    status->setSchriftFarbe( f );
}

void BLTeam::setPunkte( int p )
{
    this->p = p;
}

void BLTeam::setMaxPunkte( int mP )
{
    this->mP = mP;
}

bool BLTeam::setSpielerPunkte( int sNum, int p )
{
    for( int i = 0; i < spielerAnzahl; i++ )
    {
        if( spieler->z( i )->getSpielerNummer() == sNum )
        {
            spieler->z( i )->setPunkte( p );
            return 1;
        }
    }
    return 0;
}

void BLTeam::addPunkt( bool plus )
{
    if( plus )
        nP++;
    else
        nP--;
    if( p + nP < 0 )
        nP++;
}

bool BLTeam::addPunkt( int sNum, bool plus )
{
    for( int i = 0; i < spielerAnzahl; i++ )
    {
        if( spieler->z( i )->getSpielerNummer() == sNum )
        {
            spieler->z( i )->addPunkt( plus );
            return 1;
        }
    }
    return 0;
}

void BLTeam::updatePunkte()
{
    p += nP;
    if( p < 0 )
        p = 0;
    nP = 0;
    for( int i = 0; i < spielerAnzahl; i++ )
        spieler->z( i )->updatePunkte();
}

void BLTeam::render( int y, Bild &zRObj )
{
    rahmen->setSize( 402, 21 + 20 * spielerAnzahl );
    if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
        return;
    punkte->setText( "" );
    if( nP == 0 )
    {
        neuPunkte->setText( "" );
        neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
    }
    else if( nP > 0 )
    {
        neuPunkte->setText( "+" );
        neuPunkte->setSchriftFarbe( 0xFF00FF00 );
    }
    else
    {
        neuPunkte->setText( "" );
        neuPunkte->setSchriftFarbe( 0xFFFF0000 );
    }
    punkte->zText()->append( p );
    punkte->zText()->append( "/" );
    punkte->zText()->append( mP );
    neuPunkte->zText()->append( nP );
    rahmen->render( zRObj );
    name->render( zRObj );
    punkte->render( zRObj );
    neuPunkte->render( zRObj );
    status->render( zRObj );
    Array< bool > *gemahlt = new Array< bool >();
    for( int i = 0; i < spielerAnzahl; i++ )
        gemahlt->set( 0, i );
    int min = -1;
    int tmp = -1;
    for( int h = 0; h < spielerAnzahl; h++ )
    {
        min = -1;
        tmp = -1;
        for( int i = 0; i < spielerAnzahl; i++ )
        {
            if( !spieler->z( i ) )
                continue;
            if( gemahlt->hat( i ) && gemahlt->get( i ) )
                continue;
            int p = spieler->z( i )->getPunkte();
            if( p > min )
            {
                min = p;
                tmp = i;
            }
        }
        if( tmp >= 0 )
        {
            gemahlt->set( 1, tmp );
            spieler->z( tmp )->render( 20 + 20 * h, zRObj );
        }
        else
            break;
    }
    gemahlt->release();
    zRObj.releaseDrawOptions();
}

// constant
int BLTeam::getSpielerAnzahl() const
{
    return spielerAnzahl;
}

int BLTeam::getPunkte() const
{
    return ( p + nP ) < 0 ? 0 : ( p + nP );
}

int BLTeam::getHeight() const
{
    return 21 + spielerAnzahl * 20;
}

// Inhalt der Bestenliste Klasse aus Bestenliste.h
// Konstruktor
Bestenliste::Bestenliste( UIInit &uiFactory )
    : ReferenceCounter()
{
    rahmen = new LRahmen();
    rahmen->setRamenBreite( 1 );
    rahmen->setFarbe( 0xFFFFFFFF );
    rahmen->setSize( 420, 200 );

    teams = new RCArray< BLTeam >();

    name = uiFactory.createTextFeld( uiFactory.initParam );
    name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    name->setText( "Name" );
    name->setSize( 100, 20 );
    name->setPosition( 0, 0 );

    punkte = uiFactory.createTextFeld( uiFactory.initParam );
    punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    punkte->setText( "Punkte" );
    punkte->setSize( 100, 20 );
    punkte->setPosition( 100, 0 );

    neuPunkte = uiFactory.createTextFeld( uiFactory.initParam );
    neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    neuPunkte->setText( "+Punkte" );
    neuPunkte->setSize( 100, 20 );
    neuPunkte->setPosition( 200, 0 );

    status = uiFactory.createTextFeld( uiFactory.initParam );
    status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
    status->setText( "Status" );
    status->setSize( 100, 20 );
    status->setPosition( 300, 0 );

    scroll = new VScrollBar();
    scroll->setKlickScroll( 7 );

    this->uiFactory = uiFactory;
    update = 0;
    teamAnzahl = 0;
}

// Destruktor
Bestenliste::~Bestenliste()
{
    rahmen->release();
    teams->release();
    name->release();
    punkte->release();
    neuPunkte->release();
    status->release();
    scroll->release();
}

// nicht constant
void Bestenliste::setTeamAnzahl( int anz )
{
    teamAnzahl = anz;
}

void Bestenliste::setTeamStatus( int team, const char *txt, int f )
{
    if( teams->z( team ) )
        teams->z( team )->setStatus( txt, f );
}

void Bestenliste::addSpieler( Spieler *zSpieler )
{
    int team = zSpieler->getTeam();
    if( team < 0 )
        return;
    if( !teams->z( team ) )
        teams->set( new BLTeam( team, zSpieler->getTeamFarbe(), uiFactory ), team );
    teams->z( team )->addSpieler( zSpieler );
}

void Bestenliste::updateSpielerStatus( Spieler *zSpieler )
{
    if( teams->z( zSpieler->getTeam() ) )
        teams->z( zSpieler->getTeam() )->updateSpielerStatus( zSpieler );
}

void Bestenliste::setTeamName( int team, char *name )
{
    if( teams->z( team ) )
        teams->z( team )->setName( name );
}

void Bestenliste::setTeamPunkte( int teamId, int punkte )
{
    if( teams->z( teamId ) )
        teams->z( teamId )->setPunkte( punkte );
}

void Bestenliste::setTeamMaxPunkte( int teamId, int mPunkte )
{
    if( teams->z( teamId ) )
        teams->z( teamId )->setMaxPunkte( mPunkte );
}

void Bestenliste::setSpielerPunkte( int teamNum, int sNum, int punkte )
{
    if( teams->z( teamNum ) )
        teams->z( teamNum )->setSpielerPunkte( sNum, punkte );
}

void Bestenliste::addPunkt( int tNum, bool plus )
{
    if( teams->z( tNum ) )
        teams->z( tNum )->addPunkt( plus );
}

void Bestenliste::addPunkt( int tNum, int sNum, bool plus )
{
    if( teams->z( tNum ) )
        teams->z( tNum )->addPunkt( sNum, plus );
}

void Bestenliste::updatePunkte()
{
    for( int i = 0; i < teamAnzahl; i++ )
    {
        if( teams->z( i ) )
            teams->z( i )->updatePunkte();
    }
}

void Bestenliste::doPublicMausEreignis( MausEreignis &me )
{
    scroll->doMausMessage( rahmen->getBreite() - 15, 1, 15, rahmen->getHeight() - 2, me );
}

void Bestenliste::render( Bild &zRObj )
{
    if( !zRObj.setDrawOptions( 0, 0, rahmen->getBreite(), rahmen->getHeight() ) )
        return;
    rahmen->render( zRObj );
    zRObj.addScrollOffset( 0, scroll->getScroll() );
    name->render( zRObj );
    punkte->render( zRObj );
    neuPunkte->render( zRObj );
    status->render( zRObj );
    int yOff = 20;
    Array< bool > *gemahlt = new Array< bool >();
    for( int i = 0; i < teamAnzahl; i++ )
        gemahlt->set( 0, i );
    int min = -1;
    int tmp = -1;
    for( int h = 0; h < teamAnzahl; h++ )
    {
        min = -1;
        tmp = -1;
        for( int i = 0; i < teamAnzahl; i++ )
        {
            if( !teams->z( i ) )
                continue;
            if( gemahlt->hat( i ) && gemahlt->get( i ) )
                continue;
            int p = teams->z( i )->getPunkte();
            if( p > min )
            {
                min = p;
                tmp = i;
            }
        }
        if( tmp >= 0 )
        {
            gemahlt->set( 1, tmp );
            teams->z( tmp )->render( yOff, zRObj );
            yOff += teams->z( tmp )->getHeight();
        }
        else
            break;
    }
    gemahlt->release();
    zRObj.addScrollOffset( 0, -scroll->getScroll() );
    scroll->update( yOff, rahmen->getHeight() - 2 );
    scroll->render( rahmen->getBreite() - 16, 1, 15, rahmen->getHeight() - 2, zRObj );
    zRObj.releaseDrawOptions();
}

// constant
int Bestenliste::getTeamAnzahl() const
{
    return teamAnzahl;
}

bool Bestenliste::teamExistiert( int team ) const
{
    return teams->z( team ) != 0;
}

int Bestenliste::getTeamPunkte( int team ) const
{
    return teams->z( team ) ? teams->z( team )->getPunkte() : 0;
}