// Copyright Thorsten Ottosen, 2009.
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/utility.hpp>
#include <boost/utility/auto_buffer.hpp>
#include <boost/utility/serialize_auto_buffer.hpp>
#include <libs/multi_index/test/non_std_allocator.hpp>
#include <boost/test/test_tools.hpp>
#include <fstream>
#include <string>

//
// serialization helper: we can't save a non-const object
// 
template< class T >
inline T const& as_const( T const& r )
{
    return r;
}

template< class Buffer >
void test_helper()
{
    const unsigned N     = 42;
    const unsigned BIG_N = 257;
    typedef typename Buffer::value_type T;
    typedef typename Buffer::size_type  Sz;
    typedef typename Buffer::reverse_iterator RevIter;
    typedef typename Buffer::const_reverse_iterator ConstRevIter;
    BOOST_CHECK_EQUAL( sizeof(Buffer), sizeof(T)*256 + sizeof(Sz)*3 );

    // data on stack
    Buffer buffer( N, T() );
    BOOST_CHECK_EQUAL( buffer.size(), N );
    BOOST_CHECK_EQUAL( buffer.capacity(), N );
    BOOST_CHECK_EQUAL( buffer[0], T() );
    BOOST_CHECK_EQUAL( buffer.empty(), false );
    BOOST_CHECK_EQUAL( buffer.full(), true );
    BOOST_CHECK_EQUAL( buffer.is_on_stack(), true );
    T* data  = buffer.data();
    T* begin = buffer.begin();
    T* end   = buffer.end();
    const T* cbegin = buffer.cbegin();
    const T* cend   = buffer.cend();
    RevIter rbegin  = buffer.rbegin();
    RevIter rend    = buffer.rend();
    ConstRevIter crbegin = buffer.crbegin();
    ConstRevIter crend   = buffer.crend();
    BOOST_CHECK_EQUAL( std::distance(crbegin,crend), 
                       std::distance(begin,end) );
    const T& front = buffer.front();
    const T& back  = buffer.back();
    BOOST_CHECK_EQUAL( front, back );

    // data on heap
    Buffer buffer2( BIG_N, T() );
    BOOST_CHECK_EQUAL( buffer2.size(), BIG_N );
    BOOST_CHECK_EQUAL( buffer2.capacity(), BIG_N );
    BOOST_CHECK_EQUAL( buffer2[0], T() );
        BOOST_CHECK_EQUAL( buffer2.empty(), false );
    BOOST_CHECK_EQUAL( buffer2.full(), true );
    BOOST_CHECK_EQUAL( buffer2.is_on_stack(), false );
    T* data2  = buffer2.data();
    T* begin2 = buffer2.begin();
    T* end2   = buffer2.end();
    const T* cbegin2 = buffer2.cbegin();
    const T* cend2   = buffer2.cend();
    RevIter rbegin2  = buffer2.rbegin();
    RevIter rend2    = buffer2.rend();
    ConstRevIter crbegin2 = buffer2.crbegin();
    ConstRevIter crend2   = buffer2.crend();
    BOOST_CHECK_EQUAL( std::distance(crbegin2,crend2), 
                       std::distance(begin2,end2) );
    const T& front2 = buffer.front();
    const T& back2  = buffer.back();
    BOOST_CHECK_EQUAL( front2, back2 );

    // initially empty
    Buffer buffer3( N );
    BOOST_CHECK_EQUAL( buffer3.capacity(), N );
    BOOST_CHECK_EQUAL( buffer3.full(), false );
    BOOST_CHECK_EQUAL( buffer3.empty(), true );
    buffer3.push_back( T() );
    BOOST_CHECK_EQUAL( buffer3.full(), false );
    BOOST_CHECK_EQUAL( buffer3.empty(), false );
    BOOST_CHECK_EQUAL( buffer3[0], T() );
    BOOST_CHECK_EQUAL( buffer3.size(), 1u );
    buffer3.pop_back_n(1u);
    BOOST_CHECK_EQUAL( buffer3.size(), 0u );
    BOOST_CHECK_EQUAL( buffer3.empty(), true );
    buffer3.uninitialized_resize( N );
    BOOST_CHECK_EQUAL( buffer3.full(), true );
    BOOST_CHECK_EQUAL( buffer3.empty(), false );
    buffer3.uninitialized_resize( 0u );
    BOOST_CHECK_EQUAL( buffer3.full(), false );
    BOOST_CHECK_EQUAL( buffer3.empty(), true );
    buffer3.push_back( buffer.begin(), buffer.end() );

    // iterator construction
    Buffer buffer4( buffer.begin(), buffer.end() );
    BOOST_CHECK_EQUAL( buffer4.capacity(), buffer.size() );
    BOOST_CHECK_EQUAL( buffer4.full(), true );
    BOOST_CHECK_EQUAL( buffer4.empty(), false );

    // serialization
    std::ofstream ofs("filename");
    boost::archive::text_oarchive oa(ofs);
    oa << boost::serialization::make_nvp( "container", as_const( buffer ) );
    oa << boost::serialization::make_nvp( "container", as_const( buffer2 ) );
    ofs.close();

    std::ifstream ifs("filename", std::ios::binary);
    boost::archive::text_iarchive  ia(ifs);
    Buffer buffer1b, buffer2b;
    ia >> boost::serialization::make_nvp( "container", buffer1b );
    ia >> boost::serialization::make_nvp( "container", buffer2b );
    ifs.close();
    BOOST_CHECK_EQUAL( buffer.size(), buffer1b.size() );
    BOOST_CHECK_EQUAL( buffer.capacity(), buffer1b.capacity() );
    BOOST_CHECK_EQUAL_COLLECTIONS( buffer.begin(), buffer.end(), 
                                   buffer1b.begin(), buffer1b.end() );
    BOOST_CHECK_EQUAL( buffer2.size(), buffer2b.size() );
    BOOST_CHECK_EQUAL( buffer2.capacity(), buffer2b.capacity() );
    BOOST_CHECK_EQUAL_COLLECTIONS( buffer2.begin(), buffer2.end(), 
                                   buffer2b.begin(), buffer2b.end() );

    std::ofstream ofs_xml("filename");
    boost::archive::xml_oarchive oa_xml(ofs);
    oa_xml << boost::serialization::make_nvp( "container", as_const( buffer ) );
    oa_xml << boost::serialization::make_nvp( "container", as_const( buffer2 ) );
    ofs_xml.close();

    buffer1b.clear_buffer();
    buffer2b.clear_buffer();
    std::ifstream ifs_xml("filename", std::ios::binary);
    boost::archive::xml_iarchive ia_xml(ifs);
    ia_xml >> boost::serialization::make_nvp( "container", buffer1b );
    ia_xml >> boost::serialization::make_nvp( "container", buffer2b );
    ifs_xml.close();         
    BOOST_CHECK_EQUAL( buffer.size(), buffer1b.size() );
    BOOST_CHECK_EQUAL( buffer.capacity(), buffer1b.capacity() );
    BOOST_CHECK_EQUAL_COLLECTIONS( buffer.begin(), buffer.end(), 
                                   buffer1b.begin(), buffer1b.end() );
    BOOST_CHECK_EQUAL( buffer2.size(), buffer2b.size() );
    BOOST_CHECK_EQUAL( buffer2.capacity(), buffer2b.capacity() );
    BOOST_CHECK_EQUAL_COLLECTIONS( buffer2.begin(), buffer2.end(), 
                                   buffer2b.begin(), buffer2b.end() );
                                   
}

int test_main(int, char *[])
{
    test_helper< boost::auto_buffer<char> >();
    test_helper< boost::auto_buffer<int> >();
    test_helper< boost::auto_buffer<std::string> >();
    test_helper< boost::auto_buffer<int,256, 
                 non_std_allocator<int> > >();
    test_helper< boost::auto_buffer<std::string,256,
                 non_std_allocator<std::string> > >();
    return 0;
}

unsigned int expected_failures = 0;