/*
 *   Licensed to the Apache Software Foundation (ASF) under one
 *   or more contributor license agreements.  See the NOTICE file
 *   distributed with this work for additional information
 *   regarding copyright ownership.  The ASF licenses this file
 *   to you under the Apache License, Version 2.0 (the
 *   "License"); you may not use this file except in compliance
 *   with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing,
 *   software distributed under the License is distributed on an
 *   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *   KIND, either express or implied.  See the License for the
 *   specific language governing permissions and limitations
 *   under the License.
 *
 */
package org.apache.directory.mavibot.btree;


import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.nio.BufferUnderflowException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.directory.mavibot.btree.exception.EndOfFileExceededException;
import org.apache.directory.mavibot.btree.exception.InvalidBTreeException;
import org.apache.directory.mavibot.btree.serializer.ElementSerializer;
import org.apache.directory.mavibot.btree.serializer.LongArraySerializer;
import org.apache.directory.mavibot.btree.serializer.LongSerializer;
import org.apache.directory.mavibot.btree.util.Strings;


/**
 * A class to examine a Mavibot database file.
 *
 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
 */
public class MavibotInspector
{
    // The file to be read
    private File dbFile;

    // The recordManager
    private static RecordManager rm;

    private BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) );

    // The name of the two page arrays for the global file and teh free pages
    private static final String GLOBAL_PAGES_NAME = "__global__";
    private static final String FREE_PAGES_NAME = "__free-pages__";

    // The set of page array we already know about
    private static Set<String> knownPagesArrays = new HashSet<String>();

    // Create an array of pages to be checked for each B-tree, plus
    // two others for the free pages and the global one
    // We use one bit per page. It's 0 when the page
    // hasn't been checked, 1 otherwise.
    private static Map<String, int[]> checkedPages = new HashMap<String, int[]>();

    static
    {
        knownPagesArrays.add( GLOBAL_PAGES_NAME );
        knownPagesArrays.add( FREE_PAGES_NAME );
        knownPagesArrays.add( BTreeConstants.BTREE_OF_BTREES_NAME );
        knownPagesArrays.add( BTreeConstants.COPIED_PAGE_BTREE_NAME );
    }


    /**
     * A private class to store a few informations about a btree
     *
    
    private static BtreeInfo btreeInfo;
    
    static
    {
        btreeInfo = new BtreeInfo();
    }

    /**
     * Create an instance of MavibotInspector
     * @param dbFile The file to read
     */
    public MavibotInspector( File dbFile )
    {
        this.dbFile = dbFile;
    }


    /**
     * Check that the file exists
     */
    private boolean checkFilePresence()
    {
        if ( dbFile == null )
        {
            System.out.println( "No mavibot database file was given" );
            return false;
        }

        if ( !dbFile.exists() )
        {
            System.out.println( "Given mavibot database file " + dbFile + " doesn't exist" );
            return false;
        }

        return true;
    }


    /**
     * Pretty print the file size
     */
    public void printFileSize() throws IOException
    {
        FileChannel fileChannel = new RandomAccessFile( dbFile, "r" ).getChannel();

        long l = fileChannel.size();

        fileChannel.close();

        String msg;

        if ( l < 1024 )
        {
            msg = l + " bytes";
        }
        else
        {
            msg = ( l / 1024 ) + " KB";
        }

        System.out.println( msg );

        fileChannel.close();
    }


    /**
     * Print the number of B-trees
     */
    public void printNumberOfBTrees( RecordManagerHeader recordManagerHeader )
    {
        int nbBtrees = 0;

        if ( rm != null )
        {
            nbBtrees = rm.getNbManagedTrees( recordManagerHeader );
        }

        // The number of trees. It must be at least 2 and > 0
        System.out.println( "Total Number of BTrees: " + nbBtrees );
    }


    /**
     * Print the B-tree's name
     */
    public void printBTreeNames()
    {
        if ( rm == null )
        {
            System.out.println( "Couldn't find the number of managed btrees" );
            return;
        }

        Set<String> trees = rm.getManagedTrees();
        System.out.println( "\nManaged BTrees:" );

        for ( String tree : trees )
        {
            System.out.println( tree );
        }

        System.out.println();
    }


    /**
     * Check a B-tree
     */
    public void inspectBTree( RecordManager recordManager ) throws IOException
    {
        if ( recordManager == null )
        {
            System.out.println( "Cannot check BTree(s)" );
            return;
        }

        System.out.print( "BTree Name: " );
        String name = readLine();
        
        Transaction transaction = null;

        try
        {
            transaction = rm.beginReadTransaction();
            BTree<?, ?> pb = ( BTree<?, ?> ) rm.getBtree( transaction, name, Long.MAX_VALUE - 1 );
    
            if ( pb == null )
            {
                System.out.println( "No BTree exists with the name '" + name + "'" );
                return;
            }
    
            System.out.println( "\nBTree offset: " + String.format( "0x%1$08x", pb.getBtreeOffset() ) );
            System.out.println( "BTree _info_ offset: " + String.format( "0x%1$08x", pb.getBtreeInfoOffset() ) );
            System.out.println( "BTree root page offset: " + String.format( "0x%1$08x", pb.getRootPageOffset() ) );
            System.out.println( "Number of elements present: " + pb.getNbElems() );
            System.out.println( "BTree Page size: " + pb.getNbElems() );
            System.out.println( "BTree revision: " + pb.getBtreeHeader().getRevision() );
            System.out.println( "Key serializer: " + pb.getKeySerializerFQCN() );
            System.out.println( "Value serializer: " + pb.getValueSerializerFQCN() );
            System.out.println();
            
            transaction.commit();
        }
        catch ( IOException ioe )
        {
            if ( transaction != null )
            {
                transaction.abort();
            }
        }
    }


    /**
     * Load the full fie into a new RecordManager
     */
    private boolean loadRm()
    {
        try
        {
            if ( rm != null )
            {
                System.out.println( "Closing record manager" );
                rm.close();
            }

            rm = new RecordManager( dbFile.getAbsolutePath() );
            System.out.println( "Loaded record manager" );
        }
        catch ( Exception e )
        {
            System.out.println( "Given database file seems to be corrupted. " + e.getMessage() );
            return false;
        }

        return true;
    }


    /**
     * Check the whole file.
     */
    /* no qualifier */static void check( RecordManager recordManager )
    {
        RecordManagerHeader recordManagerHeader = recordManager.getCurrentRecordManagerHeader();
        
        try
        {
            // Dump the infos
            dumpInfos( recordManager, recordManagerHeader );
            
            rm = recordManager;

            // First check the RMheader
            ByteBuffer recordManagerHeaderBuffer = ByteBuffer.allocate( RecordManager.recordManagerHeaderSize );
            
            long fileSize = recordManager.fileChannel.size();

            if ( fileSize < RecordManager.recordManagerHeaderSize )
            {
                throw new InvalidBTreeException( "File size too small : " + fileSize );
            }

            // Read the RMHeader
            recordManager.fileChannel.read( recordManagerHeaderBuffer, 0L );
            recordManagerHeaderBuffer.flip();

            // The page size. It must be a power of 2, and above 16.
            int pageSize = recordManagerHeaderBuffer.getInt();

            if ( ( pageSize != recordManager.getPageSize( recordManagerHeader ) ) || ( pageSize < 32 )
                || ( ( pageSize & ( ~pageSize + 1 ) ) != pageSize ) )
            {
                throw new InvalidBTreeException( "Wrong page size : " + pageSize );
            }

            // Compute the number of pages in this file
            long nbPages = ( fileSize - RecordManager.recordManagerHeaderSize ) / pageSize;

            // The number of trees. It must be at least >= 2
            int nbBtrees = recordManagerHeaderBuffer.getInt();

            if ( ( nbBtrees < 0 ) || ( nbBtrees != recordManager.getNbManagedTrees( recordManagerHeader ) ) )
            {
                throw new InvalidBTreeException( "Wrong nb trees : " + nbBtrees );
            }
            
            // The current revision
            long revision = recordManagerHeaderBuffer.getLong();
            
            if ( revision != recordManagerHeader.getRevision() )
            {
                throw new InvalidBTreeException( "Wrong revision number : " + revision );
            }

            // The first free page offset. It must be either -1 or below file size
            // and its value must be a modulo of pageSize
            long firstFreePage = recordManagerHeaderBuffer.getLong();

            if ( firstFreePage != BTreeConstants.NO_PAGE )
            {
                checkOffset( recordManager, recordManagerHeader, firstFreePage );
            }

            int nbPageBits = ( int ) ( nbPages / 32 );

            // The global page array
            checkedPages.put( GLOBAL_PAGES_NAME, new int[nbPageBits + 1] );

            // The freePages array
            checkedPages.put( FREE_PAGES_NAME, new int[nbPageBits + 1] );

            // The B-tree of B-trees array
            checkedPages.put( BTreeConstants.BTREE_OF_BTREES_NAME, new int[nbPageBits + 1] );

            // Last, the Copied Pages B-tree array
            checkedPages.put( BTreeConstants.COPIED_PAGE_BTREE_NAME, new int[nbPageBits + 1] );

            // Check the free files
            checkFreePages( recordManager, recordManagerHeader, checkedPages );

            // The B-trees offsets
            long currentBtreeOfBtreesOffset = recordManagerHeaderBuffer.getLong();
            long currentCopiedPagesBtreeOffset = recordManagerHeaderBuffer.getLong();

            // Check that the current LOB offset is valid
            checkOffset( recordManager, recordManagerHeader, currentBtreeOfBtreesOffset );

            // Check that the current CPB offset is valid
            checkOffset( recordManager, recordManagerHeader, currentCopiedPagesBtreeOffset );

            // Now, check the BTree of Btrees
            checkListOfBtrees( recordManager, recordManagerHeader, checkedPages );

            // And the Copied Pages BTree
            checkBtree( recordManager, recordManagerHeader, currentCopiedPagesBtreeOffset, checkedPages );

            // We can now dump the checked pages
            //dumpCheckedPages( recordManager, recordManagerHeader, checkedPages );
        }
        catch ( Exception e )
        {
            // We catch the exception and rethrow it immediately to be able to
            // put a breakpoint here
            e.printStackTrace();
            throw new InvalidBTreeException( "Error : " + e.getMessage() );
        }
    }
    
    
    /**
     * Dump the Mavibot file infos :
     * <ul>
     *   <li>The recordManager header</li>
     *   <li><The copiedPages B-tree/li>
     *   <li>The B-tree of B-trees</li>
     * </ul>
     * @param recordManager The recordMnaager instance
     * @param recordManagerHeader The current RecordManagerHeader 
     * @throws Exception
     */
    public static void dumpInfos( RecordManager recordManager, RecordManagerHeader recordManagerHeader ) throws Exception
    {
        StringBuilder sb = new StringBuilder();
        long nbPages = recordManagerHeader.lastOffset/recordManagerHeader.pageSize;
        String[] pages = new String[(int)nbPages];
        
        // RMH
        sb.append( String.format( "0x%04X", 0L ) ).append( " RMH : " );
        sb.append( "<LOB h[" ).append( recordManagerHeader.getRevision() ).append( "] : " ).append( String.format( "0x%04X",recordManagerHeader.currentListOfBtreesOffset ) );
        sb.append( ">, " );
        sb.append( "<CPB h[" ).append( recordManagerHeader.getRevision() ).append( "] : " ).append( String.format( "0x%04X",recordManagerHeader.currentCopiedPagesBtreeOffset ) );
        sb.append( '>' );
        
        pages[0] = sb.toString();
        
        // The CPB
        dumpCopiedPagesBtree( recordManager, recordManagerHeader, pages );

        // The LOB
        dumpListOfBtrees( recordManager, recordManagerHeader, pages );

        boolean previousEmpty = false;
        
        for ( String page : pages )
        {
            if ( page == null ) 
            {
                if ( !previousEmpty )
                {
                    previousEmpty = true;
                    System.out.println();
                }
                
                System.out.print( "." );
            }
            else
            {
                System.out.println();
                System.out.print( page );
                previousEmpty = false;
            }
        }
        
        System.out.println();
    }


    /**
     * Check the List of Btrees
     */
    private static void checkListOfBtrees( RecordManager recordManager, RecordManagerHeader recordManagerHeader, Map<String, int[]> checkedPages )
        throws Exception
    {
            
        // Read the LOB header
        PageIO[] bobHeaderPageIos = recordManager
            .readPageIOs( recordManagerHeader.pageSize, recordManagerHeader.currentListOfBtreesOffset, Long.MAX_VALUE );

        // update the checkedPages
        updateCheckedPages( recordManagerHeader, checkedPages.get( BTreeConstants.BTREE_OF_BTREES_NAME ), recordManager.getPageSize( recordManagerHeader ),
            bobHeaderPageIos );
        updateCheckedPages( recordManagerHeader, checkedPages.get( GLOBAL_PAGES_NAME ), recordManager.getPageSize( recordManagerHeader ), bobHeaderPageIos );

        long dataPos = 0L;
        
        // The B-tree header page ID
        recordManager.readLong( recordManagerHeader.pageSize, bobHeaderPageIos, dataPos );
        dataPos += BTreeConstants.LONG_SIZE;

        // The number of transactions
        int nbTransactions = recordManager.readInt( recordManagerHeader.pageSize, bobHeaderPageIos, dataPos );
        dataPos += BTreeConstants.INT_SIZE;

        // The current RMH
        // The number of managed B-trees
        int nbBtrees = recordManager.readInt( recordManagerHeader.pageSize, bobHeaderPageIos, dataPos );
        dataPos += BTreeConstants.INT_SIZE;

        // The current revision
        recordManager.readLong( recordManagerHeader.pageSize, bobHeaderPageIos, dataPos );
        dataPos += BTreeConstants.LONG_SIZE;

        for ( int i = 0; i < nbBtrees; i++ )
        {
            // The b-tree offset
            long offset = recordManager.readLong( recordManagerHeader.pageSize, bobHeaderPageIos, dataPos );
            dataPos += BTreeConstants.LONG_SIZE;

            checkOffset( recordManager, recordManagerHeader, offset );
            checkBtree( recordManager, recordManagerHeader, offset, checkedPages );
        }
        
        // The pending transactions
        
        for ( int i = 0; i < nbTransactions; i++ )
        {
            // The number of managed B-trees
            nbBtrees = recordManager.readInt( recordManagerHeader.pageSize, bobHeaderPageIos, dataPos );
            dataPos += BTreeConstants.INT_SIZE;

            // The current revision
            recordManager.readLong( recordManagerHeader.pageSize, bobHeaderPageIos, dataPos );
            dataPos += BTreeConstants.LONG_SIZE;

            for ( int j = 0; j < nbBtrees; j++ )
            {
                // The b-tree offset
                long offset = recordManager.readLong( recordManagerHeader.pageSize, bobHeaderPageIos, dataPos );
                dataPos += BTreeConstants.LONG_SIZE;

                checkOffset( recordManager, recordManagerHeader, offset );
                checkBtree( recordManager, recordManagerHeader, offset, checkedPages );
            }
        }

        // Check the elements in the btree itself
        // We will read every single page
        //checkBtreeOfBtreesPage( recordManager, recordManagerHeader, checkedPages, rootPageOffset );
    }


    /**
     * Dump the List of Btrees
     */
    private static void dumpListOfBtrees( RecordManager recordManager, RecordManagerHeader recordManagerHeader, String[] pages ) throws Exception
    {
        StringBuilder sb = new StringBuilder();
        
        // Read the LOB header
        PageIO[] bobHeaderPageIos = recordManager
            .readPageIOs( recordManagerHeader.pageSize, recordManagerHeader.currentListOfBtreesOffset, Long.MAX_VALUE );

        // Get the offset
        long bobHeaderOffset = bobHeaderPageIos[0].getOffset();

        long dataPos = 0L;
        
        // The B-tree header page ID
        long pageId = recordManager.readLong( recordManagerHeader.pageSize, bobHeaderPageIos, dataPos );
        dataPos += BTreeConstants.LONG_SIZE;

        // The number of transactions
        int nbTransactions = recordManager.readInt( recordManagerHeader.pageSize, bobHeaderPageIos, dataPos );
        dataPos += BTreeConstants.INT_SIZE;

        // The current RMH
        // The number of B-trees
        int nbBtrees = recordManager.readInt( recordManagerHeader.pageSize, bobHeaderPageIos, dataPos );
        dataPos += BTreeConstants.INT_SIZE;

        // The revision
        long revision = recordManager.readLong( recordManagerHeader.pageSize, bobHeaderPageIos, dataPos );
        dataPos += BTreeConstants.LONG_SIZE;

        // Dump the header
        sb.append( String.format( "0x%04X", bobHeaderOffset ) ).append( " LOB H[" ).append( revision ).append( "] : " );

        for ( int i = 0; i < nbBtrees; i++ )
        { 
            // The B-tree offset
            long offset = recordManager.readLong( recordManagerHeader.pageSize, bobHeaderPageIos, dataPos );
            dataPos += BTreeConstants.LONG_SIZE;

            sb.append( "<BH[" ).append( revision ).append( "] : " ).append( String.format( "0x%04X", offset ) ).append( ">, " );
            
            dumpUserBtree( recordManager, recordManagerHeader, "aaa", offset, pages );
        }
        
        sb.append( '\n' );
        nbTransactions --;

        // The pending transactions
        for ( int i = 0; i < nbTransactions; i++ )
        {
            // The current RMH
            // The number of B-trees
            nbBtrees = recordManager.readInt( recordManagerHeader.pageSize, bobHeaderPageIos, dataPos );
            dataPos += BTreeConstants.INT_SIZE;

            revision = recordManager.readLong( recordManagerHeader.pageSize, bobHeaderPageIos, dataPos );
            dataPos += BTreeConstants.LONG_SIZE;
            
            sb.append( String.format( "0x%04X", bobHeaderOffset ) ).append( " LOB H[" ).append( revision ).append( "] : " );

            for ( int j = 0; j < nbBtrees; j++ )
            { 
                // The B-tree offset
                long offset = recordManager.readLong( recordManagerHeader.pageSize, bobHeaderPageIos, dataPos );
                dataPos += BTreeConstants.LONG_SIZE;

                sb.append( "<BH[" ).append( revision ).append( "] : " ).append( String.format( "0x%04X", offset ) ).append( ">, " );
            }

            sb.append( '\n' );
        }
        
        System.out.println( sb.toString() );
    }


    /**
     * Dump the Copied Pages B-tree
     */
    private static void dumpCopiedPagesBtree( RecordManager recordManager, RecordManagerHeader recordManagerHeader, String[] pages ) throws EndOfFileExceededException, IOException
    {
        StringBuilder sb = new StringBuilder();
        
        // Read the CPB header
        PageIO[] cpbbHeaderPageIos = recordManager
            .readPageIOs( recordManagerHeader.pageSize, recordManagerHeader.currentCopiedPagesBtreeOffset, Long.MAX_VALUE );

        // Get the offset
        long cpbHeaderOffset = cpbbHeaderPageIos[0].getOffset();

        long dataPos = 0L;

        // The B-tree page ID
        long id = recordManager.readLong( recordManagerHeader.pageSize, cpbbHeaderPageIos, dataPos );
        dataPos += BTreeConstants.LONG_SIZE;

        // The B-tree current revision
        long revision = recordManager.readLong( recordManagerHeader.pageSize, cpbbHeaderPageIos, dataPos );
        dataPos += BTreeConstants.LONG_SIZE;

        // The nb elems in the tree
        recordManager.readLong( recordManagerHeader.pageSize, cpbbHeaderPageIos, dataPos );
        dataPos += BTreeConstants.LONG_SIZE;

        // The B-tree rootPage offset
        long rootPageOffset = recordManager.readLong( recordManagerHeader.pageSize, cpbbHeaderPageIos, dataPos );

        dataPos += BTreeConstants.LONG_SIZE;

        // The B-tree info offset
        long infoOffset = recordManager.readLong( recordManagerHeader.pageSize, cpbbHeaderPageIos, dataPos );
        
        // Dump the header
        sb.append( String.format( "0x%04X", cpbHeaderOffset ) ).append( " CPB H[" ).append( revision ).append( "] : " );
        sb.append( "<RP[" ).append( revision ).append( "] : " ).append( String.format( "0x%04X", rootPageOffset ) ).append( ">, " );
        sb.append( "<Info:" ).append( String.format( "0x%04X", infoOffset ) ).append( '>' );
        pages[(int)cpbHeaderOffset/recordManagerHeader.pageSize] = sb.toString();
        
        // Dump the info
        dumpBtreeInfo( recordManager, recordManagerHeader, infoOffset, "CPB", pages );
        
        // Dump the CPB content
        dumpCopiedPagesBtreeContent( recordManager, recordManagerHeader, rootPageOffset, RevisionNameSerializer.INSTANCE, LongArraySerializer.INSTANCE, pages );
    }
    
    
    /**
     * Dump a BTree info
     */
    private static <K, V> BTreeInfo<K, V> dumpBtreeInfo( RecordManager recordManager, RecordManagerHeader recordManagerHeader, long offset, String btreeName, String[] pages ) 
        throws EndOfFileExceededException, IOException
    {
        PageIO[] infoPageIos = recordManager .readPageIOs( recordManagerHeader.pageSize, offset, Long.MAX_VALUE );
        StringBuilder sb = new StringBuilder();
        sb.append( String.format( "0x%04X", offset ) ).append( ' ' ).append( btreeName ).append( " Info" );
        BTreeInfo<K, V> btreeInfo = new BTreeInfo<>();
        
        // The info page may contain more than one PageIO
        int nbPage = 0;
        
        for ( PageIO pageIO : infoPageIos )
        {
            if ( nbPage > 0 )
            {
                sb.append( '-' ).append( nbPage );
            }
            
            nbPage++;
            
            int pos = (int)(pageIO.getOffset()/recordManagerHeader.pageSize);
            
            if ( ( pages[pos] != null ) && pages[pos].contains( "---copied page at" ) )
            {
                pages[pos] = new StringBuilder().append( pages[pos] ).append( ' ' ).append( sb.toString() ).toString();
            }
            else
            {
                pages[pos] = sb.toString();
            }
        }
        
        // The B-tree page size
        int dataPos = 0;
        btreeInfo.setPageNbElem( recordManager.readInt( recordManagerHeader.pageSize, infoPageIos, dataPos ) );
        dataPos += BTreeConstants.INT_SIZE;

        // The tree name
        ByteBuffer btreeNameBytes = recordManager.readBytes( recordManagerHeader.pageSize, infoPageIos, dataPos );
        dataPos += BTreeConstants.INT_SIZE + btreeNameBytes.limit();
        btreeInfo.setName( Strings.utf8ToString( btreeNameBytes ) );

        // The keySerializer FQCN
        ByteBuffer keySerializerBytes = recordManager.readBytes( recordManagerHeader.pageSize, infoPageIos, dataPos );

        if ( keySerializerBytes != null )
        {
            String keySerializerFqcn = Strings.utf8ToString( keySerializerBytes );
            btreeInfo.setKeySerializerFQCN( keySerializerFqcn );

            btreeInfo.setKeySerializer( ( ( ElementSerializer<K> ) getSerializer( keySerializerFqcn ) ) );
        }

        dataPos += BTreeConstants.INT_SIZE + keySerializerBytes.limit();

        // The valueSerialier FQCN
        ByteBuffer valueSerializerBytes = recordManager.readBytes( recordManagerHeader.pageSize, infoPageIos, dataPos );

        if ( valueSerializerBytes != null )
        {
            String valueSerializerFqcn = Strings.utf8ToString( valueSerializerBytes );
            btreeInfo.setValueSerializerFQCN( valueSerializerFqcn );

            btreeInfo.setValueSerializer( ( ( ElementSerializer<V> ) getSerializer( valueSerializerFqcn ) ) );
        }

        return btreeInfo;
    }

    
    /**
     * Dump a CPB content
     */
    private static void dumpCopiedPagesBtreeContent( RecordManager recordManager, RecordManagerHeader recordManagerHeader, long rootPageOffset, RevisionNameSerializer keySerializer, 
        LongArraySerializer valueSerializer, String[] pages ) throws IOException
    {
        // Process the rootPage
        PageIO[] pageIos = recordManager.readPageIOs( recordManagerHeader.pageSize, rootPageOffset, Long.MAX_VALUE );

        // Deserialize the page now
        long position = 0L;

        // The page ID
        long id = recordManager.readLong( recordManagerHeader.pageSize, pageIos, position );
        position += BTreeConstants.LONG_SIZE;

        // The revision
        long revision = recordManager.readLong( recordManagerHeader.pageSize, pageIos, position );
        position += BTreeConstants.LONG_SIZE;

        // The number of elements in the page
        int nbElems = recordManager.readInt( recordManagerHeader.pageSize, pageIos, position );
        position += BTreeConstants.INT_SIZE;
        
        if ( nbElems == 0 )
        {
            // No elems, we are done
            StringBuilder sb = new StringBuilder();
            
            sb.append( String.format( "0x%04X", rootPageOffset ) ).append( " CPB RP[" ).append( revision ).append( "] : {}" );
            pages[(int)(rootPageOffset/recordManagerHeader.pageSize)] = sb.toString();
            
            return;
        }

        // The size of the data containing the keys and values
        // Reads the bytes containing all the keys and values, if we have some
        // We read  big blob of data into  ByteBuffer, then we will process
        // this ByteBuffer
        ByteBuffer byteBuffer = recordManager.readBytes( recordManagerHeader.pageSize, pageIos, position );

        // Now, deserialize the data block. If the number of elements
        // is positive, it's a Leaf, otherwise it's a Node
        // Note that only a leaf can have 0 elements, and it's the root page then.
        if ( nbElems > 0 )
        {
            // It's a leaf, process it as we may have sub-btrees
            dumpCopiedPagesBtreeLeaf( recordManager, recordManagerHeader, keySerializer, valueSerializer, nbElems, revision, byteBuffer, pageIos[0].getOffset(), pages );
            
            // Update the attached PageIOS
            if ( pageIos.length > 0 )
            {
                for ( int i = 1; i < pageIos.length; i++ )
                {
                    PageIO pageIo = pageIos[i];
                    StringBuilder sb = new StringBuilder();
                    
                    sb.append( String.format( "0x%04X", pageIo.getOffset() ) ).append( " CPB RP[" ).append( revision ).append( "]-" ).append( i );
                    pages[(int)(pageIo.getOffset()/recordManagerHeader.pageSize)] = sb.toString();
                }
            }
        }
        else
        {
            // It's a node, dump its content, and iterate on the children
            dumpCopiedPagesBtreeNode( recordManager, recordManagerHeader, keySerializer, valueSerializer, -nbElems, revision, byteBuffer, pageIos[0].getOffset(), pages );
            
            // Update the attached PageIOS
            if ( pageIos.length > 0 )
            {
                for ( int i = 1; i < pageIos.length; i++ )
                {
                    PageIO pageIo = pageIos[i];
                    StringBuilder sb = new StringBuilder();
                    
                    sb.append( String.format( "0x%04X", pageIo.getOffset() ) ).append( " CPB RP[" ).append( revision ).append( "]-" ).append( i );
                    pages[(int)(pageIo.getOffset()/recordManagerHeader.pageSize)] = sb.toString();
                }
            }
        }
    }

    
    /**
     * Dump a LOB content
     */
    private static void dumpBtreeOfBtreesContent( RecordManager recordManager, RecordManagerHeader recordManagerHeader, long rootPageOffset, NameRevisionSerializer keySerializer, 
        LongSerializer valueSerializer, String[] pages ) throws IOException
    {
        // Process the rootPage
        PageIO[] pageIos = recordManager.readPageIOs( recordManagerHeader.pageSize, rootPageOffset, Long.MAX_VALUE );

        // Deserialize the page now
        long position = 0L;

        // The page ID
        long id = recordManager.readLong( recordManagerHeader.pageSize, pageIos, position );
        position += BTreeConstants.LONG_SIZE;

        // The revision
        long revision = recordManager.readLong( recordManagerHeader.pageSize, pageIos, position );
        position += BTreeConstants.LONG_SIZE;

        // The number of elements in the page
        int nbElems = recordManager.readInt( recordManagerHeader.pageSize, pageIos, position );
        position += BTreeConstants.INT_SIZE;
        
        if ( nbElems == 0 )
        {
            // No elems, we are done
            StringBuilder sb = new StringBuilder();
            
            sb.append( String.format( "0x%04X", rootPageOffset ) ).append( " LOB RP[" ).append( revision ).append( "] : {}" );
            pages[(int)(rootPageOffset/recordManagerHeader.pageSize)] = sb.toString();
            
            return;
        }

        // The size of the data containing the keys and values
        // Reads the bytes containing all the keys and values, if we have some
        // We read  big blob of data into  ByteBuffer, then we will process
        // this ByteBuffer
        ByteBuffer byteBuffer = recordManager.readBytes( recordManagerHeader.pageSize, pageIos, position );

        // Now, deserialize the data block. If the number of elements
        // is positive, it's a Leaf, otherwise it's a Node
        // Note that only a leaf can have 0 elements, and it's the root page then.
        if ( nbElems > 0 )
        {
            // It's a leaf, process it as we may have sub-btrees
            dumpBtreeOfBtreesLeaf( recordManager, recordManagerHeader, keySerializer, valueSerializer, nbElems, revision, byteBuffer, pageIos[0].getOffset(), pages );
            
            // Update the attached PageIOS
            if ( pageIos.length > 0 )
            {
                for ( int i = 1; i < pageIos.length; i++ )
                {
                    PageIO pageIo = pageIos[i];
                    StringBuilder sb = new StringBuilder();
                    
                    sb.append( String.format( "0x%04X", pageIo.getOffset() ) ).append( " LOB RP[" ).append( revision ).append( "]-" ).append( i );
                    int pos = (int)(pageIo.getOffset()/recordManagerHeader.pageSize);
                    
                    if ( pages[pos] != null )
                    {
                        pages[pos] = new StringBuilder().append( pages[pos] ).append( ' ' ).append( sb.toString() ).toString();
                    }
                    else
                    {
                        pages[pos] = sb.toString();
                    }
                }
            }
        }
        else
        {
            // It's a node, dump its content, and iterate on the children
            dumpBtreeOfBtreesNode( recordManager, recordManagerHeader, keySerializer, valueSerializer, -nbElems, revision, byteBuffer, pageIos[0].getOffset(), pages );
            
            // Update the attached PageIOS
            if ( pageIos.length > 0 )
            {
                for ( int i = 1; i < pageIos.length; i++ )
                {
                    PageIO pageIo = pageIos[i];
                    StringBuilder sb = new StringBuilder();
                    
                    sb.append( String.format( "0x%04X", pageIo.getOffset() ) ).append( " LOB RP[" ).append( revision ).append( "]-" ).append( i );
                    pages[(int)(pageIo.getOffset()/recordManagerHeader.pageSize)] = sb.toString();
                }
            }
        }
    }

    
    /**
     * Dump a LOB Btree leaf.
     */
    private static void dumpBtreeOfBtreesLeaf( RecordManager recordManager, RecordManagerHeader recordManagerHeader, NameRevisionSerializer keySerializer,
        LongSerializer valueSerializer, int nbElems, long revision, ByteBuffer byteBuffer, long cpbOffset, String[] pages ) throws IOException
    {
        StringBuilder sb = new StringBuilder();

        sb.append( String.format( "0x%04X", cpbOffset ) ).append( " LOB RP[" ).append( revision ).append( "](l) : " );
        
        // Read each key and value
        for ( int i = 0; i < nbElems; i++ )
        {
            try
            {
                // just deserialize the keys and values
                // The value
                long btreeOffset = valueSerializer.deserialize( byteBuffer );

                // the key
                NameRevision key = keySerializer.deserialize( byteBuffer );;
                String btreeName = key.getName();
                
                if ( i > 0 )
                {
                    sb.append( ", " );
                }

                sb.append( key ).append( "->" ).append( String.format( "0x%04X", btreeOffset ) );
                
                // Dump the user btree
                dumpUserBtree( recordManager, recordManagerHeader, btreeName, btreeOffset, pages );
            }
            catch ( BufferUnderflowException bue )
            {
                throw new InvalidBTreeException( "The LOB leaf byte buffer is too short : " + bue.getMessage() );
            }
        }

        pages[(int)(cpbOffset/recordManagerHeader.pageSize)] = sb.toString();
    }
    
    
    /**
     * Dump a LOB Btree Node.
     */
    private static void dumpBtreeOfBtreesNode( RecordManager recordManager, RecordManagerHeader recordManagerHeader, NameRevisionSerializer keySerializer,
        LongSerializer valueSerializer, int nbElems, long revision, ByteBuffer byteBuffer, long cpbOffset, String[] pages ) throws IOException
    {
        StringBuilder sb = new StringBuilder();

        sb.append( String.format( "0x%04X", cpbOffset ) ).append( " LOB RP[" ).append( revision ).append( "](n) : " );
        
        long[] children = new long[nbElems + 1];
        int i = 0;

        // Read each key and value
        for ( ; i < nbElems; i++ )
        {
            try
            {
                // The offsets of the child
                children[i] = LongSerializer.INSTANCE.deserialize( byteBuffer );

                // the key
                NameRevision key = keySerializer.deserialize( byteBuffer );
                
                if ( i > 0 )
                {
                    sb.append( " | " );
                }

                sb.append( String.format( "0x%04X", children[i] ) ).append( " | " ).append( key );
            }
            catch ( BufferUnderflowException bue )
            {
                throw new InvalidBTreeException( "The LOB leaf byte buffer is too short : " + bue.getMessage() );
            }
        }

        // The last child
        children[i] = LongSerializer.INSTANCE.deserialize( byteBuffer );
        sb.append( " | " ).append( String.format( "0x%04X", children[i] ) );

        pages[(int)(cpbOffset/recordManagerHeader.pageSize)] = sb.toString();
        
        // Now iterate on each children
        for ( long child : children )
        {
            dumpBtreeOfBtreesContent( recordManager, recordManagerHeader, child, keySerializer, valueSerializer, pages );
        }
    }

    
    /**
     * Dump a user Btree
     */
    private static <K, V> void dumpUserBtree( RecordManager recordManager, RecordManagerHeader recordManagerHeader, String btreeName, long headerOffset, String[] pages ) 
        throws EndOfFileExceededException, IOException
    {
        StringBuilder sb = new StringBuilder();
        
        // Read the CPB header
        PageIO[] btreeOffsetPageIos = recordManager.readPageIOs( recordManagerHeader.pageSize, headerOffset, Long.MAX_VALUE );

        long dataPos = 0L;

        // The B-tree header page ID
        long id = recordManager.readLong( recordManagerHeader.pageSize, btreeOffsetPageIos, dataPos );
        dataPos += BTreeConstants.LONG_SIZE;

        // The B-tree current revision
        long revision = recordManager.readLong( recordManagerHeader.pageSize, btreeOffsetPageIos, dataPos );
        dataPos += BTreeConstants.LONG_SIZE;

        // The nb elems in the tree
        recordManager.readLong( recordManagerHeader.pageSize, btreeOffsetPageIos, dataPos );
        dataPos += BTreeConstants.LONG_SIZE;

        // The B-tree rootPage offset
        long rootPageOffset = recordManager.readLong( recordManagerHeader.pageSize, btreeOffsetPageIos, dataPos );

        dataPos += BTreeConstants.LONG_SIZE;

        // The B-tree info offset
        long infoOffset = recordManager.readLong( recordManagerHeader.pageSize, btreeOffsetPageIos, dataPos );
        
        // Dump the header
        sb.append( String.format( "0x%04X", headerOffset ) ).append( ' ' ).append( btreeName ).append( " H[" ).append( revision ).append( "] : " );
        sb.append( "<RP[" ).append( revision ).append( "] : " ).append( String.format( "0x%04X", rootPageOffset ) ).append( ">, " );
        sb.append( "<Info:" ).append( String.format( "0x%04X", infoOffset ) ).append( '>' );

        int pos = (int)headerOffset/recordManagerHeader.pageSize;
        
        if ( pages[pos] != null )
        {
            pages[pos] = new StringBuilder().append( pages[pos] ).append( ' ' ).append( sb.toString() ).toString();
        }
        else
        {
            pages[pos] = sb.toString();
        }
        
        // Dump the info
        BTreeInfo<K,V> btreeInfo = dumpBtreeInfo( recordManager, recordManagerHeader, infoOffset, btreeName, pages );
        
        // Dump the user B-tree content
        dumpUserBtreeContent( recordManager, recordManagerHeader, btreeInfo, rootPageOffset, pages );
    }

    
    /**
     * Dump a User B-tree content
     */
    private static <K, V> void dumpUserBtreeContent( RecordManager recordManager, RecordManagerHeader recordManagerHeader, BTreeInfo<K, V> btreeInfo, long rootPageOffset, 
        String[] pages ) throws IOException
    {
        // Process the rootPage
        PageIO[] pageIos = recordManager.readPageIOs( recordManagerHeader.pageSize, rootPageOffset, Long.MAX_VALUE );

        // Deserialize the page now
        long position = 0L;

        // The pageID
        long id = recordManager.readLong( recordManagerHeader.pageSize, pageIos, position );
        position += BTreeConstants.LONG_SIZE;

        // The revision
        long revision = recordManager.readLong( recordManagerHeader.pageSize, pageIos, position );
        position += BTreeConstants.LONG_SIZE;

        // The number of elements in the page
        int nbElems = recordManager.readInt( recordManagerHeader.pageSize, pageIos, position );
        position += BTreeConstants.INT_SIZE;
        
        if ( nbElems == 0 )
        {
            // No elems, we are done
            StringBuilder sb = new StringBuilder();
            
            sb.append( String.format( "0x%04X", rootPageOffset ) ).append( ' ' ).append( btreeInfo.getName() ).append( " RP[" ).append( revision ).append( "] : {}" );
            pages[(int)(rootPageOffset/recordManagerHeader.pageSize)] = sb.toString();
            
            return;
        }

        // The size of the data containing the keys and values
        // Reads the bytes containing all the keys and values, if we have some
        // We read  big blob of data into  ByteBuffer, then we will process
        // this ByteBuffer
        ByteBuffer byteBuffer = recordManager.readBytes( recordManagerHeader.pageSize, pageIos, position );

        // Now, deserialize the data block. If the number of elements
        // is positive, it's a Leaf, otherwise it's a Node
        // Note that only a leaf can have 0 elements, and it's the root page then.
        if ( nbElems > 0 )
        {
            // It's a leaf, process it as we may have sub-btrees
            dumpUserBtreeLeaf( recordManager, recordManagerHeader, btreeInfo, nbElems, revision, byteBuffer, pageIos[0].getOffset(), pages );
            
            // Update the attached PageIOS
            if ( pageIos.length > 0 )
            {
                for ( int i = 1; i < pageIos.length; i++ )
                {
                    PageIO pageIo = pageIos[i];
                    StringBuilder sb = new StringBuilder();
                    
                    sb.append( String.format( "0x%04X", pageIo.getOffset() ) ).append( ' ' ).append( btreeInfo.getName() );
                    sb.append( " RP[" ).append( revision ).append( "]-" ).append( i );
                    int pos = (int)(pageIo.getOffset()/recordManagerHeader.pageSize);
                    
                    if ( pages[pos] != null )
                    {
                        pages[pos] = new StringBuilder().append( pages[pos] ).append( ' ' ).append( sb.toString() ).toString();
                    }
                    else
                    {
                        pages[pos] = sb.toString();
                    }
                }
            }
        }
        else
        {
            // It's a node, dump its content, and iterate on the children
            dumpUserBtreeNode( recordManager, recordManagerHeader, btreeInfo, -nbElems, revision, byteBuffer, pageIos[0].getOffset(), pages );
            
            // Update the attached PageIOS
            if ( pageIos.length > 0 )
            {
                for ( int i = 1; i < pageIos.length; i++ )
                {
                    PageIO pageIo = pageIos[i];
                    StringBuilder sb = new StringBuilder();
                    
                    sb.append( String.format( "0x%04X", pageIo.getOffset() ) ).append( ' ' ).append( btreeInfo.getName() );
                    sb.append( " RP[" ).append( revision ).append( "]-" ).append( i );
                    pages[(int)(pageIo.getOffset()/recordManagerHeader.pageSize)] = sb.toString();
                }
            }
        }
    }
    
    
    /**
     * Dump a User Btree leaf.
     */
    private static <K, V> void dumpUserBtreeLeaf( RecordManager recordManager, RecordManagerHeader recordManagerHeader, BTreeInfo<K, V> btreeInfo,
        int nbElems, long revision, ByteBuffer byteBuffer, long cpbOffset, String[] pages ) throws IOException
    {
        StringBuilder sb = new StringBuilder();

        sb.append( String.format( "0x%04X", cpbOffset ) ).append( ' ' ).append( btreeInfo.getName() ).append( " RP[" ).append( revision ).append( "](l) : " );
        
        // Read each key and value
        for ( int i = 0; i < nbElems; i++ )
        {
            try
            {
                // just deserialize the keys and values
                // The value
                V value = btreeInfo.getValueSerializer().deserialize( byteBuffer );

                // the key
                K key = btreeInfo.getKeySerializer().deserialize( byteBuffer );
                
                if ( i > 0 )
                {
                    sb.append( ", " );
                }

                sb.append( '<' ).append( key ).append( ", " ).append( value ).append( '>' );
            }
            catch ( BufferUnderflowException bue )
            {
                throw new InvalidBTreeException( "The user leaf byte buffer is too short : " + bue.getMessage() );
            }
        }

        pages[(int)(cpbOffset/recordManagerHeader.pageSize)] = sb.toString();
    }
    
    
    /**
     * Dump a User Btree Node.
     */
    private static <K, V> void dumpUserBtreeNode( RecordManager recordManager, RecordManagerHeader recordManagerHeader, BTreeInfo<K, V> btreeInfo,
        int nbElems, long revision, ByteBuffer byteBuffer, long pageOffset, String[] pages ) throws IOException
    {
        StringBuilder sb = new StringBuilder();

        sb.append( String.format( "0x%04X", pageOffset ) ).append( ' ' ).append( btreeInfo.getName() ).append( " RP[" ).append( revision ).append( "](n) : " );
        
        long[] children = new long[nbElems + 1];
        int i = 0;

        // Read each key and value
        for ( ; i < nbElems; i++ )
        {
            try
            {
                // The offsets of the child
                children[i] = LongSerializer.INSTANCE.deserialize( byteBuffer );

                // the key
                K key = btreeInfo.getKeySerializer().deserialize( byteBuffer );
                
                if ( i > 0 )
                {
                    sb.append( " | " );
                }

                sb.append( String.format( "0x%04X", children[i] ) ).append( " | " ).append( key );
            }
            catch ( BufferUnderflowException bue )
            {
                throw new InvalidBTreeException( "The User leaf byte buffer is too short : " + bue.getMessage() );
            }
        }

        // The last child
        children[i] = LongSerializer.INSTANCE.deserialize( byteBuffer );
        sb.append( " | " ).append( String.format( "0x%04X", children[i] ) );

        pages[(int)(pageOffset/recordManagerHeader.pageSize)] = sb.toString();
        
        // Now iterate on each children
        for ( long child : children )
        {
            dumpUserBtreeContent( recordManager, recordManagerHeader, btreeInfo, child, pages );
        }
        
        System.out.println( sb.toString() );
    }

    
    /**
     * Dump a CPB Btree leaf.
     */
    private static void dumpCopiedPagesBtreeLeaf( RecordManager recordManager, RecordManagerHeader recordManagerHeader, RevisionNameSerializer keySerializer,
        LongArraySerializer valueSerializer, int nbElems, long revision, ByteBuffer byteBuffer, long cpbOffset, String[] pages ) throws IOException
    {
        StringBuilder sb = new StringBuilder();

        sb.append( String.format( "0x%04X", cpbOffset ) ).append( " CPB RP[" ).append( revision ).append( "](l) : " );
        
        // Read each key and value
        for ( int i = 0; i < nbElems; i++ )
        {
            try
            {
                // just deserialize the keys and values
                // The value
                long[] value = valueSerializer.deserialize( byteBuffer );

                // the key
                RevisionName key = keySerializer.deserialize( byteBuffer );
                
                if ( i > 0 )
                {
                    sb.append( ", " );
                }

                sb.append( key ).append( "->{" );
                
                boolean isFirst = true;
                
                for ( long offset : value )
                {
                    if ( isFirst )
                    {
                        isFirst = false;
                    }
                    else
                    {
                        sb.append( ", " );
                    }
                    
                    sb.append( String.format( "0x%04X", offset ) );
                    
                    // Process the copied pages offset now
                    StringBuilder sb1 = new StringBuilder();
                    
                    sb1.append( String.format( "0x%04X", offset ) );
                    sb1.append( " ---copied page at r" ).append( key.getRevision() ).append( "---" );
                    pages[(int)(offset/recordManagerHeader.pageSize)] = sb1.toString();
                }
                
                sb.append( '}' );
            }
            catch ( BufferUnderflowException bue )
            {
                throw new InvalidBTreeException( "The LOB leaf byte buffer is too short : " + bue.getMessage() );
            }
        }

        pages[(int)(cpbOffset/recordManagerHeader.pageSize)] = sb.toString();
    }
    
    
    /**
     * Dump a CPB Btree Node.
     */
    private static void dumpCopiedPagesBtreeNode( RecordManager recordManager, RecordManagerHeader recordManagerHeader, RevisionNameSerializer keySerializer,
        LongArraySerializer valueSerializer, int nbElems, long revision, ByteBuffer byteBuffer, long cpbOffset, String[] pages ) throws IOException
    {
        StringBuilder sb = new StringBuilder();

        sb.append( String.format( "0x%04X", cpbOffset ) ).append( " CPB RP[" ).append( revision ).append( "](n) : " );
        
        long[] children = new long[nbElems + 1];
        int i = 0;

        // Read each key and value
        for ( ; i < nbElems; i++ )
        {
            try
            {
                // The offsets of the child
                children[i] = LongSerializer.INSTANCE.deserialize( byteBuffer );

                // the key
                RevisionName key = keySerializer.deserialize( byteBuffer );
                
                if ( i > 0 )
                {
                    sb.append( " | " );
                }

                sb.append( String.format( "0x%04X", children[i] ) ).append( " | " ).append( key );
            }
            catch ( BufferUnderflowException bue )
            {
                throw new InvalidBTreeException( "The CPB leaf byte buffer is too short : " + bue.getMessage() );
            }
        }

        // The last child
        children[i] = LongSerializer.INSTANCE.deserialize( byteBuffer );
        sb.append( " | " ).append( String.format( "0x%04X", children[i] ) );

        pages[(int)(cpbOffset/recordManagerHeader.pageSize)] = sb.toString();
        
        // Now iterate on each children
        for ( long child : children )
        {
            dumpCopiedPagesBtreeContent( recordManager, recordManagerHeader, child, keySerializer, valueSerializer, pages );
        }
    }


    /**
     * Check a user's B-tree
     */
    private static <K, V> void checkBtree( RecordManager recordManager, RecordManagerHeader recordManagerHeader, long btreeOffset,
        Map<String, int[]> checkedPages ) throws Exception
    {
        // Read the B-tree header
        PageIO[] btreeHeaderPageIos = recordManager.readPageIOs( recordManagerHeader.pageSize, btreeOffset, Long.MAX_VALUE );

        long dataPos = 0L;

        // The B-tree page ID
        long id = recordManager.readLong( recordManagerHeader.pageSize, btreeHeaderPageIos, dataPos );
        dataPos += BTreeConstants.LONG_SIZE;

        // The B-tree current revision
        long btreeRevision = recordManager.readLong( recordManagerHeader.pageSize, btreeHeaderPageIos, dataPos );
        dataPos += BTreeConstants.LONG_SIZE;

        // The nb elems in the tree
        recordManager.readLong( recordManagerHeader.pageSize, btreeHeaderPageIos, dataPos );
        dataPos += BTreeConstants.LONG_SIZE;

        // The B-tree rootPage offset
        long rootPageOffset = recordManager.readLong( recordManagerHeader.pageSize, btreeHeaderPageIos, dataPos );

        checkOffset( recordManager, recordManagerHeader, rootPageOffset );

        dataPos += BTreeConstants.LONG_SIZE;

        // The B-tree info offset
        long btreeInfoOffset = recordManager.readLong( recordManagerHeader.pageSize, btreeHeaderPageIos, dataPos );

        checkOffset( recordManager, recordManagerHeader, btreeInfoOffset );

        BTreeInfo<K, V> btreeInfo = checkBtreeInfo( recordManager, recordManagerHeader, checkedPages, btreeInfoOffset, btreeRevision );

        // Update the checked pages
        updateCheckedPages( recordManagerHeader, checkedPages.get( btreeInfo.getName() ), recordManager.getPageSize( recordManagerHeader ), btreeHeaderPageIos );
        updateCheckedPages( recordManagerHeader, checkedPages.get( GLOBAL_PAGES_NAME ), recordManager.getPageSize( recordManagerHeader ), btreeHeaderPageIos );

        // And now, process the rootPage
        checkBtreePage( recordManager, recordManagerHeader, btreeInfo, checkedPages, rootPageOffset );
    }


    /**
     * Check the Btree of Btrees rootPage
     */
    private static <K, V> void checkBtreePage( RecordManager recordManager, RecordManagerHeader recordManagerHeader, BTreeInfo<K, V> btreeInfo,
        Map<String, int[]> checkedPages, long pageOffset ) throws Exception
    {
        PageIO[] pageIos = recordManager.readPageIOs( recordManagerHeader.pageSize, pageOffset, Long.MAX_VALUE );

        // Update the checkedPages array
        updateCheckedPages( recordManagerHeader, checkedPages.get( btreeInfo.getName() ), recordManager.getPageSize( recordManagerHeader ), pageIos );
        updateCheckedPages( recordManagerHeader, checkedPages.get( GLOBAL_PAGES_NAME ), recordManager.getPageSize( recordManagerHeader ), pageIos );

        // Deserialize the page now
        long position = 0L;

        // The page ID
        long id = recordManager.readLong( recordManagerHeader.pageSize, pageIos, position );
        position += BTreeConstants.LONG_SIZE;

        // The revision
        long revision = recordManager.readLong( recordManagerHeader.pageSize, pageIos, position );
        position += BTreeConstants.LONG_SIZE;

        // The number of elements in the page
        int nbElems = recordManager.readInt( recordManagerHeader.pageSize, pageIos, position );
        position += BTreeConstants.INT_SIZE;

        // The size of the data containing the keys and values
        // Reads the bytes containing all the keys and values, if we have some
        // We read  big blob of data into  ByteBuffer, then we will process
        // this ByteBuffer
        ByteBuffer byteBuffer = recordManager.readBytes( recordManagerHeader.pageSize, pageIos, position );

        // Now, deserialize the data block. If the number of elements
        // is positive, it's a Leaf, otherwise it's a Node
        // Note that only a leaf can have 0 elements, and it's the root page then.
        if ( nbElems >= 0 )
        {
            // It's a leaf, process it as we may have sub-btrees
            checkBtreeLeaf( recordManager, recordManagerHeader, btreeInfo, checkedPages, nbElems, revision, byteBuffer, pageIos );
        }
        else
        {
            // It's a node
            long[] children = checkBtreeNode( recordManager, recordManagerHeader, btreeInfo, checkedPages, -nbElems, revision, byteBuffer,
                pageIos );

            for ( int pos = 0; pos <= -nbElems; pos++ )
            {
                // Recursively check the children
                checkBtreePage( recordManager, recordManagerHeader, btreeInfo, checkedPages, children[pos] );
            }
        }
    }


    /**
     * Check the Btree info page
     * @throws ClassNotFoundException 
     */
    private static <K, V> BTreeInfo<K, V> checkBtreeInfo( RecordManager recordManager, RecordManagerHeader recordManagerHeader, Map<String, int[]> checkedPages,
        long btreeInfoOffset, long btreeRevision ) throws IOException
    {
        BTreeInfo<K, V> btreeInfo = new BTreeInfo<>();

        PageIO[] btreeInfoPagesIos = recordManager.readPageIOs( recordManagerHeader.pageSize, btreeInfoOffset, Long.MAX_VALUE );

        long dataPos = 0L;

        // The B-tree page size
        recordManager.readInt( recordManagerHeader.pageSize, btreeInfoPagesIos, dataPos );
        dataPos += BTreeConstants.INT_SIZE;

        // The tree name
        ByteBuffer btreeNameBytes = recordManager.readBytes( recordManagerHeader.pageSize, btreeInfoPagesIos, dataPos );
        dataPos += BTreeConstants.INT_SIZE + btreeNameBytes.limit();
        String btreeName = Strings.utf8ToString( btreeNameBytes );

        // The keySerializer FQCN
        ByteBuffer keySerializerBytes = recordManager.readBytes( recordManagerHeader.pageSize, btreeInfoPagesIos, dataPos );

        if ( keySerializerBytes != null )
        {
            String keySerializerFqcn = Strings.utf8ToString( keySerializerBytes );

            btreeInfo.setKeySerializer( ( ( ElementSerializer<K> ) getSerializer( keySerializerFqcn ) ) );
        }

        dataPos += BTreeConstants.INT_SIZE + keySerializerBytes.limit();

        // The valueSerialier FQCN
        ByteBuffer valueSerializerBytes = recordManager.readBytes( recordManagerHeader.pageSize, btreeInfoPagesIos, dataPos );

        if ( valueSerializerBytes != null )
        {
            String valueSerializerFqcn = Strings.utf8ToString( valueSerializerBytes );

            btreeInfo.setValueSerializer( ( ( ElementSerializer<V> ) getSerializer( valueSerializerFqcn ) ) );
        }

        dataPos += BTreeConstants.INT_SIZE + valueSerializerBytes.limit();

        // The B-tree allowDuplicates flag
        recordManager.readInt( recordManagerHeader.pageSize, btreeInfoPagesIos, dataPos );
        dataPos += BTreeConstants.INT_SIZE;

        // update the checkedPages
        if ( !BTreeConstants.COPIED_PAGE_BTREE_NAME.equals( btreeName )
            && !BTreeConstants.BTREE_OF_BTREES_NAME.equals( btreeName ) )
        {
            //btreeName = btreeName + "<" + btreeRevision + ">";
        }

        btreeInfo.setName( btreeName );

        // Update the checkedPages
        int[] checkedPagesArray = checkedPages.get( btreeName );

        if ( checkedPagesArray == null )
        {
            // Add the new name in the checkedPage name if it's not already there
            checkedPagesArray = createPageArray( recordManager, recordManagerHeader );
            checkedPages.put( btreeName, checkedPagesArray );
        }

        updateCheckedPages( recordManagerHeader, checkedPagesArray, recordManager.getPageSize( recordManagerHeader ), btreeInfoPagesIos );
        updateCheckedPages( recordManagerHeader, checkedPages.get( GLOBAL_PAGES_NAME ), recordManager.getPageSize( recordManagerHeader ), btreeInfoPagesIos );

        return btreeInfo;
    }


    /**
     * Get back the serializer instance
     */
    @SuppressWarnings("unchecked")
    private static <T> ElementSerializer<T> getSerializer( String serializerFqcn )
    {
        try
        {
            Class<?> serializerClass = Class.forName( serializerFqcn );
            ElementSerializer<T> serializer = null;

            try
            {
                serializer = ( ElementSerializer<T> ) serializerClass.getDeclaredField( "INSTANCE" ).get( null );
            }
            catch ( NoSuchFieldException e )
            {
                // ignore
            }

            if ( serializer == null )
            {
                serializer = ( ElementSerializer<T> ) serializerClass.newInstance();
            }

            return serializer;
        }
        catch ( Exception e )
        {
            throw new InvalidBTreeException( "Error : " + e.getMessage() );
        }
    }


    /**
     * Check the Btree of Btrees rootPage
     */
    private static <K, V> void checkBtreeOfBtreesPage( RecordManager recordManager, RecordManagerHeader recordManagerHeader, Map<String, int[]> checkedPages,
        long pageOffset ) throws Exception
    {
        PageIO[] pageIos = recordManager.readPageIOs( recordManagerHeader.pageSize, pageOffset, Long.MAX_VALUE );

        // Update the checkedPages array
        updateCheckedPages( recordManagerHeader, checkedPages.get( BTreeConstants.BTREE_OF_BTREES_NAME ), recordManager.getPageSize( recordManagerHeader ), pageIos );
        updateCheckedPages( recordManagerHeader, checkedPages.get( GLOBAL_PAGES_NAME ), recordManager.getPageSize( recordManagerHeader ), pageIos );

        // Deserialize the page now
        long position = 0L;

        // The page ID
        long id = recordManager.readLong( recordManagerHeader.pageSize, pageIos, position );
        position += BTreeConstants.LONG_SIZE;

        // The revision
        long revision = recordManager.readLong( recordManagerHeader.pageSize, pageIos, position );
        position += BTreeConstants.LONG_SIZE;

        // The number of elements in the page
        int nbElems = recordManager.readInt( recordManagerHeader.pageSize, pageIos, position );
        position += BTreeConstants.INT_SIZE;

        // The size of the data containing the keys and values
        // Reads the bytes containing all the keys and values, if we have some
        // We read  big blob of data into  ByteBuffer, then we will process
        // this ByteBuffer
        ByteBuffer byteBuffer = recordManager.readBytes( recordManagerHeader.pageSize, pageIos, position );

        // Now, deserialize the data block. If the number of elements
        // is positive, it's a Leaf, otherwise it's a Node
        // Note that only a leaf can have 0 elements, and it's the root page then.
        if ( nbElems >= 0 )
        {
            // It's a leaf, process it as we may have sub-btrees
            checkBtreeOfBtreesLeaf( recordManager, recordManagerHeader, checkedPages, nbElems, revision, byteBuffer, pageIos );
        }
        else
        {
            // It's a node
            long[] children = checkBtreeOfBtreesNode( recordManager, recordManagerHeader, checkedPages, -nbElems, revision, byteBuffer,
                pageIos );

            for ( int pos = 0; pos <= -nbElems; pos++ )
            {
                // Recursively check the children
                checkBtreeOfBtreesPage( recordManager, recordManagerHeader, checkedPages, children[pos] );
            }
        }
    }


    /**
     * Check a Btree of Btrees leaf. It contains <revision, name> -> offset.
     */
    private static void checkBtreeOfBtreesLeaf( RecordManager recordManager, RecordManagerHeader recordManagerHeader, Map<String, int[]> checkedPages,
        int nbElems, long revision, ByteBuffer byteBuffer, PageIO[] pageIos ) throws Exception
    {
        // Read each key and value
        for ( int i = 0; i < nbElems; i++ )
        {
            try
            {
                // This is a normal value, an offset
                long btreeOffset = byteBuffer.getLong();

                checkOffset( recordManager, recordManagerHeader , btreeOffset );

                // Now, process the key
                RevisionName revisionName = RevisionNameSerializer.INSTANCE.deserialize( byteBuffer );

                // Add the new name in the checkedPage name if it's not already there
                int[] btreePagesArray = createPageArray( recordManager, recordManagerHeader );
                checkedPages.put( revisionName.getName(), btreePagesArray );

                // Now, we can check the Btree we just found
                checkBtree( recordManager, recordManagerHeader, btreeOffset, checkedPages );

                //System.out.println( "read <" + btreeName + "," + btreeRevision + "> : 0x" + Long.toHexString( btreeOffset ) );
            }
            catch ( BufferUnderflowException bue )
            {
                throw new InvalidBTreeException( "The LOB leaf byte buffer is too short : " + bue.getMessage() );
            }
        }
    }


    /**
     * Check a Btree leaf.
     */
    private static <K, V> void checkBtreeLeaf( RecordManager recordManager, RecordManagerHeader recordManagerHeader, BTreeInfo<K, V> btreeInfo,
        Map<String, int[]> checkedPages, int nbElems, long revision, ByteBuffer byteBuffer, PageIO[] pageIos )
        throws Exception
    {
        // Read each key and value
        for ( int i = 0; i < nbElems; i++ )
        {
            try
            {
                // just deserialize the keys and values
                // The value
                btreeInfo.getValueSerializer().deserialize( byteBuffer );

                // the key
                btreeInfo.getKeySerializer().deserialize( byteBuffer );
            }
            catch ( BufferUnderflowException bue )
            {
                bue.printStackTrace();
                throw new InvalidBTreeException( "The LOB leaf byte buffer is too short : " + bue.getMessage() );
            }
        }
    }


    /**
     * Check a Btree of Btrees Node
     */
    private static <K, V> long[] checkBtreeOfBtreesNode( RecordManager recordManager, RecordManagerHeader recordManagerHeader, Map<String, int[]> checkedPages,
        int nbElems, long revision,
        ByteBuffer byteBuffer, PageIO[] pageIos ) throws IOException
    {
        long[] children = new long[nbElems + 1];

        // Read each value
        for ( int i = 0; i < nbElems; i++ )
        {
            // The offsets of the child
            long firstOffset = LongSerializer.INSTANCE.deserialize( byteBuffer );

            checkOffset( recordManager, recordManagerHeader, firstOffset );

            children[i] = firstOffset;

            // Read the revision
            byteBuffer.getLong();

            // read the btreeName
            int btreeNameLength = byteBuffer.getInt();

            // Read the Btree name
            byte[] bytes = new byte[btreeNameLength];
            byteBuffer.get( bytes );
        }

        // And read the last child
        // The offsets of the child
        long firstOffset = LongSerializer.INSTANCE.deserialize( byteBuffer );

        checkOffset( recordManager, recordManagerHeader, firstOffset );

        children[nbElems] = firstOffset;

        // and read the last value, as it's a node
        return children;
    }


    /**
     * Check a Btree node.
     */
    private static <K, V> long[] checkBtreeNode( RecordManager recordManager, RecordManagerHeader recordManagerHeader, BTreeInfo<K, V> btreeInfo,
        Map<String, int[]> checkedPages, int nbElems, long revision, ByteBuffer byteBuffer, PageIO[] pageIos )
        throws Exception
    {
        long[] children = new long[nbElems + 1];

        // Read each key and value
        for ( int i = 0; i < nbElems; i++ )
        {
            try
            {
                // The offsets of the child
                long firstOffset = LongSerializer.INSTANCE.deserialize( byteBuffer );

                checkOffset( recordManager, recordManagerHeader, firstOffset );

                children[i] = firstOffset;

                // Now, read the key
                btreeInfo.getKeySerializer().deserialize( byteBuffer );
            }
            catch ( BufferUnderflowException bue )
            {
                throw new InvalidBTreeException( "The LOB leaf byte buffer is too short : " + bue.getMessage() );
            }
        }

        // The last child
        // The offsets of the child
        long firstOffset = LongSerializer.INSTANCE.deserialize( byteBuffer );

        checkOffset( recordManager, recordManagerHeader, firstOffset );

        children[nbElems] = firstOffset;

        return children;
    }


    /**
     * Create an array of bits for pages 
     */
    private static int[] createPageArray( RecordManager recordManager, RecordManagerHeader recordManagerHeader ) throws IOException
    {
        long fileSize = recordManager.fileChannel.size();
        int pageSize = recordManager.getPageSize( recordManagerHeader );
        long nbPages = ( fileSize - RecordManager.recordManagerHeaderSize ) / pageSize;
        int nbPageBits = ( int ) ( nbPages / 32 );

        return new int[nbPageBits + 1];
    }


    /**
     * Update the array of seen pages.
     */
    private static void updateCheckedPages( RecordManagerHeader recordManagerHeader, int[] checkedPages, int pageSize, PageIO... pageIos )
    {
        for ( PageIO pageIO : pageIos )
        {
            long offset = pageIO.getOffset();

            setCheckedPage( rm, recordManagerHeader, checkedPages, offset );
        }
    }


    /**
     * Check the offset to be sure it's a valid one :
     * <ul>
     * <li>It's >= 0</li>
     * <li>It's below the end of the file</li>
     * <li>It's a multiple of the pageSize
     * </ul>
     */
    private static void checkOffset( RecordManager recordManager, RecordManagerHeader recordManagerHeader, long offset ) throws IOException
    {
        if ( ( offset == BTreeConstants.NO_PAGE ) ||
            ( ( ( offset - RecordManager.recordManagerHeaderSize ) % recordManager.getPageSize( recordManagerHeader ) ) != 0 ) ||
            ( offset > recordManager.fileChannel.size() ) )
        {
            throw new InvalidBTreeException( "Invalid Offset : " + offset );
        }
    }


    /**
     * Check the free pages
     */
    private static void checkFreePages( RecordManager recordManager, RecordManagerHeader recordManagerHeader, Map<String, int[]> checkedPages )
        throws IOException
    {
        if ( recordManagerHeader.firstFreePage == BTreeConstants.NO_PAGE )
        {
            return;
        }

        // Now, read all the free pages
        long currentOffset = recordManagerHeader.firstFreePage;
        long fileSize = recordManager.fileChannel.size();

        while ( currentOffset != BTreeConstants.NO_PAGE )
        {
            if ( currentOffset > fileSize )
            {
                System.out.println( "Wrong free page offset, above file size : " + currentOffset );
                return;
            }

            try
            {
                PageIO pageIo = recordManager.fetchPageIO( recordManagerHeader.pageSize, currentOffset );

                if ( currentOffset != pageIo.getOffset() )
                {
                    System.out.println( "PageIO offset is incorrect : " + currentOffset + "-"
                        + pageIo.getOffset() );
                    return;
                }

                setCheckedPage( recordManager, recordManagerHeader, checkedPages.get( GLOBAL_PAGES_NAME ), currentOffset );
                setCheckedPage( recordManager, recordManagerHeader, checkedPages.get( FREE_PAGES_NAME ), currentOffset );

                long newOffset = pageIo.getNextPage();
                currentOffset = newOffset;
            }
            catch ( IOException ioe )
            {
                throw new InvalidBTreeException( "Cannot fetch page at : " + currentOffset );
            }
        }
    }


    /**
     * Update the CheckedPages array
     */
    private static void setCheckedPage( RecordManager recordManager, RecordManagerHeader recordManagerHeader, int[] checkedPages, long offset )
    {
        int pageNumber = ( int ) offset / recordManager.getPageSize( recordManagerHeader );
        int nbBitsPage = ( BTreeConstants.INT_SIZE << 3 );
        long pageMask = checkedPages[pageNumber / nbBitsPage];
        long mask = 1L << pageNumber % nbBitsPage;

        if ( ( pageMask & mask ) != 0 )
        {
            //throw new InvalidBTreeException( "The page " + offset + " has already been referenced" );
        }

        pageMask |= mask;

        checkedPages[pageNumber / nbBitsPage] |= pageMask;
    }


    /**
     * Output the pages that has been seen ('1') and those which has not been seen ('0'). The '.' represent non-pages
     * at the end of the file.
     */
    private static void dumpCheckedPages( RecordManager recordManager, RecordManagerHeader recordManagerHeader, Map<String, int[]> checkedPages )
        throws IOException
    {
        // First dump the global array
        int[] globalArray = checkedPages.get( GLOBAL_PAGES_NAME );
        String result = dumpPageArray( recordManager, recordManagerHeader, globalArray );

        String dump = String.format( "%1$-40s : %2$s", GLOBAL_PAGES_NAME, result );
        System.out.println( dump );

        // The free pages array
        int[] freePagesArray = checkedPages.get( FREE_PAGES_NAME );
        result = dumpPageArray( recordManager, recordManagerHeader, freePagesArray );

        dump = String.format( "%1$-40s : %2$s", FREE_PAGES_NAME, result );
        System.out.println( dump );

        // The B-tree of B-trees pages array
        int[] btreeOfBtreesArray = checkedPages.get( BTreeConstants.BTREE_OF_BTREES_NAME );
        result = dumpPageArray( recordManager, recordManagerHeader, btreeOfBtreesArray );

        dump = String.format( "%1$-40s : %2$s", BTreeConstants.BTREE_OF_BTREES_NAME, result );
        System.out.println( dump );

        // The Copied page B-tree pages array
        int[] copiedPagesArray = checkedPages.get( BTreeConstants.COPIED_PAGE_BTREE_NAME );
        result = dumpPageArray( recordManager, recordManagerHeader, copiedPagesArray );

        dump = String.format( "%1$-40s : %2$s", BTreeConstants.COPIED_PAGE_BTREE_NAME, result );
        System.out.println( dump );

        // And now, all the other btree arrays
        for ( String btreeName : checkedPages.keySet() )
        {
            // Don't do the array we have already processed
            if ( knownPagesArrays.contains( btreeName ) )
            {
                continue;
            }

            int[] btreePagesArray = checkedPages.get( btreeName );
            result = dumpPageArray( recordManager, recordManagerHeader, btreePagesArray );

            dump = String.format( "%1$-40s : %2$s", btreeName, result );
            System.out.println( dump );
        }
    }


    /**
     * @see #getPageOffsets()
     */
    public static List<Long> getFreePages( RecordManagerHeader recordManagerHeader ) throws IOException
    {
        return getPageOffsets( recordManagerHeader, FREE_PAGES_NAME );
    }

    
    /**
     * @see #getPageOffsets()
     */
    public static List<Long> getGlobalPages( RecordManagerHeader recordManagerHeader ) throws IOException
    {
        return getPageOffsets( recordManagerHeader, GLOBAL_PAGES_NAME );
    }

    
    /**
     * Gives a list of offsets of pages from the page array associated wit the given name.
     * 
     * This method should always be called after calling check() method.
     * 
     * @return a list of offsets
     * @throws IOException
     */
    public static List<Long> getPageOffsets( RecordManagerHeader recordManagerHeader, String pageArrayName ) throws IOException
    {
        List<Long> lst = new ArrayList<>();
        
        int[] fparry = checkedPages.get( pageArrayName );

        long nbPagesChecked = 0; // the 0th page will always be of RM header
        long fileSize = rm.fileChannel.size();
        long nbPages = ( fileSize - RecordManager.recordManagerHeaderSize ) / rm.getPageSize( recordManagerHeader );

        for ( int checkedPage : fparry )
        {
            for ( int j = 0; j < 32; j++ )
            {

                if ( nbPagesChecked > nbPages + 1 )
                {
                    break;
                }
                else
                {
                    int mask = ( checkedPage & ( 1 << j ) );
                    if ( mask != 0 )
                    {
                        lst.add( nbPagesChecked * rm.getPageSize( recordManagerHeader ));
                    }
                }
                
                nbPagesChecked++;
            }
        }
        
        return lst;
    }
    
    
    /**
     * Process a page array
     */
    private static String dumpPageArray( RecordManager recordManager, RecordManagerHeader recordManagerHeader, int[] checkedPages ) throws IOException
    {
        StringBuilder sb = new StringBuilder();
        int i = -1;
        int nbPagesChecked = 0;
        long fileSize = recordManager.fileChannel.size();
        long nbPages = ( fileSize - RecordManager.recordManagerHeaderSize ) / recordManager.getPageSize( recordManagerHeader );

        for ( int checkedPage : checkedPages )
        {
            i++;

            sb.append( " [" ).append( i ).append( "] " );

            for ( int j = 0; j < 32; j++ )
            {
                if ( nbPagesChecked >= nbPages + 1 )
                {
                    sb.append( "." );
                }
                else
                {
                    if ( ( checkedPage & ( 1 << j ) ) == 0 )
                    {
                        sb.append( "0" );
                    }
                    else
                    {
                        sb.append( "1" );
                    }
                }

                nbPagesChecked++;
            }
        }

        return sb.toString();
    }


    /**
     * The entry point method
     */
    public void start() throws Exception
    {
        if ( !checkFilePresence() )
        {
            return;
        }

        if ( !loadRm() )
        {
            return;
        }

        boolean stop = false;

        while ( !stop )
        {
            System.out.println( "Choose an option:" );
            System.out.println( "n - Print Number of BTrees" );
            System.out.println( "b - Print BTree Names" );
            System.out.println( "i - Inspect BTree" );
            System.out.println( "c - Check Free Pages" );
            System.out.println( "s - Get database file size" );
            System.out.println( "d - Dump RecordManager" );
            System.out.println( "r - Reload RecordManager" );
            System.out.println( "o - Read page at offset" );
            System.out.println( "q - Quit" );

            char c = readOption();

            switch ( c )
            {
                case 'n':
                    printNumberOfBTrees( rm.getCurrentRecordManagerHeader() );
                    break;

                case 'b':
                    printBTreeNames();
                    break;

                case 'i':
                    inspectBTree( rm );
                    break;

                case 'c':
                    long fileSize = rm.fileChannel.size();
                    long nbPages = fileSize / rm.getPageSize( rm.getCurrentRecordManagerHeader() );
                    int nbPageBits = ( int ) ( nbPages / BTreeConstants.INT_SIZE );

                    Map<String, int[]> checkedPages = new HashMap<String, int[]>( 2 );

                    // The global page array
                    checkedPages.put( GLOBAL_PAGES_NAME, new int[nbPageBits + 1] );

                    // The freePages array
                    checkedPages.put( FREE_PAGES_NAME, new int[nbPageBits + 1] );

                    checkFreePages( rm, rm.getCurrentRecordManagerHeader(), checkedPages );
                    break;

                case 's':
                    printFileSize();
                    break;

                case 'd':
                    check( rm );
                    break;

                case 'r':
                    loadRm();
                    break;

                case 'o':
                    readPageAt(rm.getCurrentRecordManagerHeader() );
                    break;
                case 'q':
                    stop = true;
                    break;

                default:
                    System.out.println( "Invalid option" );
                    //c = readOption( br );
                    break;
            }
        }

        try
        {
            rm.close();
            br.close();
        }
        catch ( Exception e )
        {
            //ignore
        }
    }


    /**
     * Read the user's interaction
     */
    private String readLine()
    {
        try
        {
            String line = br.readLine();

            if ( line != null )
            {
                return line.trim();
            }
            else
            {
                return "";
            }
        }
        catch ( Exception e )
        {
            throw new RuntimeException( e );
        }
    }


    /**
     * Process the input and get back the selected choice
     */
    private char readOption()
    {
        try
        {
            String s = br.readLine();

            if ( ( s == null ) || ( s.length() == 0 ) )
            {
                return ' ';
            }

            return s.charAt( 0 );
        }
        catch ( Exception e )
        {
            throw new RuntimeException( e );
        }
    }

    
    private void readPageAt( RecordManagerHeader recordManagerHeader ) throws IOException
    {
        System.out.println();
        System.out.print( "Offset: " );
        
        String s = readLine();
        
        long offset = -1;
        
        try
        {
            offset = Long.parseLong( s.trim() );
        }
        catch( Exception e )
        {
            offset = -1;
        }
        
        if( offset < 0 || offset > (rm.fileChannel.size() - BTreeConstants.DEFAULT_PAGE_SIZE) )
        {
            System.out.println( "Invalid offset " + s );
            return;
        }
        
        PageIO io = rm.fetchPageIO( recordManagerHeader.pageSize, offset );

        List<Long> ll = new ArrayList<Long>();
        ll.add( offset );
        
        do
        {
            long next = io.getNextPage();
            ll.add( next );
            if ( next == -1 )
            {
                break;
            }
            
            io = rm.fetchPageIO( recordManagerHeader.pageSize, next );
        }
        while( true );
        
        int i = 0;
        for ( ; i < ll.size() - 2; i++ )
        {
            System.out.print( ll.get( i ) + " --> ");
        }
        
        System.out.println( ll.get( i ) );
    }

    
    /**
     * Main method
     */
    public static void main( String[] args ) throws Exception
    {

        if ( args.length == 0 )
        {
            System.out.println( "Usage java MavibotInspector <db-file-path>" );
            System.exit( 0 );
        }
        
        File f = new File( args[0] );

        MavibotInspector mi = new MavibotInspector( f );
        mi.start();
    }
}