#include "VideoNachricht.h"

// Inhalt der RundeNachricht Klasse aus VideoNachricht.h
// Konstruktor
RundeNachricht::RundeNachricht( Datei *d, int spielerAnzahl )
{
	index = 0;
	maxNachricht = 0;
	nachrichten = new Array< VideoMSG* >();
	vDat = d;
	rvd = new RundeVideoDaten();
	rsvd = new Array< RundeSpielerVideoDaten* >();
	aktiv = 1;
	ref = 1;
	vDat->lese( (char*)&rvd->mapBreite, 4 );
	vDat->lese( (char*)&rvd->mapHöhe, 4 );
	for( int i = 0; i < spielerAnzahl; i++ )
	{
		RundeSpielerVideoDaten *svd = new RundeSpielerVideoDaten();
		vDat->lese( (char*)&svd->wendigkeit, 8 );
		vDat->lese( (char*)&svd->xPos, 8 );
		vDat->lese( (char*)&svd->yPos, 8 );
		vDat->lese( (char*)&svd->xSpeed, 8 );
		vDat->lese( (char*)&svd->ySpeed, 8 );
		rsvd->set( svd, i );
	}
}

// Destruktor
RundeNachricht::~RundeNachricht()
{
	for( int i = 0; i < maxNachricht; i++ )
	{
		VideoMSG *tmp = nachrichten->get( i );
		if( !tmp->typ )
			delete (VideoMSG*)tmp;
		else
		{
			if( ( (VideoAktionMSG*)tmp )->aktion == 4 )
				delete (VideoChatMSG*)tmp;
			else if( ( (VideoAktionMSG*)tmp )->aktion == 5 )
				delete (VideoLinieMSG*)tmp;
			else
				delete (VideoAktionMSG*)tmp;
		}
	}
	nachrichten->release();
	vDat->release();
	delete rvd;
	int anz = rsvd->getEintragAnzahl();
	for( int i = 0; i < anz; i++ )
		delete rsvd->get( i );
	rsvd->release();
}

// nicht constant
VideoMSG *RundeNachricht::GetNextNachricht()
{
	if( index < maxNachricht )
	{
		index++;
		return nachrichten->get( index - 1 );
	}
	else if( aktiv )
	{
		char typ = 0;
		vDat->lese( &typ, 1 );
		if( !typ )
		{
			VideoMSG *vtmsg = new VideoMSG();
			vtmsg->typ = typ;
			nachrichten->set( vtmsg, index );
			index++;
			maxNachricht++;
			return vtmsg;
		}
		else if( typ == 1 )
		{
			NachrichtVideoDaten nvd;
			vDat->lese( (char*)&nvd.spielerNummer, 4 );
			vDat->lese( (char*)&nvd.län, 2 );
			char *bytes = new char[ nvd.län ];
			vDat->lese( bytes, nvd.län );
			if( bytes[ 0 ] >= 0 && bytes[ 0 ] <= 3 )
			{
				VideoAktionMSG *vamsg = new VideoAktionMSG();
				vamsg->typ = typ;
				vamsg->spielerNummer = nvd.spielerNummer;
				vamsg->aktion = bytes[ 0 ];
				nachrichten->set( vamsg, index );
				index++;
				maxNachricht++;
				delete[] bytes;
				return vamsg;
			}
			if( bytes[ 0 ] == 4 )
			{
				VideoChatMSG *vcmsg = new VideoChatMSG();
				vcmsg->typ = typ;
				vcmsg->spielerNummer = nvd.spielerNummer;
				vcmsg->aktion = bytes[ 0 ];
				vcmsg->län = nvd.län - 1;
				vcmsg->msg.setText( bytes + 1, vcmsg->län );
				nachrichten->set( vcmsg, index );
				index++;
				maxNachricht++;
				delete[] bytes;
				return vcmsg;
			}
			if( bytes[ 0 ] == 5 )
			{
				VideoLinieMSG *vlmsg = new VideoLinieMSG();
				vlmsg->typ = typ;
				vlmsg->spielerNummer = nvd.spielerNummer;
				vlmsg->aktion = bytes[ 0 ];
				vlmsg->unterbrechung = *( bytes + 1 );
				nachrichten->set( vlmsg, index );
				index++;
				maxNachricht++;
				delete[] bytes;
				return vlmsg;
			}
			delete[] bytes;
		}
		else
		{
			VideoMSG *msg = new VideoMSG();
			msg->typ = typ;
			nachrichten->set( msg, index );
			index++;
			maxNachricht++;
			return msg;
		}
	}
	return 0;
}

VideoMSG *RundeNachricht::GetLastNachricht()
{
	if( index == 0 )
		return 0;
	index--;
	return nachrichten->get( index );
}

void RundeNachricht::setEnde()
{
	aktiv = 0;
}

// constant
RundeVideoDaten *RundeNachricht::getRVD() const
{
	return rvd;
}

RundeSpielerVideoDaten *RundeNachricht::getRSVD( int index ) const
{
	if( !rsvd->hat( index ) )
		return 0;
	return rsvd->get( index );
}

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

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


// Inhalt der SpielNachricht Klasse aus VideoNachricht.h
// Konatruktor
SpielNachricht::SpielNachricht( int num )
{
	runde = 0;
	maxRunde = 0;
	teamAnzahl = 0;
	runden = new RCArray< RundeNachricht >();
	vDat = new Datei();
	svd = new SpielVideoDaten();
	spvd = new Array< SpielerVideoDaten* >();
	tvd = new Array< TeamVideoDaten* >();
	error = 0;
	fehler = new Text();
	ref = 1;
	Text pfad( "data/tmp/historie/" );
	pfad += num;
	pfad += "/verlauf.ksggl";
	vDat->setDatei( pfad );
	if( !vDat->open( Datei::Style::lesen ) )
	{
		*fehler = "Die Videodatei '";
		*fehler += pfad;
		*fehler += "' konnte nicht geöffnet werden.\nEs existiert eventuell keine Aufzeichnung von diesem Spiel.";
		error = 1;
	}
	Array< int > team;
	if( !error )
	{
		vDat->lese( (char*)&svd->spielerAnzahl, 4 );
		for( int i = 0; i < svd->spielerAnzahl; i++ )
		{
			SpielerVideoDaten *svd = new SpielerVideoDaten();
			vDat->lese( (char*)&svd->index, 4 );
			vDat->lese( (char*)&svd->spielerNummer, 4 );
			vDat->lese( (char*)&svd->kamBreite, 4 );
			vDat->lese( (char*)&svd->kamHöhe, 4 );
			vDat->lese( (char*)&svd->team, 4 );
			vDat->lese( (char*)&svd->spielerFarbe, 4 );
			vDat->lese( (char*)&svd->teamFarbe, 4 );
			char län = 0;
			vDat->lese( &län, 1 );
			char *n = new char[ län + 1 ];
			n[ län ] = 0;
			if( län )
				vDat->lese( n, län );
			svd->name.setText( n );
			delete[] n;
			vDat->lese( &län, 1 );
			n = new char[ län + 1 ];
			n[ län ] = 0;
			if( län )
				vDat->lese( n, län );
			svd->teamName.setText( n );
			delete[] n;
			spvd->set( svd, svd->index );
			if( team.getWertIndex( svd->team ) < 0 )
			{
				team.set( svd->team, teamAnzahl );
				teamAnzahl++;
			}
		}
		for( int i = 0; i < teamAnzahl; i++ )
		{
			TeamVideoDaten *t = new TeamVideoDaten();
			vDat->lese( (char*)&t->teamNummer, 4 );
			vDat->lese( (char*)&t->maxPunkte, 4 );
			vDat->lese( (char*)&t->punkte, 4 );
			tvd->set( t, i );
		}
		RundeNachricht *r = new RundeNachricht( vDat->getThis(), svd->spielerAnzahl );
		runden->set( r, runde );
	}
}

// Destruktor
SpielNachricht::~SpielNachricht()
{
	runden->release();
	vDat->close();
	vDat->release();
	for( int i = 0; i < svd->spielerAnzahl; i++ )
		delete spvd->get( i );
	delete svd;
	spvd->release();
	for( int i = 0; i < teamAnzahl; i++ )
		delete tvd->get( i );
	tvd->release();
	fehler->release();
}

// nicht constant
VideoMSG *SpielNachricht::GetNextNachricht()
{
	return runden->z( runde )->GetNextNachricht();
}

VideoMSG *SpielNachricht::GetLastNachricht()
{
	return runden->z( runde )->GetLastNachricht();
}

int SpielNachricht::setRundenEnde( bool vorwärts )
{
	if( vorwärts )
	{
		if( runde < maxRunde )
			runde++;
		else
		{
			runden->z( runde )->setEnde();
			runde++;
			maxRunde++;
			RundeNachricht *tmp = new RundeNachricht( vDat->getThis(), svd->spielerAnzahl );
			runden->set( tmp, runde );
		}
	}
	else
		runde--;
	if( runde < 0 )
	{
		runde = 0;
		return -1;
	}
	return runde;
}

// constant
SpielVideoDaten *SpielNachricht::getSVD() const
{
	return svd;
}

SpielerVideoDaten *SpielNachricht::getSPVD( int index ) const
{
	if( !spvd->hat( index ) )
		return 0;
	return spvd->get( index );
}

TeamVideoDaten *SpielNachricht::getTVD( int index ) const
{
	if( !tvd->hat( index ) )
		return 0;
	return tvd->get( index );
}

RundeVideoDaten *SpielNachricht::getRVD() const
{
	return runden->z( runde )->getRVD();
}

RundeSpielerVideoDaten *SpielNachricht::getRSVD( int index ) const
{
	return runden->z( runde )->getRSVD( index );
}

bool SpielNachricht::hatFehler( Text *txt ) const
{
	txt->setText( fehler->getText() );
	return error;
}

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

int SpielNachricht::getRunde() const
{
	return runde;
}

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

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