#include "KSGSKlasse.h"
#include "../Error/Error.h"
#include "../Main/KSGScriptObj.h"
#include "../Klassen/KSGSTyp.h"
#include "../Klassen/KSGSBool.h"
#include "../Klassen/KSGSInt.h"
#include "../Klassen/KSGSDouble.h"
#include "../Klassen/KSGSText.h"
#include "../Klassen/KSGSBild.h"
#include "../Klassen/KSGSMausEreignis.h"
#include "../Klassen/KSGSTastaturEreignis.h"
#include "../Klassen/KSGSTextFeld.h"
#include "../Klassen/KSGSKnopf.h"
#include "../Klassen/KSGSFenster.h"
#include "../Klassen/KSGSBildZ.h"
#include "../Klassen/KSGSAnimation2DData.h"
#include "../Klassen/KSGSAnimation2D.h"
#include "../Klassen/KSGSArray.h"

using namespace KSGScript;

// Inhalt der KSGSKlasseInstanz Klasse aus KSGSKlasse.h
// Konstruktor
KSGSKlasseInstanz::KSGSKlasseInstanz( int typ, Array< KSGSVariableDef* > *zVars, RCArray< KSGSFunktion > *funcs, KSGScriptObj *zObj )
{
	lokaleVariablen = new RCArray< KSGSVariable >();
	varPublic = new Array< bool >();
	funktionen = funcs;
	obj = zObj->getThis();
	lokaleVariablen->add( getThis(), 0 );
	varPublic->set( 0, 0 );
	int anz = zVars ? zVars->getEintragAnzahl() : 0;
	for( int i = 0; i < anz; i++ )
	{
		lokaleVariablen->set( KSGSKlasseInstanz::erstellVariable( zObj, zVars->get( i ) ), zVars->get( i )->id + 1 );
		varPublic->set( zVars->get( i )->sichtbar == 1, zVars->get( i )->id + 1 );
	}
	this->typ = typ;
	ref = 1;
}

// Destruktor
KSGSKlasseInstanz::~KSGSKlasseInstanz()
{
	lokaleVariablen->release();
	if( funktionen )
		funktionen->release();
	varPublic->release();
	obj->release();
}

// nicht constant
KSGSVariable *KSGSKlasseInstanz::startFunktion( int id, bool zugriff, RCArray< KSGSVariable > *parameter )
{
	if( !funktionen || ( !zugriff && ( !funktionen->z( id ) || funktionen->z( id )->getSichtbarkeit() != 1 ) ) )
	{
		error( 18, {}, obj );
		parameter->release();
		return 0;
	}
	if( !funktionen->z( id ) )
	{
		parameter->release();
		return 0;
	}
	KSGSFunktionInstanz *inst = funktionen->z( id )->erstellInstanz( (KSGScriptO*)obj->getThis(), (KSGSKlasseInstanz*)getThis(), parameter );
	KSGSVariable *ret = inst->startFunktion();
	inst->release();
	return ret;
}

KSGSVariable *KSGSKlasseInstanz::doOperator( int id, KSGSVariable *rechts )
{
	error( 21, {}, obj );
	if( rechts )
		rechts->release();
	return 0;
}

void KSGSKlasseInstanz::setVariable( int id, KSGSVariable *var )
{
	lokaleVariablen->set( var, id );
}

// constant
KSGSVariable *KSGSKlasseInstanz::getVariable( int id, bool zugriff ) const
{
	if( !zugriff && ( !varPublic->hat( id ) || !varPublic->get( id ) ) )
	{
		error( 17, {}, obj );
		return 0;
	}
	return lokaleVariablen->get( id );
}

KSGSVariable *KSGSKlasseInstanz::umwandelnIn( int typ ) const
{
	error( 16, {}, obj );
	return 0;
}

int KSGSKlasseInstanz::getTyp() const
{
	return typ;
}

// verarbeiten
bool KSGSKlasseInstanz::getBool() const
{
	if( typ == KSGS_BOOL )
		return ( ( KSGSBoolKlasse* )this )->getVal();
	else
	{
		KSGSBoolKlasse *tmp = (KSGSBoolKlasse*)umwandelnIn( KSGS_BOOL );
		if( tmp )
		{
			bool ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return 0;
	}
}

int KSGSKlasseInstanz::getInt() const
{
	if( typ == KSGS_INT )
		return ( ( KSGSIntKlasse* )this )->getVal();
	else
	{
		KSGSIntKlasse *tmp = (KSGSIntKlasse*)umwandelnIn( KSGS_INT );
		if( tmp )
		{
			int ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return 0;
	}
}

double KSGSKlasseInstanz::getDouble() const
{
	if( typ == KSGS_DOUBLE )
		return ( ( KSGSDoubleKlasse* )this )->getVal();
	else
	{
		KSGSDoubleKlasse *tmp = (KSGSDoubleKlasse*)umwandelnIn( KSGS_DOUBLE );
		if( tmp )
		{
			double ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return 0;
	}
}

Text *KSGSKlasseInstanz::getText() const
{
	if( typ == KSGS_TEXT )
		return ( ( KSGSTextKlasse* )this )->getVal();
	else
	{
		KSGSTextKlasse *tmp = (KSGSTextKlasse*)umwandelnIn( KSGS_TEXT );
		if( tmp )
		{
			Text *ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new Text( "" );
	}
}

Bild *KSGSKlasseInstanz::getBild() const
{
	if( typ == KSGS_BILD )
		return ( ( KSGSBildKlasse* )this )->getVal();
	else
	{
		KSGSBildKlasse *tmp = (KSGSBildKlasse*)umwandelnIn( KSGS_BILD );
		if( tmp )
		{
			Bild *ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new Bild();
	}
}

MausEreignis KSGSKlasseInstanz::getMausEreignis() const
{
	if( typ == KSGS_MAUSEREIGNIS )
		return ( ( KSGSMausEreignisKlasse* )this )->getVal();
	else
	{
		KSGSMausEreignisKlasse *tmp = (KSGSMausEreignisKlasse*)umwandelnIn( KSGS_MAUSEREIGNIS );
		if( tmp )
		{
			MausEreignis ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return MausEreignis{ 0, 0, 0, 0, 0, 0 };
	}
}

TastaturEreignis KSGSKlasseInstanz::getTastaturEreignis() const
{
	if( typ == KSGS_TASTATUREREIGNIS )
		return ( ( KSGSTastaturEreignisKlasse* )this )->getVal();
	else
	{
		KSGSTastaturEreignisKlasse *tmp = (KSGSTastaturEreignisKlasse*)umwandelnIn( KSGS_TASTATUREREIGNIS );
		if( tmp )
		{
			TastaturEreignis ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return TastaturEreignis{ 0, 0, 0 };
	}
}

TextFeld *KSGSKlasseInstanz::getTextFeld() const
{
	if( typ == KSGS_TEXTFELD )
		return ( ( KSGSTextFeldKlasse* )this )->getVal();
	else
	{
		KSGSTextFeldKlasse *tmp = (KSGSTextFeldKlasse*)umwandelnIn( KSGS_TEXTFELD );
		if( tmp )
		{
			TextFeld *ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new TextFeld();
	}
}

Knopf *KSGSKlasseInstanz::getKnopf() const
{
	if( typ == KSGS_KNOPF )
		return ( ( KSGSKnopfKlasse* )this )->getVal();
	else
	{
		KSGSKnopfKlasse *tmp = (KSGSKnopfKlasse*)umwandelnIn( KSGS_KNOPF );
		if( tmp )
		{
			Knopf *ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new Knopf();
	}
}

Fenster *KSGSKlasseInstanz::getFenster() const
{
	if( typ == KSGS_FENSTER )
		return ( ( KSGSFensterKlasse* )this )->getVal();
	else
	{
		KSGSFensterKlasse *tmp = (KSGSFensterKlasse*)umwandelnIn( KSGS_FENSTER );
		if( tmp )
		{
			Fenster *ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new Fenster();
	}
}

BildZ *KSGSKlasseInstanz::getBildZ() const
{
	if( typ == KSGS_BILDO )
		return ( ( KSGSBildZKlasse* )this )->getVal();
	else
	{
		KSGSBildZKlasse *tmp = (KSGSBildZKlasse*)umwandelnIn( KSGS_BILDO );
		if( tmp )
		{
			BildZ *ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new BildZ();
	}
}

Animation2DData *KSGSKlasseInstanz::getAnimation2DData() const
{
	if( typ == KSGS_ANIMATION2DDATA )
		return ( ( KSGSAnimation2DDataKlasse* )this )->getVal();
	else
	{
		KSGSAnimation2DDataKlasse *tmp = (KSGSAnimation2DDataKlasse*)umwandelnIn( KSGS_ANIMATION2DDATA );
		if( tmp )
		{
			Animation2DData *ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new Animation2DData();
	}
}

Animation2D *KSGSKlasseInstanz::getAnimation2D() const
{
	if( typ == KSGS_ANIMATION2D )
		return ( ( KSGSAnimation2DKlasse* )this )->getVal();
	else
	{
		KSGSAnimation2DKlasse *tmp = (KSGSAnimation2DKlasse*)umwandelnIn( KSGS_ANIMATION2D );
		if( tmp )
		{
			Animation2D *ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new Animation2D();
	}
}

Zeichnung *KSGSKlasseInstanz::getZeichnung() const
{
	switch( typ )
	{
	case KSGS_TEXTFELD:
		return ((KSGSTextFeldKlasse*)this)->zVal();
	case KSGS_KNOPF:
		return ( ( KSGSKnopfKlasse* )this )->zVal();
	case KSGS_FENSTER:
		return ( ( KSGSFensterKlasse* )this )->zVal();
	case KSGS_BILDO:
		return ( ( KSGSBildZKlasse* )this )->zVal();
	case KSGS_ANIMATION2D:
		return ( ( KSGSAnimation2DKlasse* )this )->zVal();
	}
	return 0;
}

RCArray< KSGSVariable > *KSGSKlasseInstanz::getArray() const
{
	if( typ == KSGS_ARRAY )
		return ( ( KSGSArrayKlasse* )this )->getVal();
	else
	{
		KSGSArrayKlasse *tmp = (KSGSArrayKlasse*)umwandelnIn( KSGS_ARRAY );
		if( tmp )
		{
			RCArray< KSGSVariable > *ret = tmp->getVal();
			tmp->release();
			return ret;
		}
		return new RCArray< KSGSVariable >();
	}
}

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

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

// static
KSGSVariable *KSGSKlasseInstanz::erstellVariable( KSGScriptObj *zObj, KSGSVariableDef *def )
{
	if( !def )
	{
		error( 0, {}, zObj );
		return 0;
	}
	if( def->typId < KSGS_TYP_MIN )
	{
		error( 0, {}, zObj );
		return 0;
	}
	if( def->typId <= KSGS_TYP_MAX )
	{ // Vordefinierter Typ
		switch( def->typId )
		{
		case KSGS_BOOL:
			if( def->wert.istGleich( "true" ) )
				return new KSGSBoolKlasse( zObj, 1 );
			if( def->wert.istGleich( "false" ) )
				return new KSGSBoolKlasse( zObj, 0 );
			if( def->wert.getLength() )
				return new KSGSBoolKlasse( zObj, ( int )def->wert != 0 );
			return new KSGSBoolKlasse( zObj );
		case KSGS_INT:
			if( def->wert.getLength() )
				return new KSGSIntKlasse( zObj, def->wert );
			return new KSGSIntKlasse( zObj );
		case KSGS_DOUBLE:
			if( def->wert.getLength() )
				return new KSGSDoubleKlasse( zObj, def->wert );
			return new KSGSDoubleKlasse( zObj );
		case KSGS_TEXT:
			if( def->wert.getLength() )
				return new KSGSTextKlasse( zObj, def->wert );
			return new KSGSTextKlasse( zObj );
		case KSGS_BILD:
			return new KSGSBildKlasse( zObj );
		case KSGS_MAUSEREIGNIS:
			return new KSGSMausEreignisKlasse( zObj );
		case KSGS_TASTATUREREIGNIS:
			return new KSGSTastaturEreignisKlasse( zObj );
		case KSGS_TEXTFELD:
			return new KSGSTextFeldKlasse( zObj );
		case KSGS_KNOPF:
			return new KSGSKnopfKlasse( zObj );
		case KSGS_FENSTER:
			return new KSGSFensterKlasse( zObj );
		case KSGS_BILDO:
			return new KSGSBildZKlasse( zObj );
		case KSGS_ANIMATION2DDATA:
			return new KSGSAnimation2DDataKlasse( zObj );
		case KSGS_ANIMATION2D:
			return new KSGSAnimation2DKlasse( zObj );
		default:
			error( 1, {}, zObj );
			break;
		}
		return 0;
	}
	else if( zObj ) // Im Script Definierter Typ
		return zObj->erstellKlassenInstanz( def->typId );
	error( 0, {}, zObj );
	return 0;
}


// Inhalt der KSGSKlasse Klasse aus KSGSKlasse.h
// Konstruktor
KSGSKlasse::KSGSKlasse( int id )
{
	var = new Array< KSGSVariableDef* >();
	funktionen = new RCArray< KSGSFunktion >();
	this->id = id;
	ref = 1;
}

// Destruktor
KSGSKlasse::~KSGSKlasse()
{
	int anz = var->getEintragAnzahl();
	for( int i = 0; i < anz; i++ )
		delete var->get( i );
	var->release();
	funktionen->release();
}

// nicht constant
void KSGSKlasse::addVariable( KSGSVariableDef *var )
{
	this->var->add( var );
}

void KSGSKlasse::addFunktion( KSGSFunktion *func )
{
	funktionen->add( func );
}

KSGSKlasseInstanz *KSGSKlasse::erstellInstanz( KSGScriptObj *zObj )
{
	return new KSGSKlasseInstanz( id, var, funktionen->getThis(), zObj );
}

// constant
int KSGSKlasse::getId() const
{
	return id;
}

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

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