#include "InitDatei.h"
#include "Text.h"
#include "Datei.h"

using namespace Framework;

// Inhalt der InitDatei Klasse aus InitDatei.h
// Konstruktor
InitDatei::InitDatei()
    : ReferenceCounter(),
    pfad( new Text() ),
    name( new RCArray< Text >() ),
    wert( new RCArray< Text >() )
{}

InitDatei::InitDatei( Text *pfad )
    : ReferenceCounter(),
    pfad( new Text() ),
    name( new RCArray< Text >() ),
    wert( new RCArray< Text >() )
{
    setPfad( pfad );
}

InitDatei::InitDatei( const char *pfad )
    : ReferenceCounter(),
    pfad( new Text() ),
    name( new RCArray< Text >() ),
    wert( new RCArray< Text >() )
{
    setPfad( pfad );
}

// Destruktor
InitDatei::~InitDatei()
{
    pfad->release();
    name->release();
    wert->release();
}

// nicht constant
void InitDatei::setPfad( Text *pfad )
{
    this->pfad->setText( pfad );
}

void InitDatei::setPfad( const char *pfad )
{
    this->pfad->setText( pfad );
}

bool InitDatei::laden()
{
    Datei *dat = new Datei();
    dat->setDatei( pfad->getText() );
    if( !dat->open( Datei::Style::lesen ) )
    {
        dat->release();
        return 0;
    }
    removeAlle();
    Text *zeile = dat->leseZeile();
    while( zeile )
    {
        zeile->remove( "\r\n" );
        zeile->remove( "\n" );
        Text *n = zeile->getTeilText( 0, zeile->positionVon( '=' ) );
        Text *w = zeile->getTeilText( zeile->positionVon( '=' ) + 1 );
        name->add( n );
        wert->add( w);
        zeile->release();
        zeile = dat->leseZeile();
    }
    dat->close();
    dat->release();
    return 1;
}

bool InitDatei::addWert( Text *name, Text *wert )
{
    if( !wertExistiert( name->getText() ) )
    {
        this->name->add( new Text( name->getText() ) );
        this->wert->add( new Text( wert->getText() ) );
        name->release();
        wert->release();
        return 1;
    }
    name->release();
    wert->release();
    return 0;
}

bool InitDatei::addWert( const char *name, const char *wert )
{
    return addWert( new Text( name ), new Text( wert ) );
}

bool InitDatei::setWert( Text *name, Text *wert )
{
    if( !wertExistiert( name->getText() ) )
    {
        name->release();
        wert->release();
        return 0;
    }
    auto n = this->name->getIterator();
    for( auto v = this->wert->getIterator(); v; v++, n++ )
    {
        if( n->istGleich( name->getText() ) )
        {
            v->setText( wert->getText() );
            name->release();
            wert->release();
            return 1;
        }
    }
    name->release();
    wert->release();
    return 0;
}

bool InitDatei::setWert( const char *name, const char *wert )
{
    return setWert( new Text( name ), new Text( wert ) );
}

bool InitDatei::setWert( int num, Text *wert )
{
    bool result = setWert( num, wert->getText() );
    wert->release();
    return result;
}

bool InitDatei::setWert( int num, const char *wert )
{
    if( num >= name->getEintragAnzahl() )
        return 0;
    this->wert->z( num )->setText( wert );
    return 1;
}

bool InitDatei::removeWert( Text *name )
{
    bool result = removeWert( name->getText() );
    name->release();
    return result;
}

bool InitDatei::removeWert( const char *name )
{
    if( !wertExistiert( name ) )
        return 0;
    for( int i = 0; i < wert->getEintragAnzahl(); ++i )
    {
        if( this->name->z( i )->istGleich( name ) )
        {
            this->name->remove( i );
            this->wert->remove( i );
            return 1;
        }
    }
    return 0;
}

bool InitDatei::removeWert( int num )
{
    if( num >= wert->getEintragAnzahl() )
        return 0;
    this->name->remove( num );
    this->wert->remove( num );
    return 1;
}

void InitDatei::removeAlle()
{
    while( wert->getEintragAnzahl() > 0 )
    {
        this->name->remove( 0 );
        this->wert->remove( 0 );
    }
}

bool InitDatei::speichern()
{
    Datei *dat = new Datei();
    dat->setDatei( pfad->getText() );
    if( !dat->existiert() )
        dat->erstellen();
    if( !dat->open( Datei::Style::schreiben ) )
    {
        dat->release();
        return 0;
    }
    auto n = name->getIterator();
    for( auto v = wert->getIterator(); v; v++, n++ )
    {
        Text *zeile = new Text( "" );
        zeile->append( n->getText() );
        zeile->append( "=" );
        zeile->append( v->getText() );
        zeile->append( "\n" );
        dat->schreibe( zeile->getText(), zeile->getLength() );
        zeile->release();
    }
    dat->close();
    dat->release();
    return 1;
}

// constant
int InitDatei::getWertAnzahl() const
{
    return name->getEintragAnzahl();
}

bool InitDatei::wertExistiert( Text *name )
{
    bool result = wertExistiert( name->getText() );
    name->release();
    return result;
}

bool InitDatei::wertExistiert( const char *name )
{
    for( auto n = this->name->getIterator(); n; n++ )
    {
        if( n->istGleich( name ) )
            return 1;
    }
    return 0;
}

int InitDatei::getWertNummer( Text *name )
{
    int result = getWertNummer( name->getText() );
    name->release();
    return result;
}

int InitDatei::getWertNummer( const char *name )
{
    int i = 0;
    for( auto n = this->name->getIterator(); n; n++, i++ )
    {
        if( n->istGleich( name ) )
            return i;
    }
    return -1;
}

Text *InitDatei::getWert( Text *name )
{
    Text *result = getWert( name->getText() );
    name->release();
    return result;
}

Text *InitDatei::getWert( const char *name )
{
    auto v = wert->getIterator();
    for( auto n = this->name->getIterator(); n; n++, v++ )
    {
        if( n->istGleich( name ) )
            return dynamic_cast<Text*>(v->getThis());
    }
    return 0;
}

Text *InitDatei::getWert( int num )
{
    if( num >= name->getEintragAnzahl() )
        return 0;
    return wert->get( num );
}

Text *InitDatei::zWert( Text *name )
{
    Text *result = zWert( name->getText() );
    name->release();
    return result;
}

Text *InitDatei::zWert( const char *name )
{
    auto v = wert->getIterator();
    for( auto n = this->name->getIterator(); n; n++, v++ )
    {
        if( n->istGleich( name ) )
            return v;
    }
    return 0;
}

Text *InitDatei::zWert( int num )
{
    if( num >= wert->getEintragAnzahl() )
        return 0;
    return wert->z( num );
}

Text *InitDatei::getName( int num )
{
    if( num >= name->getEintragAnzahl() )
        return 0;
    return name->get( num );
}

Text *InitDatei::zName( int num )
{
    if( num >= name->getEintragAnzahl() )
        return 0;
    return name->z( num );
}

Text *InitDatei::getPfad() const
{
    return dynamic_cast<Text *>(pfad->getThis());
}

Text *InitDatei::zPfad() const
{
    return pfad;
}