#ifdef _WIN32
    #include "windows.h"
#endif // _WIN32

#define BOOST_EXCEPTION_DISABLE
#define BOOST_MPL_LIMIT_VECTOR_SIZE 40

#include "boost/gil/extension/io2/libjpeg_image.hpp"
#include "boost/gil/extension/io2/libtiff_image.hpp"
#include "boost/timer.hpp"

#include <cstdio>

void convert_int_to_hex( unsigned int integer, char * p_char_buffer );

extern "C" int main( int /*argc*/, char * /*argv*/[] )
{
#ifdef _WIN32
    ::SetPriorityClass( ::GetCurrentProcess(), REALTIME_PRIORITY_CLASS );
#elif defined( __APPLE__ )
	BOOST_VERIFY( ::setpriority( PRIO_PROCESS, 0, -20 ) );
#endif // _WIN32

    try
    {
        using namespace boost;
        using namespace boost::gil;

        typedef image<rgb8_pixel_t, false> tile_holder_t;

        typedef libtiff_image::reader_for<char const *>::type reader_t;
        reader_t reader( "test_images/TrueMarble.250m.21600x21600.E2.tif" );

        BOOST_ASSERT( reader.can_do_tile_access() );

        BOOST_ASSERT( reader.format() == reader_t:: BOOST_NESTED_TEMPLATE get_native_format<tile_holder_t>::value );
    
        point2<std::ptrdiff_t> const output_tile_dimensions( reader.tile_dimensions() );
        tile_holder_t output_tile_holder( output_tile_dimensions.x, output_tile_dimensions.y );
        typedef libjpeg_image::writer_for<char const *>::type writer_t;

        char output_file_name[] = "test_images/tiles/__out_tile__00000000.jpg";
        char * const p_back_of_file_name_number( boost::end( output_file_name ) - ( boost::size( ".jpg" ) + 1 ) );

        point2<std::ptrdiff_t> const input_dimensions( reader.dimensions() );

        reader_t::sequential_tile_access_state state( reader.begin_sequential_tile_access() );

        boost::timer benchmark_timer;

        unsigned int output_tile_counter( 0 );
        for ( unsigned int x( 0 ); x < static_cast<unsigned>( input_dimensions.x ); x += output_tile_dimensions.x )
        {
            for ( unsigned int y( 0 ); y < static_cast<unsigned>( input_dimensions.y ); y += output_tile_dimensions.y )
            {
                reader.read_tile( state, interleaved_view_get_raw_data( view( output_tile_holder ) ) );
                BOOST_ASSERT( !state.failed() );

                convert_int_to_hex( output_tile_counter++, p_back_of_file_name_number );
                libjpeg_image::write( output_file_name, view( output_tile_holder ) );
            }
        }

        std::printf( "%u ms\n", static_cast<unsigned int>( benchmark_timer.elapsed() * 1000 ) );

        BOOST_ASSERT( !state.failed() );
        state.throw_if_error();

        return EXIT_SUCCESS;
    }
    catch ( std::exception const & e )
    {
        std::puts( e.what() );
        return EXIT_FAILURE;
    }
}


void convert_int_to_hex( unsigned int const integer, char * p_char_buffer )
{
    static char const hexDigits[] = "0123456789ABCDEF";
    unsigned char const *       p_current_byte( reinterpret_cast<unsigned char const *>( &integer ) );
    unsigned char const * const p_end         ( p_current_byte + sizeof( integer )                  );
    while ( p_current_byte != p_end )
    {
        *p_char_buffer-- = hexDigits[ ( ( *p_current_byte ) & 0x0F )      ];
        *p_char_buffer-- = hexDigits[ ( ( *p_current_byte ) & 0xF0 ) >> 4 ];
        ++p_current_byte;
    }
}