#include "KESSEditor.h"
#include "KEShopSeite.h"
#include "../../../../Global/Initialisierung.h"
#include <MausEreignis.h>
#include <Text.h>
#include "../../../../Global/Variablen.h"
#include <DateiSystem.h>

// Inhalt der KESSTextSeite Klasse aus KESSEditor.h
// Konstruktor
KESSTextSeite::KESSTextSeite( Schrift *zSchrift, Knopf *zNeueDatei, Knopf *zDateiRemove )
{
    LTDSDatei *sd = new LTDSDatei();
    sd->setPfad( new Text( "data/schriften/ksgs.ltds" ) );
    sd->leseDaten();
    Schrift *ksgsS = sd->ladeSchrift();
    sd->release();
    text = initTextFeld( 220, 10, 540, 510, ksgsS ? ksgsS : zSchrift, TextFeld::Style::TextGebiet | TextFeld::Style::HScroll, "" );
    if( ksgsS )
        ksgsS->release();
    speichern = initKnopf( 770, 10, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Speichern" );
    dateiLöschen = zDateiRemove->getThis();
    neueDatei = zNeueDatei->getThis();
    aktion = 0;
    sichtbar = 0;
    alpha = 0;
    tickVal = 0;
    ref = 1;
}

// Destruktor
KESSTextSeite::~KESSTextSeite()
{
    text->release();
    speichern->release();
    dateiLöschen->release();
    neueDatei->release();
}

// nicht constant
int KESSTextSeite::getAktion()
{
    int ret = aktion;
    aktion = 0;
    return ret;
}

void KESSTextSeite::setDateiText( Text *txt )
{
    text->setText( txt );
}

void KESSTextSeite::setSichtbar( bool s )
{
    sichtbar = s;
}

bool KESSTextSeite::tick( double tv )
{
    bool ret = text->tick( tv );
    ret |= speichern->tick( tv );
    ret |= dateiLöschen->tick( tv );
    ret |= neueDatei->tick( tv );
    tickVal += tv * 150;
    int val = 0;
    if( tickVal > 1 )
        val = (int)tickVal;
    else
        return ret;
    if( sichtbar && alpha != 255 )
    {
        if( alpha + val > 255 )
            alpha = 255;
        else
            alpha += val;
        ret = 1;
    }
    if( !sichtbar && alpha != 0 )
    {
        if( alpha - val < 0 )
            alpha = 0;
        else
            alpha -= val;
        ret = 1;
    }
    return ret;
}

void KESSTextSeite::doMausEreignis( MausEreignis &me )
{
    if( !sichtbar )
        return;
    text->doMausEreignis( me );
    bool vera = me.verarbeitet;
    speichern->doMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
        aktion = 1;
    vera = me.verarbeitet;
    dateiLöschen->doMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
        aktion = 2;
    vera = me.verarbeitet;
    neueDatei->doMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
        aktion = 3;
}

void KESSTextSeite::doTastaturEreignis( TastaturEreignis &te )
{
    if( !sichtbar )
        return;
    text->doTastaturEreignis( te );
}

void KESSTextSeite::render( Bild &zRObj )
{
    if( !alpha )
        return;
    zRObj.setAlpha( alpha );
    text->render( zRObj );
    speichern->render( zRObj );
    neueDatei->setPosition( 770, 70 );
    neueDatei->render( zRObj );
    dateiLöschen->setPosition( 770, 40 );
    dateiLöschen->render( zRObj );
    zRObj.releaseAlpha();
}

// constant
Text *KESSTextSeite::zDateiText() const
{
    return text->zText();
}

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

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


// Inhalt der KESSBildSeite Klasse aus KESSEditor.h
// Konstruktor
KESSBildSeite::KESSBildSeite( Schrift *zSchrift, Knopf *zNeueDatei, Knopf *zDateiRemove )
{
    bilder = initAuswahlListe( 220, 10, 200, 510, zSchrift, AuswahlListe::Style::Normal, {} );
    bildObj = initBildZ( 430, 10, 440, 440, BildZ::Style::normal | BildZ::Style::Alpha, 0 );
    bildLöschen = initKnopf( 430, 460, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Bild Löschen" );
    importieren = initKnopf( 430, 490, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Importieren" );
    dateiLöschen = zDateiRemove->getThis();
    neueDatei = zNeueDatei->getThis();
    importDialog = 0;
    importPfad = 0;
    aktion = 0;
    sichtbar = 0;
    alpha = 0;
    alpha2 = 0;
    tickVal = 0;
    ref = 1;
}

// Destruktor
KESSBildSeite::~KESSBildSeite()
{
    bilder->release();
    bildObj->release();
    bildLöschen->release();
    importieren->release();
    dateiLöschen->release();
    neueDatei->release();
    if( importDialog )
        importDialog->release();
    if( importPfad )
        importPfad->release();
}

// nicht constant
int KESSBildSeite::getAktion()
{
    int ret = aktion;
    aktion = 0;
    return ret;
}

void KESSBildSeite::setBildListe( RCArray< Text > *list )
{
    hauptScreen->lock();
    Text txt = bilder->zEintrag( bilder->getAuswahl() ) ? bilder->zEintrag( bilder->getAuswahl() )->zText()->getText() : "";
    while( bilder->getEintragAnzahl() )
        bilder->removeEintrag( 0 );
    int anz = list->getEintragAnzahl();
    int ausw = -1;
    for( int i = 0; i < anz; i++ )
    {
        if( list->z( i )->istGleich( txt ) )
            ausw = i;
        bilder->addEintrag( list->get( i ) );
    }
    if( ausw >= 0 )
        bilder->setAuswahl( ausw );
    else
        bilder->deSelect();
    list->release();
    hauptScreen->unlock();
}

void KESSBildSeite::setBild( Bild *b )
{
    hauptScreen->lock();
    bildObj->setBild( b );
    hauptScreen->unlock();
}

void KESSBildSeite::setSichtbar( bool s )
{
    sichtbar = s;
}

bool KESSBildSeite::tick( double tv )
{
    if( importDialog )
    {
        if( !importDialog->isRunning() )
        {
            if( importPfad )
                importPfad->release();
            importPfad = importDialog->getPfad();
            importDialog = importDialog->release();
            if( sichtbar && importPfad )
                aktion = 3;
        }
    }
    bool ret = bilder->tick( tv );
    ret |= bildObj->tick( tv );
    ret |= bildLöschen->tick( tv );
    ret |= importieren->tick( tv );
    ret |= dateiLöschen->tick( tv );
    ret |= neueDatei->tick( tv );
    tickVal += tv * 150;
    int val = 0;
    if( tickVal > 1 )
        val = (int)tickVal;
    else
        return ret;
    if( sichtbar && alpha != 255 )
    {
        if( alpha + val > 255 )
            alpha = 255;
        else
            alpha += val;
        ret = 1;
    }
    if( !sichtbar && alpha != 0 )
    {
        if( alpha - val < 0 )
            alpha = 0;
        else
            alpha -= val;
        ret = 1;
    }
    if( sichtbar && bilder->getAuswahl() >= 0 && alpha2 != 255 )
    {
        if( alpha2 + val > 255 )
            alpha2 = 255;
        else
            alpha2 += val;
        ret = 1;
    }
    if( ( !sichtbar || bilder->getAuswahl() < 0 ) && alpha2 != 0 )
    {
        if( alpha2 - val < 0 )
            alpha2 = 0;
        else
            alpha2 -= val;
        ret = 1;
    }
    return ret;
}

void KESSBildSeite::doMausEreignis( MausEreignis &me )
{
    if( !sichtbar )
        return;
    int ausw = bilder->getAuswahl();
    bilder->doMausEreignis( me );
    if( ausw != bilder->getAuswahl() && me.id == ME_RLinks )
    {
        if( bilder->getAuswahl() >= 0 )
            aktion = 1;
        else
            bilder->setAuswahl( ausw );
    }
    bool vera = me.verarbeitet;
    dateiLöschen->doMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
        aktion = 4;
    vera = me.verarbeitet;
    neueDatei->doMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
        aktion = 5;
    vera = me.verarbeitet;
    importieren->doMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
    {
        if( !importDialog )
        {
            importDialog = new DateiDialogTh();
            importDialog->setOpen( 1 );
            importDialog->setDateiTypAuswahl( 4 );
            importDialog->addDateiTyp( "JPEG-Bild", "*.jpg;*.jpeg;*.jpe" );
            importDialog->addDateiTyp( "GIF-Bild", "*.gif" );
            importDialog->addDateiTyp( "PNG-Bild", "*.png" );
            importDialog->addDateiTyp( "Alle Dateien", "*.*" );
            importDialog->start();
        }
    }
    if( bilder->getAuswahl() < 0 )
        return;
    bildObj->doMausEreignis( me );
    vera = me.verarbeitet;
    bildLöschen->doMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
        aktion = 2;
}

void KESSBildSeite::render( Bild &zRObj )
{
    if( !alpha )
        return;
    zRObj.setAlpha( alpha );
    bilder->render( zRObj );
    neueDatei->setPosition( 540, 490 );
    neueDatei->render( zRObj );
    dateiLöschen->setPosition( 540, 460 );
    dateiLöschen->render( zRObj );
    importieren->render( zRObj );
    zRObj.setAlpha( alpha2 );
    bildObj->render( zRObj );
    bildLöschen->render( zRObj );
    zRObj.releaseAlpha();
    zRObj.releaseAlpha();
}

// constant
Text *KESSBildSeite::zBildImportPfad() const
{
    return importPfad;
}

Text *KESSBildSeite::zBildAuswahl() const
{
    if( !bilder->zEintrag( bilder->getAuswahl() ) )
        return 0;
    return bilder->zEintrag( bilder->getAuswahl() )->zText();
}

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

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


bool kESSEditorNeuDateiOkME( void *p, void *obj, MausEreignis me )
{
    if( p )
        return ( (KESSEditor*)p )->neuDateiOkME( me );
    else if( me.id == ME_RLinks )
        ( (Fenster*)obj )->removeStyle( Fenster::Style::Sichtbar );
    return 1;
}


// Inhalt der KESSEditor Klasse aus KESSEditor.h
// Konstruktor
KESSEditor::KESSEditor( Schrift *zSchrift )
    : Zeichnung()
{
    neueDatei = initKnopf( 0, 0, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Neue Datei" );
    dateiLöschen = initKnopf( 0, 0, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Datei Löschen" );
    dateien = initAuswahlListe( 10, 10, 200, 510, zSchrift, AuswahlListe::Style::Normal, {} );
    textSeite = new KESSTextSeite( zSchrift, neueDatei, dateiLöschen );
    bildSeite = new KESSBildSeite( zSchrift, neueDatei, dateiLöschen );
    vorschau = initKnopf( 770, 470, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Vorschau" );
    veröffentlichen = initKnopf( 770, 500, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Fertig" );
    initToolTip( veröffentlichen, "Veröffentlicht die geänderte Version der Shop-Seite.", zSchrift->getThis(), hauptScreen );
    neuDateiF = initFenster( 365, 145, 150, 120, zSchrift, Fenster::Style::Erlaubt | Fenster::Style::BodyHintergrund | Fenster::Style::BodyHAlpha |
                             Fenster::Style::Rahmen | Fenster::Style::Closable | Fenster::Style::ClosingKlickBuffer | Fenster::Style::ClosingHintergrund |
                             Fenster::Style::ClosingHAlpha | Fenster::Style::Titel | Fenster::Style::TitelHintergrund | Fenster::Style::TitelHAlpha | Fenster::Style::TitelBuffered, "Neue Datei" );
    neuDateiF->setKBgFarbe( 0xC0000000 );
    neuDateiF->setSBgFarbe( 0xC0000000 );
    neuDateiF->setTBgFarbe( 0xC0000000 );
    neuDateiF->setClosingMe( kESSEditorNeuDateiOkME );
    neuDateiTyp = initAuswahlBox( 10, 10, 130, 20, zSchrift, ABSTYLE, { "Ordner", "Bild (.ltdb)", "Script (.ksgs)" } );
    neuDateiName = initTextFeld( 10, 40, 130, 20, zSchrift, TextFeld::Style::TextFeld, "Datei Name" );
    neuDateiOk = initKnopf( 25, 70, 100, 20, zSchrift, Knopf::Style::Normal | Knopf::Style::Sichtbar, "Erstellen" );
    neuDateiOk->setMausEreignisParameter( this );
    neuDateiOk->setMausEreignis( kESSEditorNeuDateiOkME );
    neuDateiF->addMember( neuDateiName );
    neuDateiF->addMember( neuDateiOk );
    neuDateiF->addMember( neuDateiTyp );
    aktion = 0;
    sichtbar = 0;
    alpha = 0;
    alpha2 = 0;
    tickVal = 0;
    ref = 1;
}

// Destruktor
KESSEditor::~KESSEditor()
{
    dateien->release();
    textSeite->release();
    bildSeite->release();
    vorschau->release();
    veröffentlichen->release();
    neuDateiF->release();
    neuDateiTyp->release();
    neuDateiName->release();
    neuDateiOk->release();
    neueDatei->release();
    dateiLöschen->release();
}

// nicht constant
int KESSEditor::getAktion()
{
    int ret = aktion;
    aktion = 0;
    return ret;
}

bool KESSEditor::neuDateiOkME( MausEreignis &me )
{
    if( me.id == ME_RLinks )
    {
        neuDateiF->removeStyle( Fenster::Style::Sichtbar );
        aktion = 1;
    }
    return 1;
}

void KESSEditor::setDateiListe( RCArray< Text > *list )
{
    hauptScreen->lock();
    dateien->deSelect();
    while( dateien->getEintragAnzahl() )
        dateien->removeEintrag( 0 );
    int anz = list->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
        dateien->addEintrag( list->get( i ) );
    bildSeite->setSichtbar( 0 );
    textSeite->setSichtbar( 0 );
    neuDateiF->removeStyle( Fenster::Style::Sichtbar );
    list->release();
    hauptScreen->unlock();
}

void KESSEditor::setBildListe( RCArray< Text > *list )
{
    textSeite->setSichtbar( 0 );
    bildSeite->setBildListe( list );
    bildSeite->setSichtbar( 1 );
}

void KESSEditor::setDateiText( Text *txt )
{
    bildSeite->setSichtbar( 0 );
    textSeite->setDateiText( txt );
    textSeite->setSichtbar( 1 );
}

void KESSEditor::setBild( Bild *b )
{
    bildSeite->setBild( b );
}

void KESSEditor::setSichtbar( bool s )
{
    sichtbar = s;
}

bool KESSEditor::tick( double tv )
{
    int ak = textSeite->getAktion();
    switch( ak )
    {
    case 1: // Text Speichern
        aktion = 5;
        break;
    case 2: // Datei Löschen
        aktion = 4;
        break;
    case 3: // Neue Datei
        neuDateiF->addStyle( Fenster::Style::Sichtbar );
        break;
    }
    ak = bildSeite->getAktion();
    switch( ak )
    {
    case 1: // Bild Auswählen
        aktion = 3;
        break;
    case 2: // Bild Löschen
        aktion = 6;
        break;
    case 3: // Importieren
        aktion = 7;
        break;
    case 4: // Datei Löschen
        aktion = 4;
        break;
    case 5: // Neue Datei
        neuDateiF->addStyle( Fenster::Style::Sichtbar );
        break;
    }
    bool ret = dateien->tick( tv );
    ret |= textSeite->tick( tv );
    ret |= bildSeite->tick( tv );
    ret |= vorschau->tick( tv );
    ret |= veröffentlichen->tick( tv );
    ret |= neuDateiF->tick( tv );
    if( dateien->getAuswahl() < 0 )
    {
        ret |= neueDatei->tick( tv );
        if( dateien->getEintragAnzahl() > 0 && dateien->zEintrag( 0 )->zText()->istGleich( ".." ) )
            ret |= dateiLöschen->tick( tv );
    }
    tickVal += tv * 150;
    int val = 0;
    if( tickVal > 1 )
    {
        val = (int)tickVal;
        tickVal -= val;
    }
    else
        return ret;
    if( sichtbar && neuDateiF->hatStyle( Fenster::Style::Sichtbar ) && alpha2 > 100 )
    {
        if( alpha2 - val < 100 )
            alpha2 = 100;
        else
            alpha2 -= val;
        ret = 1;
    }
    if( sichtbar && neuDateiF->hatStyleNicht( Fenster::Style::Sichtbar ) && alpha2 < 255 )
    {
        if( alpha2 + val > 255 )
            alpha2 = 255;
        else
            alpha2 += val;
        ret = 1;
    }
    if( sichtbar && alpha != 255 )
    {
        if( alpha + val > 255 )
            alpha = 255;
        else
            alpha += val;
        ret = 1;
    }
    if( !sichtbar && alpha != 0 )
    {
        if( alpha - val < 0 )
            alpha = 0;
        else
            alpha -= val;
        ret = 1;
    }
    return ret;
}

void KESSEditor::doMausEreignis( MausEreignis &me )
{
    if( !sichtbar )
        return;
    if( neuDateiF->hatStyle( Fenster::Style::Sichtbar ) )
    {
        neuDateiF->doMausEreignis( me );
        return;
    }
    int ausw = dateien->getAuswahl();
    dateien->doMausEreignis( me );
    if( ausw != dateien->getAuswahl() && me.id == ME_RLinks )
    {
        if( dateien->getAuswahl() >= 0 )
            aktion = 2;
        else
            dateien->setAuswahl( ausw );
    }
    textSeite->doMausEreignis( me );
    bildSeite->doMausEreignis( me );
    if( dateien->getAuswahl() < 0 )
    {
        bool vera = me.verarbeitet;
        neueDatei->doMausEreignis( me );
        if( !vera && me.verarbeitet && me.id == ME_RLinks )
            neuDateiF->addStyle( Fenster::Style::Sichtbar );
        if( dateien->getEintragAnzahl() > 0 && dateien->zEintrag( 0 )->zText()->istGleich( ".." ) )
        {
            vera = me.verarbeitet;
            dateiLöschen->doMausEreignis( me );
            if( !vera && me.verarbeitet && me.id == ME_RLinks )
                aktion = 4;
        }
    }
    bool vera = me.verarbeitet;
    vorschau->doMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
        aktion = 8;
    vera = me.verarbeitet;
    veröffentlichen->doMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
        aktion = 9;
}

void KESSEditor::doTastaturEreignis( TastaturEreignis &te )
{
    if( neuDateiF->hatStyle( Fenster::Style::Sichtbar ) )
    {
        neuDateiF->doTastaturEreignis( te );
        return;
    }
    textSeite->doTastaturEreignis( te );
}

void KESSEditor::render( Bild &zRObj )
{
    zRObj.setAlpha( alpha );
    zRObj.setAlpha( alpha2 );
    dateien->render( zRObj );
    textSeite->render( zRObj );
    bildSeite->render( zRObj );
    vorschau->render( zRObj );
    veröffentlichen->render( zRObj );
    if( dateien->getAuswahl() < 0 )
    {
        neueDatei->setPosition( 770, 440 );
        neueDatei->render( zRObj );
        if( dateien->getEintragAnzahl() > 0 && dateien->zEintrag( 0 )->zText()->istGleich( ".." ) )
        {
            dateiLöschen->setPosition( 770, 410 );
            dateiLöschen->render( zRObj );
        }
    }
    zRObj.releaseAlpha();
    neuDateiF->render( zRObj );
    zRObj.releaseAlpha();
}

// constant
Text *KESSEditor::zDateiText() const
{
    return textSeite->zDateiText();
}

Text *KESSEditor::zBildImportPfad() const
{
    return bildSeite->zBildImportPfad();
}

Text *KESSEditor::zDateiAuswahl() const
{
    if( !dateien->zEintrag( dateien->getAuswahl() ) )
        return 0;
    return dateien->zEintrag( dateien->getAuswahl() )->zText();
}

Text *KESSEditor::zBildAuswahl() const
{
    return bildSeite->zBildAuswahl();
}

int KESSEditor::getNeuDateiTyp() const
{
    return neuDateiTyp->getAuswahl();
}

Text *KESSEditor::zNeuDateiName() const
{
    return neuDateiName->zText();
}

bool KESSEditor::istSichtbar() const
{
    return sichtbar;
}

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

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