/*---------------------------------------------------------------------------*
  Project:  NintendoWare
  File:     ut_BinaryFileFormat.cpp

  Copyright (C)2009-2010 Nintendo Co., Ltd./HAL Laboratory, Inc.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Revision:$
 *---------------------------------------------------------------------------*/

#include "precompiled.h"

#include <nw/types.h>
#include <nw/assert.h>
#include <nw/ut/ut_BinaryFileFormat.h>
#include <nw/ut/ut_Inlines.h>


namespace nw {
namespace ut {


bool
IsValidBinaryFile(
    const BinaryFileHeader* pHeader,
    u32                     signature,
    u32                     version,
    u16                     minBlocks  /* = 1 */
)
{
    NW_POINTER_ASSERT( pHeader );
    
    if ( pHeader->signature != signature )
    {
        NW_WARNING(false, "Signature check failed ('%c%c%c%c' must be '%c%c%c%c').",
            static_cast<char>(BitExtract(pHeader->signature, 24, 8)),
            static_cast<char>(BitExtract(pHeader->signature, 16, 8)),
            static_cast<char>(BitExtract(pHeader->signature,  8, 8)),
            static_cast<char>(BitExtract(pHeader->signature,  0, 8)),
            static_cast<char>(BitExtract(signature, 24, 8)),
            static_cast<char>(BitExtract(signature, 16, 8)),
            static_cast<char>(BitExtract(signature,  8, 8)),
            static_cast<char>(BitExtract(signature,  0, 8))
        );
        return false;
    }
    
    if ( pHeader->byteOrder != BYTE_ORDER_MARK )
    {
        NW_WARNING(false, "Unsupported byte order.");
        return false;
    }
    
    if ( NW_UT_VERSION_MAJOR(version) != NW_UT_VERSION_MAJOR(pHeader->version) ||
         NW_UT_VERSION_MINOR(version) < NW_UT_VERSION_MINOR(pHeader->version)  ||
         NW_UT_VERSION_BINARYBUGFIX(version) > NW_UT_VERSION_BINARYBUGFIX(pHeader->version) )
    {
        NW_WARNING(false, "Version check faild (bin:'%d.%d.%d.%d', lib:'%d.%d.%d.%d').",
            NW_UT_VERSION_MAJOR(pHeader->version),
            NW_UT_VERSION_MINOR(pHeader->version),
            NW_UT_VERSION_MICRO(pHeader->version),
            NW_UT_VERSION_BINARYBUGFIX(pHeader->version),
            NW_UT_VERSION_MAJOR(version),
            NW_UT_VERSION_MINOR(version),
            NW_UT_VERSION_MICRO(version),
            NW_UT_VERSION_BINARYBUGFIX(version)
        );
        return false;
    }
    
    if( pHeader->fileSize < sizeof(BinaryFileHeader) + sizeof(BinaryBlockHeader) * minBlocks )
    {
        NW_WARNING(false, "Too small file size(=%d).", pHeader->fileSize);
        return false;
    }
    
    if( pHeader->dataBlocks < minBlocks )
    {
        NW_WARNING(false, "Too small number of data blocks(=%d).", pHeader->dataBlocks);
        return false;
    }

    return true;
}


/*!--------------------------------------------------------------------------*
  Name:         IsReverseEndianBinaryFile

  @brief        NintendoWare 標準バイナリファイルのエンディアンが逆かどうかを
                チェックします。

  @param[in]    pFileHeader     対象のファイルヘッダへのポインタ

  @return       エンディアンが逆なら true,さもなければ false を返します。
 *---------------------------------------------------------------------------*/
bool 
IsReverseEndianBinaryFile( const BinaryFileHeader* pFileHeader )
{
    NW_POINTER_ASSERT( pFileHeader );
    return ( pFileHeader->byteOrder != BYTE_ORDER_MARK );
}


/*!--------------------------------------------------------------------------*
  Name:         GetNextBinaryBlockHeader

  @brief        NintendoWare 標準バイナリファイル内の次のブロックヘッダを
                取得します。

  @param[in]    pFileHeader     対象のファイルヘッダへのポインタ
  @param[in]    pBlockHeader    現在のブロックヘッダへのポインタ
  
  @return       pBlockHeaderの次のブロックヘッダを返します。
                次のブロックがない場合は、NULLを返します。
                pBlockHeaderがNULLの場合は、一番始めのブロックヘッダを返します。
 *---------------------------------------------------------------------------*/
BinaryBlockHeader* 
GetNextBinaryBlockHeader(
    BinaryFileHeader*       pFileHeader,
    BinaryBlockHeader*      pBlockHeader
)
{
    NW_POINTER_ASSERT( pFileHeader );
    
    void* ptr;
    if ( ! IsReverseEndianBinaryFile( pFileHeader ) )
    {
        if ( pBlockHeader == NULL )
        {
            if ( pFileHeader->dataBlocks == 0 ) return NULL;
            ptr = AddOffsetToPtr( pFileHeader, pFileHeader->headerSize );
        }
        else
        {
            ptr = AddOffsetToPtr( pBlockHeader, pBlockHeader->size );
        }
    
        if ( ptr >= AddOffsetToPtr( pFileHeader, pFileHeader->fileSize ) )
        {
            return NULL;
        }
    }
    else
    {
        if ( pBlockHeader == NULL )
        {
            if ( pFileHeader->dataBlocks == 0 ) return NULL;
            ptr = AddOffsetToPtr( pFileHeader, ReverseEndian( pFileHeader->headerSize ) );
        }
        else
        {
            ptr = AddOffsetToPtr( pBlockHeader, ReverseEndian( pBlockHeader->size ) );
        }
        
        if ( ptr >= AddOffsetToPtr( pFileHeader, ReverseEndian( pFileHeader->fileSize ) ) )
        {
            return NULL;
        }
    }
    
    return reinterpret_cast<BinaryBlockHeader*>( ptr );
}

} /* namespace ut */
} /* namespace nw */