/*
 *  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.nio.ByteBuffer;

import org.apache.directory.mavibot.btree.util.Strings;


/**
 * A structure containing a Page on disk. It's a byte[PageSize] plus a few more details like
 * the page offset on disk and a link to the next page.</br>
 * As we may need more than one Page to store some data, the PageIO are linked so that
 * the list of all the PageIO contain the full data.</br>
 * The first PageIO contains the size of the data.</br>
 * Here is the logical structure of a PageIO :
 * <pre>
 * For a first page :
 *
 * +----------+------+----------------------+
 * | nextPage | size | XXXXXXXXXXXXXXXXXXXX |
 * +----------+------+----------------------+
 *
 * for any page but the first :
 *
 * +----------+-----------------------------+
 * | nextPage | XXXXXXXXXXXXXXXXXXXXXXXXXXX |
 * +----------+-----------------------------+
 *
 * for the last page :
 * +----------+-----------------------------+
 * |    -1    | XXXXXXXXXXXXXXXXXXXXXXXXXXX |
 * +----------+-----------------------------+
 *
 * In any case, the page length is always PageSize.
 * </pre>
 *
 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
 */
/* No qualifier*/class PageIO
{
    /** The contain data */
    private ByteBuffer data;

    /** A pointer to the next pageIO */
    private long nextPage;

    /** The offset on disk */
    private int size;

    /** The position of the page on disk */
    private long offset;


    /**
     * A default constructor for a PageIO
     */
    /* no qualifier */PageIO()
    {
        nextPage = -2L;
        size = -1;
        offset = -1L;
    }


    /**
     * A constructor for a PageIO when we know the offset of this page on disk
     */
    /* no qualifier */PageIO( long offset )
    {
        nextPage = -2L;
        size = -1;
        this.offset = offset;
    }


    /**
     * @return the data
     */
    /* no qualifier */ByteBuffer getData()
    {
        return data;
    }


    /**
     * @param data the data to set
     */
    /* no qualifier */void setData( ByteBuffer data )
    {
        this.data = data;
        nextPage = data.getLong( 0 );
    }


    /**
     * Get the NextPage value from the PageIO. If it's -1, there is no next page<br/>
     * @return the nextPage
     */
    /* no qualifier */long getNextPage()
    {
        return nextPage;
    }


    /**
     * @param nextPage the nextPage to set
     */
    /* no qualifier */void setNextPage( long nextPage )
    {
        this.nextPage = nextPage;

        data.putLong( 0, nextPage );
    }


    /**
     * @return the size
     */
    /* no qualifier */long getSize()
    {
        return size;
    }


    /**
     * @param size the size to set
     */
    /* no qualifier */void setSize( int size )
    {
        data.putInt( 8, size );

        this.size = size;
    }


    /**
     * @param size the size to set
     */
    /* no qualifier */void setSize()
    {
        size = data.getInt( 8 );
    }


    /**
     * @return the offset
     */
    /* no qualifier */long getOffset()
    {
        return offset;
    }


    /**
     * @param offset the offset to set
     */
    /* no qualifier */void setOffset( long offset )
    {
        this.offset = offset;
    }


    /* no qualifier */PageIO copy( PageIO copy )
    {
        // The data
        if ( data.isDirect() )
        {
            copy.data = ByteBuffer.allocateDirect( data.capacity() );
        }
        else
        {
            copy.data = ByteBuffer.allocate( data.capacity() );
        }

        // Save the original buffer position and limit
        int start = data.position();
        int limit = data.limit();

        // The data is extended to get all the bytes in it
        data.position( 0 );
        data.limit( data.capacity() );

        // Copy the data
        copy.data.put( data );

        // Restore the original buffer to the initial position and limit
        data.position( start );
        data.limit( limit );

        // Set those position and limit in the copied buffer
        copy.data.position( start );
        copy.data.limit( limit );

        // The size
        copy.size = size;

        // The offset and next page pointers are not copied.
        return copy;
    }


    /**
     * @see Object#toString()
     */
    public String toString()
    {
        StringBuilder sb = new StringBuilder();

        sb.append( "PageIO[offset:0x" ).append( Long.toHexString( offset ) );

        if ( size != -1 )
        {
            sb.append( ", size:" ).append( size );
        }

        if ( nextPage != -1L )
        {
            sb.append( ", next:0x" ).append( Long.toHexString( nextPage ) );
        }

        sb.append( "]" );

        int start = 0;

        byte[] array = null;

        data.mark();
        data.position( 0 );

        if ( data.isDirect() )
        {
            array = new byte[data.capacity()];
            data.get( array );
        }
        else
        {
            array = data.array();
        }

        data.reset();

        for ( int i = start; i < array.length; i++ )
        {
            if ( ( ( i - start ) % 16 ) == 0 )
            {
                sb.append( "\n    " );
            }

            sb.append( Strings.dumpByte( array[i] ) ).append( " " );
        }

        return sb.toString();
    }
}