#include <bu/archive.h>
#include <bu/hash.h>
#include <bu/uuid.h>
#include <bu/myriad.h>
#include <bu/myriadstream.h>
#include <bu/file.h>
#include <bu/streamstack.h>

//
// New Cache Implementation
//

template<typename keytype, typename obtype> class CacheBase;

template<typename keytype, typename obtype>
class CacheObject
{
friend class CacheBase<keytype, obtype>;
public:
    CacheObject() :
        pCache( NULL ),
        bChanged( false )
    {
    }

    virtual ~CacheObject()
    {
    }

    typedef CacheBase<keytype, obtype> CacheType;

    virtual const keytype getKey() const=0;

    void changed( bool bChanged=true )
    {
        if( this->bChanged == false && bChanged == true )
            pCache->objectChanged( getKey() );

        this->bChanged = bChanged;
    }

private:
    void setCache( CacheType *pCache )
    {
        this->pCache = pCache;
    }

private:
    CacheType *pCache;
    bool bChanged;
};

template<typename keytype, typename obtype, typename basetype=obtype>
class CachePtr
{
friend class CacheBase<keytype, basetype>;
public:
    CachePtr()
    {
    }

    virtual ~CachePtr()
    {
    }
};

template<typename keytype, typename obtype>
class CacheBase
{
public:
    CacheBase()
    {
    }

    virtual ~CacheBase()
    {
    }

protected:
    virtual void _create( obtype *o )=0;
    virtual void _erase( const keytype &k )=0;

    virtual obtype *_load( const keytype &k )=0;
    virtual void _save( obtype *o )=0;
};

template<typename keytype, typename obtype>
class MyriadCache : public CacheBase<keytype, obtype>
{
public:
    MyriadCache( Bu::Stream &sStore, int iBlockSize=512, int iPreallocate=8 ) :
        sStore( sStore ),
        mStore( sStore, iBlockSize, iPreallocate )
    {
        try
        {
            Bu::MyriadStream ms = mStore.openStream( 1 );
            Bu::Archive ar( ms, Bu::Archive::load );
            ar >> hIndex;
        }
        catch(...)
        {
            if( mStore.createStreamWithId( 1 ) != 1 )
                throw Bu::ExceptionBase("Error creating index stream.");

            Bu::MyriadStream ms = mStore.openStream( 1 );
            Bu::Archive ar( ms, Bu::Archive::save );
            ar << hIndex;
        }
    }

    virtual ~MyriadCache()
    {
    }

protected:
    virtual void _create( obtype *o )
    {
        hIndex.insert( o->getKey(), mStore.createStream() );
        _save( o );
    }

    virtual void _erase( const keytype &k )
    {
        mStore.deleteStream( hIndex.get( k ) );
        hIndex.erase( k );
    }

    virtual obtype *_load( const keytype &k )
    {
        Bu::MyriadStream ms = mStore.openStream( hIndex.get( k ) );
        Bu::Archive ar( ms, Bu::Archive::load );
        obtype *ret = new obtype();
        ar >> *ret;
        return ret;
    }

    virtual void _save( obtype *o )
    {
        Bu::MyriadStream ms = mStore.openStream( hIndex.get( o->getKey() ) );
        {
            Bu::Archive ar( ms, Bu::Archive::save );
            ar << *o;
        }
        ms.setSize( ms.tell() );
    }

private:
    Bu::Stream &sStore;
    Bu::Myriad mStore;
    Bu::Hash<keytype, int> hIndex;
};

//
// Test
//

class Something : public CacheObject<Bu::Uuid, Something>
{
friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Something &s );
friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Something &s );
public:
    Something()
    {
    }
    
    Something( const Bu::String &sName ) :
        uId( Bu::Uuid::generate() ),
        sName( sName )
    {
    }

    virtual ~Something()
    {
    }

    virtual const Bu::Uuid getKey() const
    {
        return uId;
    }

private:
    Bu::Uuid uId;
    Bu::String sName;
};

Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, Something &s )
{
    return ar >> s.uId >> s.sName;
}

Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const Something &s )
{
    return ar << s.uId << s.sName;
}

int main()
{
    Bu::File fStore("test.myr", Bu::File::Create|Bu::File::ReadWrite);
    MyriadCache<Bu::Uuid, Something> c( fStore );

    return 0;
}