// vim: syntax=cpp
/*
 * Copyright (C) 2007-2014 Xagasoft, All rights reserved.
 *
 * This file is part of the libbu++ library and is released under the
 * terms of the license contained in the file LICENSE.
 */

#include "bu/string.h"
#include "bu/file.h"
#include "bu/myriad.h"
#include "bu/myriadstream.h"
#include "bu/array.h"

#include "bu/sio.h"
#include "bu/archive.h"
#include "bu/md5.h"
#include "bu/unitsuite.h"

#include <stdlib.h>

using namespace Bu;

class VerifyObject
{
friend Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const VerifyObject &vo );
friend Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, VerifyObject &vo );
public:
    VerifyObject( int iUnits ) :
        iUnits( iUnits ),
        iBytesWritten( 0 )
    {
    }

    virtual ~VerifyObject()
    {
    }

    int getBytesWritten()
    {
        return iBytesWritten;
    }

private:
    int iUnits;
    mutable int iBytesWritten;
};

Bu::ArchiveBase &operator<<( Bu::ArchiveBase &ar, const VerifyObject &vo )
{
    Md5 sum;
    ar << vo.iUnits;
    vo.iBytesWritten = 4;
    sum.addData( &vo.iUnits, 4 );
    for( int j = 0; j < vo.iUnits; j++ )
    {
        int iRand = random()%128;
//      ar << iRand;
        Bu::String sDat( iRand );
        for( int j = 0; j < iRand; j++ )
            sDat[j] = (char)((uint8_t)(random()%256));
        ar << sDat;
        sum.addData( &iRand, 4 );
        sum.addData( sDat.getStr(), iRand );
        vo.iBytesWritten += 4 + iRand;
    }
    Bu::String sRes = sum.getResult();
    ar << sRes;
    vo.iBytesWritten += 4 + sRes.getSize();
    return ar;
}

Bu::ArchiveBase &operator>>( Bu::ArchiveBase &ar, VerifyObject &vo )
{
    Md5 sum;
    ar >> vo.iUnits;
    sum.addData( &vo.iUnits, 4 );
    for( int j = 0; j < vo.iUnits; j++ )
    {
        int iRand;
//      ar >> iRand;
        Bu::String sStr;
        ar >> sStr;
        iRand = sStr.getSize();
        sum.addData( &iRand, 4 );
        sum.addData( sStr.getStr(), iRand );
    }
    Bu::String sSum;
    ar >> sSum;
    unitTest( sSum == sum.getResult() );
    int iTooMuch;
    try
    {
        ar >> iTooMuch;
        unitFailed("should have thrown an exception.");
    }
    catch( Bu::ExceptionBase &e )
    {
    }
    return ar;
}

suite Myriad
{
    test setSize
    {
        String sFileName("myriad-XXXXXXX");

        File fMyriad = tempFile( sFileName );
        Myriad m( fMyriad, 32 );

        MyriadStream ms = m.openStream( m.createStream() );
        ms.setSize( 150 );
        ms.setPos( 145 );
        char stuff[10];
        unitTest( ms.read( stuff, 10 ) == 5 );

        ms.setSize( 12 );
        unitTest( ms.read( stuff, 10 ) == 0 );
        unitTest( ms.write( "hello", 5 ) == 5 );
        unitTest( ms.tell() == 17 );

        ms.setSize( 500 );
        unitTest( ms.tell() == 17 );
    }

    void addBlock( Stream &s, bool bAppend=true )
    {
        if( bAppend )
            s.setPosEnd( 0 );
        int iSize = (random()%1016)+8;
        s.write( &iSize, 4 );
        char *buf = new char[iSize-8];
        for( int j = 0; j < iSize-8; j++ )
        {
            buf[j] = (j+iSize)%256;
        }
        if( random()%2 == 0 )
        {
            s.write( buf, iSize-8 );
        }
        else
        {
            for( int j = 0; j < iSize-8; )
            {
                int iAmnt = (random()%8)+1;
                if( iAmnt+j > iSize-8 )
                    iAmnt = iSize-8-j;
                iAmnt = s.write( buf+j, iAmnt );
                j += iAmnt;
            }
        }
        delete[] buf;
        iSize = ~iSize;
        s.write( &iSize, 4 );
    }

    void verifyBlock( Stream &s )
    {
        int iSize, iInv;
        if( s.read( &iSize, 4 ) == 0 )
            return;
        if( iSize < 8 || iSize > 1024 )
            throw ExceptionBase("Read bad data, %d", iSize );
        char *buf = new char[iSize-8];
        if( s.read( buf, iSize-8 ) < (size_t)iSize-8 )
        {
            delete[] buf;
            throw ExceptionBase("Block failed verify (insuffient block data).");
        }
        for( int j = 0; j < iSize-8; j++ )
        {
            if( buf[j] != (char)((j+iSize)%256) )
            {
                char b = buf[j];
                delete[] buf;
                throw ExceptionBase("Block failed computed data verify "
                    "(%02X==%02X).", b, (char)((j+iSize)%256) );
            }
        }
        delete[] buf;
        if( s.read( &iInv, 4 ) < 4 )
            throw ExceptionBase("Block failed verify (insufficient data).");
        if( iInv != ~iSize )
            throw ExceptionBase("Block failed inversion verify.");
    }
    
    void verifyStream( Stream &s )
    {
        s.setPos( 0 );
        while( !s.isEos() )
            verifyBlock( s );
    }

    test stressGrow
    {
        String sFileName("myriad-XXXXXXX");

        File fMyriad = tempFile( sFileName );
        Myriad m( fMyriad );
        m.initialize( 64 );

        Array<int> aStreams;
        for( int j = 0; j < 5; j++ )
        {
            aStreams.append( m.createStream() );
        }

        srandom( 512 );

        for( int j = 0; j < 2500; j++ )
        {
            switch( random()%5 )
            {
                case 0:
                    aStreams.append( m.createStream() );
                    break;

                case 1:
                    if( aStreams.getSize() > 0 )
                    {
                        int iStream = random()%aStreams.getSize();
                        {
                            MyriadStream ms = m.openStream( aStreams[iStream] );
                            verifyStream( ms );
                        }
                        m.deleteStream( aStreams[iStream] );
                        Array<int>::iterator i = aStreams.begin();
                        for( int k = 0; k < iStream; k++ )
                            i++;
                        aStreams.erase( i );
                    }
                    break;

                default:
                    if( aStreams.getSize() == 0 )
                    {
                        aStreams.append( m.createStream() );
                    }
                    {
                        int iStream = random()%aStreams.getSize();
                        MyriadStream ms = m.openStream( aStreams[iStream] );
                        addBlock( ms );
                        verifyStream( ms );
                    }
                    break;
            }
        }

        for( Array<int>::iterator i = aStreams.begin(); i; i++ )
        {
            MyriadStream ms = m.openStream( *i );
            verifyStream( ms );
        }
    }
    
    test stressTruncate
    {
        String sFileName("myriad-XXXXXXX");

        File fMyriad = tempFile( sFileName );
        Myriad m( fMyriad );
        m.initialize( 128 );

        Array<int> aStream;

        for( int j = 0; j < 5; j++ )
        {
            aStream.append( m.createStream() );
        }
        
        srandom( 1024 );

        char b;
        for( int iter = 0; iter < 2500; iter++ )
        {
            for( Array<int>::iterator i = aStream.begin(); i; i++ )
            {
                MyriadStream ms = m.openStream( *i );
                addBlock( ms, false );
                ms.setSize( ms.tell() );
                unitTest( ms.read( &b, 1 ) == 0 );
                ms.setPos( 0 );
                verifyBlock( ms );
                unitTest( ms.read( &b, 1 ) == 0 );
            }
        }
    }
    
    test stressTruncate2
    {
        String sFileName("myriad-XXXXXXX");

        Array<int> aStream;

        setStepCount( 5*2500 + 5 );

        {
            File fMyriad = tempFile( sFileName );
            Myriad m( fMyriad, 128 );

            for( int j = 0; j < 5; j++ )
            {
                aStream.append( m.createStream() );
                incProgress();
            }
        }
        
        srandom( 1024 );

        char b;
        for( int iter = 0; iter < 2500; iter++ )
        {
            File fMyriad( sFileName, File::ReadWrite );
            Myriad m( fMyriad );
            for( Array<int>::iterator i = aStream.begin(); i; i++ )
            {
                MyriadStream ms = m.openStream( *i );
                addBlock( ms, false );
                ms.setSize( ms.tell() );
                unitTest( ms.read( &b, 1 ) == 0 );
                ms.setPos( 0 );
                verifyBlock( ms );
                unitTest( ms.read( &b, 1 ) == 0 );
                incProgress();
            }
        }
    }

    test stressArchive
    {
        String sFileName("myriad-XXXXXX");
        Array<int> aStream;
        
        srandom( 2096 );

        setStepCount( 15*250 + 15 );
        
        {
            File fMyriad = tempFile( sFileName );
            Myriad m( fMyriad, 1024 );

            for( int j = 0; j < 15; j++ )
            {
                int iStream = m.createStream();
                aStream.append( iStream );
                VerifyObject vo( random()%1024 );
                {
                    MyriadStream ms = m.openStream( iStream );
                    Archive ar( ms, Archive::save );
                    ar << vo;
                    unitTest( ms.tell() == vo.getBytesWritten() );
                    ms.setSize( ms.tell() );
                }
                unitTest( m.getStreamSize( iStream ) == vo.getBytesWritten() );
                incProgress();
            }
        }

        for( int iter = 0; iter < 250; iter++ )
        {
            File fMyriad( sFileName, File::ReadWrite );
            Myriad m( fMyriad );
            for( Array<int>::iterator i = aStream.begin(); i; i++ )
            {
                VerifyObject vo( random()%1024 );
                {
                    MyriadStream ms = m.openStream( *i );
                    Archive ar( ms, Archive::load );
                    ar >> vo;
                }
                {
                    MyriadStream ms = m.openStream( *i );
                    Archive ar( ms, Archive::save );
                    ar << vo;
                    unitTest( ms.tell() == vo.getBytesWritten() );
                    ms.setSize( ms.tell() );
                }
                unitTest( m.getStreamSize( *i ) == vo.getBytesWritten() );
                incProgress();
            }
        }
    }
}