#include "KETeams.h"
#include "../../../../Global/Initialisierung.h"
#include "../../../../Global/Variablen.h"

bool KETNachME( void *p, void *obj, MausEreignis me )
{
    if( p )
        ( (KETeams*)p )->nachME( obj, me );
    return 1;
}

bool KETNachTE( void *p, void *obj, TastaturEreignis te )
{
    if( p )
        ( (KETeams*)p )->nachTE( obj, te );
    return 1;
}

// Inhalt der KETeams Klasse aus KETeams.h
// Konstruktor
KETeams::KETeams( int karte, Schrift *zSchrift )
    : Thread()
{
    schrift = zSchrift->getThis();
    Text *kName = infoKlient->getKarteName( karte );
    Text titel = kName ? kName->getText() : "<Karte>";
    titel += " - Teams";
    if( kName )
        kName->release();
    fenster = initFenster( 10, 40, 880, 550, zSchrift, Fenster::Style::Sichtbar | Fenster::Style::Titel | Fenster::Style::TitelBuffered | Fenster::Style::Erlaubt | Fenster::Style::Rahmen, titel );
    teams = initAuswahlListe( 10, 10, 265, 510, zSchrift, AuswahlListe::Style::Normal, {} );
    teams->setNMausEreignisParameter( this );
    teams->setNMausEreignis( KETNachME );
    tName = initTextFeld( 285, 10, 150, 20, zSchrift, TextFeld::Style::TextFeld & ~TextFeld::Style::Erlaubt, "Team Name" );
    initToolTip( tName, "Name des Teams ändern", zSchrift->getThis(), hauptScreen );
    tName->setNTastaturEreignisParameter( this );
    tName->setNTastaturEreignis( KETNachTE );
    tFarbe = initTextFeld( 285, 40, 150, 20, zSchrift, TextFeld::Style::TextFeld & ~TextFeld::Style::Erlaubt, "Team Farbe" );
    initToolTip( tFarbe, "Farbe des Teams ändern", zSchrift->getThis(), hauptScreen );
    tFarbe->setTastaturEreignis( _nurHexTE );
    tFarbe->setNTastaturEreignisParameter( this );
    tFarbe->setNTastaturEreignis( KETNachTE );
    tFarbeV = initZeichnungHintergrund( 285, 70, 150, 20, ZeichnungHintergrund::Style::Sichtbar | ZeichnungHintergrund::Style::Hintergrund, 0 );
    tNeu = initKnopf( 285, 100, 150, 20, zSchrift, Knopf::Style::Sichtbar, "Neues Team" );
    tNeu->setNMausEreignisParameter( this );
    tNeu->setNMausEreignis( KETNachME );
    tLöschen = initKnopf( 285, 130, 150, 20, zSchrift, Knopf::Style::Sichtbar, "Team remove" );
    tLöschen->removeStyle( Knopf::Style::Erlaubt );
    tLöschen->setNMausEreignisParameter( this );
    tLöschen->setNMausEreignis( KETNachME );
    spieler = initAuswahlListe( 445, 10, 265, 510, zSchrift, AuswahlListe::Style::Normal & ~AuswahlListe::Style::Erlaubt, {} );
    spieler->setNMausEreignisParameter( this );
    spieler->setNMausEreignis( KETNachME );
    sFarbe = initTextFeld( 720, 10, 150, 20, zSchrift, TextFeld::Style::TextFeld & ~TextFeld::Style::Erlaubt, "Spieler Farbe" );
    initToolTip( sFarbe, "Farbe des Spielers ändern", zSchrift->getThis(), hauptScreen );
    sFarbe->setTastaturEreignis( _nurHexTE );
    sFarbe->setNTastaturEreignisParameter( this );
    sFarbe->setNTastaturEreignis( KETNachTE );
    sFarbeV = initZeichnungHintergrund( 720, 40, 150, 20, ZeichnungHintergrund::Style::Sichtbar | ZeichnungHintergrund::Style::Hintergrund, 0 );
    sNeu = initKnopf( 720, 70, 150, 20, zSchrift, Knopf::Style::Sichtbar, "Neuer Spieler" );
    sNeu->removeStyle( Knopf::Style::Erlaubt );
    sNeu->setNMausEreignisParameter( this );
    sNeu->setNMausEreignis( KETNachME );
    sLöschen = initKnopf( 720, 100, 150, 20, zSchrift, Knopf::Style::Sichtbar, "Spieler remove" );
    sLöschen->removeStyle( Knopf::Style::Erlaubt );
    sLöschen->setNMausEreignisParameter( this );
    sLöschen->setNMausEreignis( KETNachME );
    abbrechen = initKnopf( 720, 470, 150, 20, zSchrift, Knopf::Style::Sichtbar, "Abbrechen" );
    initToolTip( abbrechen, "Verwirft alle änderungen an den Team Einstellungen", zSchrift->getThis(), hauptScreen );
    abbrechen->setNMausEreignisParameter( this );
    abbrechen->setNMausEreignis( KETNachME );
    speichern = initKnopf( 720, 500, 150, 20, zSchrift, Knopf::Style::Sichtbar, "Speichern" );
    initToolTip( speichern, "Speichert alle Änderungen an den Team Einstellungen", zSchrift->getThis(), hauptScreen );
    speichern->setNMausEreignisParameter( this );
    speichern->setNMausEreignis( KETNachME );
    fenster->addMember( teams );
    fenster->addMember( tName );
    fenster->addMember( tFarbe );
    fenster->addMember( tFarbeV );
    fenster->addMember( tNeu );
    fenster->addMember( tLöschen );
    fenster->addMember( spieler );
    fenster->addMember( sFarbe );
    fenster->addMember( sFarbeV );
    fenster->addMember( sNeu );
    fenster->addMember( sLöschen );
    fenster->addMember( abbrechen );
    fenster->addMember( speichern );
    laden = (Animation2D*)ladeAnimation->dublizieren();
    laden->setPosition( 425, 275 );
    laden->setSichtbar( 0 );
    sts = new SpielerTeamStruktur();
    animation = 0;
    tickVal = 0;
    sichtbar = 0;
    rechts = 0;
    xStart = 0;
    breite = 0;
    aktion = 0;
    this->karte = karte;
    alpha = 255;
    ref = 1;
}

// Destruktor
KETeams::~KETeams()
{
    if( run )
    {
        warteAufThread( 5000 );
        if( run )
            ende();
    }
    fenster->release();
    laden->release();
    schrift->release();
    teams->release();
    tName->release();
    tFarbe->release();
    delete tFarbeV;
    tNeu->release();
    tLöschen->release();
    spieler->release();
    sFarbe->release();
    delete sFarbeV;
    sNeu->release();
    sLöschen->release();
    abbrechen->release();
    speichern->release();
    sts->release();
}

// privat
void KETeams::updateGUI()
{
    Text *teamAusw = teams->zEintrag( teams->getAuswahl() ) ? teams->zEintrag( teams->getAuswahl() )->getText() : 0;
    Text *spielerAusw = spieler->zEintrag( spieler->getAuswahl() ) ? spieler->zEintrag( spieler->getAuswahl() )->getText() : 0;
    hauptScreen->lock();
    teams->deSelect();
    spieler->deSelect();
    while( teams->getEintragAnzahl() )
        teams->removeEintrag( 0 );
    while( spieler->getEintragAnzahl() )
        spieler->removeEintrag( 0 );
    for( int i = 0; i < sts->teamAnzahl; i++ )
    {
        teams->addEintrag( sts->teamName->z( i )->getText() );
        if( teamAusw && teamAusw->istGleich( sts->teamName->z( i )->getText() ) )
        {
            teams->setAuswahl( i );
            tName->setText( sts->teamName->z( i )->getText() );
            Text f = "";
            f.appendHex( sts->teamFarbe->get( i ) );
            tFarbe->setText( f );
            tFarbeV->setHintergrundFarbe( sts->teamFarbe->get( i ) );
        }
    }
    int start = 0;
    for( int i = 0; i < teams->getAuswahl(); i++ )
        start += sts->teamGröße->get( i );
    bool tausw = teams->zEintrag( teams->getAuswahl() ) != 0;
    if( tausw )
    {
        for( int i = 0; i < sts->teamGröße->get( teams->getAuswahl() ); i++ )
        {
            Text n = "Spieler ";
            n += i + 1;
            spieler->addEintrag( n );
            if( spielerAusw && spielerAusw->istGleich( n ) )
            {
                spieler->setAuswahl( i );
                Text f = "";
                f.appendHex( sts->spielerFarbe->get( start + i ) );
                sFarbe->setText( f );
                sFarbeV->setHintergrundFarbe( sts->spielerFarbe->get( start + i ) );
            }
        }
    }
    sts->spielerAnzahl = 0;
    for( int i = 0; i < sts->teamAnzahl; i++ )
        sts->spielerAnzahl += sts->teamGröße->get( i );
    hauptScreen->unlock();
    bool sAusw = spieler->zEintrag( spieler->getAuswahl() ) != 0;
    tName->setStyle( TextFeld::Style::Erlaubt, tausw );
    tFarbe->setStyle( TextFeld::Style::Erlaubt, tausw );
    tLöschen->setStyle( Knopf::Style::Erlaubt, tausw );
    spieler->setStyle( AuswahlListe::Style::Erlaubt, tausw );
    sNeu->setStyle( Knopf::Style::Erlaubt, tausw );
    sFarbe->setStyle( TextFeld::Style::Erlaubt, sAusw );
    sLöschen->setStyle( Knopf::Style::Erlaubt, sAusw );
    if( teamAusw )
        teamAusw->release();
    if( spielerAusw )
        spielerAusw->release();
}

// nicht constant
void KETeams::nachME( void *obj, MausEreignis &me )
{
    if( me.id != ME_RLinks )
        return;
    if( obj == speichern )
    {
        aktion = 1;
        start();
    }
    if( obj == abbrechen )
    {
        aktion = 0;
        start();
    }
    if( obj == tNeu )
    {
        sts->teamGröße->set( 0, sts->teamAnzahl );
        sts->teamFarbe->set( 0, sts->teamAnzahl );
        Text tn = "";
        bool ex = 1;
        for( int i = 1; ex; i++ )
        {
            tn = "Team ";
            tn += i;
            ex = 0;
            for( int j = 0; j < sts->teamAnzahl; j++ )
            {
                if( sts->teamName->z( j )->istGleich( tn ) )
                {
                    ex = 1;
                    break;
                }
            }
        }
        sts->teamName->set( new Text( (char*)tn ), sts->teamAnzahl );
        sts->teamAnzahl++;
        updateGUI();
    }
    if( obj == tLöschen )
    {
        sts->teamGröße->remove( teams->getAuswahl() );
        sts->teamFarbe->remove( teams->getAuswahl() );
        sts->teamName->remove( teams->getAuswahl() );
        sts->teamAnzahl--;
        updateGUI();
    }
    if( obj == sNeu )
    {
        int start = 0;
        for( int i = 0; i < teams->getAuswahl(); i++ )
            start += sts->teamGröße->get( i );
        sts->spielerFarbe->add( 0, start + sts->teamGröße->get( teams->getAuswahl() ) );
        sts->teamGröße->set( sts->teamGröße->get( teams->getAuswahl() ) + 1, teams->getAuswahl() );
        updateGUI();
    }
    if( obj == sLöschen )
    {
        int start = 0;
        for( int i = 0; i < teams->getAuswahl(); i++ )
            start += sts->teamGröße->get( i );
        sts->spielerFarbe->remove( start + spieler->getAuswahl() );
        sts->teamGröße->set( sts->teamGröße->get( teams->getAuswahl() ) - 1, teams->getAuswahl() );
        updateGUI();
    }
    if( obj == teams )
        updateGUI();
    if( obj == spieler )
        updateGUI();
}

void KETeams::nachTE( void *obj, TastaturEreignis &te )
{
    if( te.id != TE_Release )
        return;
    if( obj == tName )
    {
        sts->teamName->set( new Text( tName->zText()->getText() ), teams->getAuswahl() );
        teams->zEintrag( teams->getAuswahl() )->setText( sts->teamName->z( teams->getAuswahl() )->getText() );
    }
    if( obj == tFarbe )
    {
        sts->teamFarbe->set( TextZuInt( tFarbe->zText()->getText(), 16 ), teams->getAuswahl() );
        tFarbeV->setHintergrundFarbe( sts->teamFarbe->get( teams->getAuswahl() ) );
    }
    if( obj == sFarbe )
    {
        int start = 0;
        for( int i = 0; i < teams->getAuswahl(); i++ )
            start += sts->teamGröße->get( i );
        sts->spielerFarbe->set( TextZuInt( sFarbe->zText()->getText(), 16 ), start + spieler->getAuswahl() );
        sFarbeV->setHintergrundFarbe( sts->spielerFarbe->get( start + spieler->getAuswahl() ) );
    }
}

void KETeams::setSichtbar( bool s, bool vr )
{
    animation = 1;
    sichtbar = s;
    rechts = vr;
    if( sichtbar )
    {
        if( vr )
        {
            xStart = 900;
            breite = 0;
        }
        else
        {
            xStart = 0;
            breite = 0;
        }
        if( !run )
        {
            aktion = 0;
            start();
        }
    }
}

void KETeams::thread()
{
    laden->setSichtbar( 1 );
    if( aktion == 0 )
    { // Laden
        if( !editorKlient->ladeTeamDaten( sts ) )
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( editorKlient->getLetzterFehler() ), new Text( "Ok" ) );
        else
            updateGUI();
    }
    if( aktion == 1 )
    { // Speichern
        if( !editorKlient->speicherTeamDaten( sts ) )
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( editorKlient->getLetzterFehler() ), new Text( "Ok" ) );
    }
    run = 0;
    laden->setSichtbar( 0 );
    return;
}

void KETeams::doMausEreignis( MausEreignis &me )
{
    if( !run )
        fenster->doMausEreignis( me );
}

void KETeams::doTastaturEreignis( TastaturEreignis &te )
{
    if( !run )
        fenster->doTastaturEreignis( te );
}

bool KETeams::tick( double z )
{
    bool ret = laden->tick( z );
    tickVal += z * 150;
    int val = (int)tickVal;
    tickVal -= val;
    if( val )
    {
        if( run && alpha > 100 )
        {
            if( alpha - val < 100 )
                alpha = 100;
            else
                alpha -= val;
            ret = 1;
        }
        if( sichtbar && !run && alpha != 255 )
        {
            if( alpha + val > 255 )
                alpha = 255;
            else
                alpha += val;
            ret = 1;
        }
        val *= 3;
        if( sichtbar )
        {
            if( alpha < 100 )
            {
                if( alpha + val > 100 )
                    alpha = 100;
                else
                    alpha += val;
                ret = 1;
            }
            if( xStart != 0 || breite != 900 )
            {
                if( rechts )
                {
                    if( xStart - val <= 0 )
                    {
                        xStart = 0;
                        breite = 900;
                        animation = 0;
                    }
                    else
                    {
                        xStart -= val;
                        breite += val;
                    }
                }
                else
                {
                    if( breite + val >= 900 )
                    {
                        breite = 900;
                        animation = 0;
                    }
                    else
                        breite += val;
                }
                ret = 1;
            }
        }
        else
        {
            if( breite != 0 )
            {
                if( rechts )
                {
                    if( breite - val <= 0 )
                    {
                        breite = 0;
                        animation = 0;
                    }
                    else
                        breite -= val;
                }
                else
                {
                    if( breite - val <= 0 )
                    {
                        breite = 0;
                        xStart = 900;
                        animation = 0;
                    }
                    else
                    {
                        breite -= val;
                        xStart += val;
                    }
                }
                ret = 1;
            }
        }
    }
    return ret || fenster->tick( z );
}

void KETeams::render( Bild &zRObj )
{
    if( !zRObj.setDrawOptions( xStart, 0, breite, 600 ) )
        return;
    zRObj.setAlpha( alpha );
    fenster->render( zRObj );
    zRObj.releaseAlpha();
    laden->render( zRObj );
    zRObj.releaseDrawOptions();
}

// constant
bool KETeams::istSichtbar() const
{
    return sichtbar || animation;
}

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

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