#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, Schrift *zS )
{
	this->sNum = sNum;
	this->farbe = farbe;
	p = 0;
	nP = 0;

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

	name = new TextFeld();
	name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
	name->setSchriftZ( zS->getThis() );
	name->setSchriftFarbe( farbe );
	name->setSchriftSize( 12 );
	name->setSize( 100, 20 );
	name->setPosition( 0, 0 );
	name->setText( "" );

	punkte = new TextFeld();
	punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
	punkte->setSchriftZ( zS->getThis() );
	punkte->setSchriftFarbe( farbe );
	punkte->setSchriftSize( 12 );
	punkte->setSize( 100, 20 );
	punkte->setPosition( 100, 0 );
	punkte->setText( "" );

	neuPunkte = new TextFeld();
	neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
	neuPunkte->setSchriftZ( zS->getThis() );
	neuPunkte->setSchriftFarbe( farbe );
	neuPunkte->setSchriftSize( 12 );
	neuPunkte->setSize( 100, 20 );
	neuPunkte->setPosition( 200, 0 );
	neuPunkte->setText( "" );

	status = new TextFeld();
	status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
	status->setSchriftZ( zS->getThis() );
	status->setSchriftFarbe( 0xFF00FF00 );
	status->setSchriftSize( 12 );
	status->setSize( 100, 20 );
	status->setPosition( 300, 0 );
	status->setText( "lebt" );

	ref = 1;
}

// 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;
}

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

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

// Inhalt der BLTeam Klasse aus Bestenliste.h
// Konstruktor
BLTeam::BLTeam( int id, int farbe, Schrift *s )
{
	teamId = id;
	spielerAnzahl = 0;
	p = 0;
	mP = 0;
	nP = 0;
	this->farbe = farbe;
	schrift = s;

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

	spieler = new RCArray< BLSpieler >();

	name = new TextFeld();
	name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
	name->setSchriftZ( s->getThis() );
	name->setSchriftFarbe( farbe );
	name->setSchriftSize( 12 );
	name->setSize( 100, 20 );
	name->setPosition( 0, 0 );
	name->setText( "" );

	punkte = new TextFeld();
	punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
	punkte->setSchriftZ( s->getThis() );
	punkte->setSchriftFarbe( farbe );
	punkte->setSchriftSize( 12 );
	punkte->setSize( 100, 20 );
	punkte->setPosition( 100, 0 );
	punkte->setText( "" );

	neuPunkte = new TextFeld();
	neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
	neuPunkte->setSchriftZ( s->getThis() );
	neuPunkte->setSchriftFarbe( farbe );
	neuPunkte->setSchriftSize( 12 );
	neuPunkte->setSize( 100, 20 );
	neuPunkte->setPosition( 200, 0 );
	neuPunkte->setText( "" );

	status = new TextFeld();
	status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
	status->setSchriftZ( s->getThis() );
	status->setSchriftFarbe( 0xFF00FF00 );
	status->setSchriftSize( 12 );
	status->setSize( 100, 20 );
	status->setPosition( 300, 0 );
	status->setText( "lebt" );

	ref = 1;
}

// Destruktor
BLTeam::~BLTeam()
{
	schrift->release();
	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(), schrift );
	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;
}

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

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

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

	teams = new RCArray< BLTeam >();

	name = new TextFeld();
	name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
	name->setSchriftZ( s->getThis() );
	name->setSchriftFarbe( 0xFFFFFFFF );
	name->setSchriftSize( 12 );
	name->setText( "Name" );
	name->setSize( 100, 20 );
	name->setPosition( 0, 0 );

	punkte = new TextFeld();
	punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
	punkte->setSchriftZ( s->getThis() );
	punkte->setSchriftFarbe( 0xFFFFFFFF );
	punkte->setSchriftSize( 12 );
	punkte->setText( "Punkte" );
	punkte->setSize( 100, 20 );
	punkte->setPosition( 100, 0 );

	neuPunkte = new TextFeld();
	neuPunkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
	neuPunkte->setSchriftZ( s->getThis() );
	neuPunkte->setSchriftFarbe( 0xFFFFFFFF );
	neuPunkte->setSchriftSize( 12 );
	neuPunkte->setText( "+Punkte" );
	neuPunkte->setSize( 100, 20 );
	neuPunkte->setPosition( 200, 0 );

	status = new TextFeld();
	status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
	status->setSchriftZ( s->getThis() );
	status->setSchriftFarbe( 0xFFFFFFFF );
	status->setSchriftSize( 12 );
	status->setText( "Status" );
	status->setSize( 100, 20 );
	status->setPosition( 300, 0 );

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

	schrift = s;
	update = 0;
	teamAnzahl = 0;
	ref = 1;
}

// Destruktor
Bestenliste::~Bestenliste()
{
	rahmen->release();
	teams->release();
	name->release();
	punkte->release();
	neuPunkte->release();
	status->release();
	scroll->release();
	schrift->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(), schrift->getThis() ), 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::doMausEreignis( 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;
}

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

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