#include "EditorKarte.h"
#include <Model2D.h>
#include <Bild.h>
#include <Textur2D.h>

using namespace Editor;

KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
    : Thread()
{
    welt = new Welt2D();
    welt->setCircular( 1 );
    this->client = client;
    this->sts = (SpielerTeamStruktur *)sts->getThis();
    client->loadMapSize( size );
    client->loadResources( resources );
    client->loadSpieler( spieler );
    client->loadTeams( teams );
    client->loadObjekte( objekte );
    welt->setSize( size.x, size.y );
    welt->setSize( 1 );
    for( auto s = spieler.getIterator(); s; s++ )
    {
        Model2DObject *model = new Model2DObject();
        Bild *bild;
        int fc = sts->spielerFarbe->get( s->id - 1 );
        for( auto r = resources.getIterator(); r; r++ )
        {
            if( r->id == s->m2d )
                model->setModel( client->loadModel( r->path ) );
            if( r->id == s->bild )
                bild = client->loadBild( r->path );
        }
        if( bild )
        {
            Bild *shb = new Bild();
            shb->neuBild( bild->getBreite(), bild->getHeight(), 0 );
            int maxP = shb->getBreite() * shb->getHeight();
            int *buffer = bild->getBuffer();
            for( int i = 0; i < maxP; i++ )
            {
                if( buffer[ i ] )
                {
                    shb->setPixelDP( i, fc );
                    shb->alphaPixelDP2D( i, buffer[ i ] );
                }
            }
            Textur2D *textur = new Textur2D();
            textur->setTexturZ( shb );
            model->setTextur( textur, "ship" );
            bild->release();
        }
        model->setPosition( s->pos );
        model->setCollision( 0 );
        welt->addObject( model );
    }
    exit = 0;
    start();
}

KarteDaten::~KarteDaten()
{
    cs.lock();
    for( auto i = resources.getIterator(); i; i++ )
        delete i._;
    for( auto i = objekte.getIterator(); i; i++ )
        delete i._;
    for( auto i = spieler.getIterator(); i; i++ )
        delete i._;
    for( auto i = teams.getIterator(); i; i++ )
        delete i._;
    sts->release();
    client->release();
    welt->release();
}

void KarteDaten::addObjekt( ObjektDaten & daten )
{
    ObjektDaten *nd = new ObjektDaten( daten );
    cs.lock();
    nd->id = objekte.getEintragAnzahl();
    objekte.add( nd );
    ObjektDaten td = *nd;
    EditorKlient *c = client;
    aktionen.add( [ td, c ]()
    {
        c->saveObjekt( &td );
    } );
    cs.unlock();
}

void KarteDaten::removeObjekt( int index )
{
    cs.lock();
    int id = objekte.get( index )->id;
    delete objekte.get( index );
    objekte.remove( index );
    EditorKlient *c = client;
    aktionen.add( [ id, c ]()
    {
        c->deleteObjekt( id );
    } );
    cs.unlock();
}

void KarteDaten::getObjekt( int index, std::function< bool( ObjektDaten * ) > callBack )
{
    cs.lock();
    if( callBack( objekte.get( index ) ) )
    {
        ObjektDaten td = *objekte.get( index );
        EditorKlient *c = client;
        aktionen.add( [ td, c ]()
        {
            c->saveObjekt( &td );
        } );
    }
    cs.unlock();
}

void KarteDaten::getSpieler( int index, std::function< bool( SpielerDaten * ) > callBack )
{
    cs.lock();
    if( callBack( spieler.get( index ) ) )
    {
        SpielerDaten td = *spieler.get( index );
        EditorKlient *c = client;
        aktionen.add( [ td, c ]()
        {
            c->saveSpieler( &td );
        } );
    }
    cs.unlock();
}

void KarteDaten::getTeam( int index, std::function< bool( TeamDaten * ) > callBack )
{
    cs.lock();
    if( callBack( teams.get( index ) ) )
    {
        TeamDaten td = *teams.get( index );
        EditorKlient *c = client;
        aktionen.add( [ td, c ]()
        {
            c->saveTeam( &td );
        } );
    }
    cs.unlock();
}

void KarteDaten::thread()
{
    while( !exit )
    {
        cs.lock();
        while( hasAktions() )
        {
            std::function< void() > ak = aktionen.get( 0 );
            cs.unlock();
            ak();
            cs.lock();
            aktionen.remove( 0 );
        }
        cs.unlock();
        Sleep( 100 );
    }
}

const ObjektDaten *KarteDaten::getObjekt( int index )
{
    ObjektDaten *ret = 0;
    cs.lock();
    ret = objekte.get( index );
    cs.unlock();
    return ret;
}

const SpielerDaten *KarteDaten::getSpieler( int index )
{
    SpielerDaten *ret = 0;
    cs.lock();
    ret = spieler.get( index );
    cs.unlock();
    return ret;
}

const TeamDaten *KarteDaten::getTeam( int index )
{
    TeamDaten *ret = 0;
    cs.lock();
    ret = teams.get( index );
    cs.unlock();
    return ret;
}

int KarteDaten::getSpielerIndexById( int id )
{
    int index = 0;
    cs.lock();
    for( auto i = spieler.getIterator(); i; i++ )
    {
        if( i->id == id )
            break;
        index++;
    }
    cs.unlock();
    return index;
}

int KarteDaten::getSpielerAnzahl() const
{
    return spieler.getEintragAnzahl();
}

int KarteDaten::getTeamIndexById( int id )
{
    int index = 0;
    cs.lock();
    for( auto i = teams.getIterator(); i; i++ )
    {
        if( i->id == id )
            break;
        index++;
    }
    cs.unlock();
    return index;
}

int KarteDaten::getTeamAnzahl() const
{
    return teams.getEintragAnzahl();
}

int KarteDaten::getObjektAnzahl() const
{
    return objekte.getEintragAnzahl();
}

bool KarteDaten::hasError() const
{
    return !error.istGleich( "" );
}

char *KarteDaten::getError() const
{
    return error;
}

bool KarteDaten::hasAktions() const
{
    return aktionen.getEintragAnzahl() > 0;
}

Welt2D *KarteDaten::getWelt() const
{
    return welt->getThis();
}

Welt2D *KarteDaten::zWelt() const
{
    return welt;
}

// löscht das objekt wenn es nicht mehr gebraucht wird und beendet den Thread
Thread *KarteDaten::release()
{
    if( Thread::ref == 2 && run )
    {
        exit = 1;
        if( isRunning() )
            warteAufThread( INT_MAX );
    }
    return Thread::release();
}