/*---------------------------------------------------------------------------*
  Project:  NintendoWare
  File:     io_HioFileStream.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: 13145 $
 *---------------------------------------------------------------------------*/

#include "precompiled.h"

#include <nw/io/io_HioFileStream.h>

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

namespace
{
s64 GetHioFileSize( nn::hio::HostFile& file )
{
    s64 current;
    file.Seek( &current, 0, nn::hio::HostFile::SEEK_TYPE_CURRENT );

    s64 fileSize;
    file.Seek( &fileSize, 0, nn::hio::HostFile::SEEK_TYPE_END );
    file.Seek( current, nn::hio::HostFile::SEEK_TYPE_SET );

    return fileSize;
}
}

namespace nw {
namespace io   {

NW_UT_RUNTIME_TYPEINFO_DEFINITION(HioFileStream,IOStream);

void HioFileStream::Initialize()
{
    m_CanRead = false;
    m_CanWrite = false;
    m_CloseEnableFlag = false;
    m_CloseOnDestroyFlag = false;
    m_IsAvailable = false;
}

HioFileStream::HioFileStream()
{
    this->Initialize();
}

HioFileStream::HioFileStream( const char* path, bit32 accessMode,
        nn::hio::HostFile::OpenDisp disp )
{
    Initialize();
    Open( path, accessMode, disp );
}

#ifdef NW_PLATFORM_CTRWIN
HioFileStream::HioFileStream( ... )
{
    // TODO: PC 版は未対応
}
#else
HioFileStream::HioFileStream(
        nn::hio::HostFile* openedFile, bit32 accessMode, bool closeEnable )
{
    Initialize();
    Open( openedFile, accessMode, closeEnable );
}
#endif

HioFileStream::~HioFileStream()
{
    if ( m_CloseOnDestroyFlag )
    {
        this->Close();
    }
}

bool HioFileStream::Open( const char* path, bit32 accessMode,
        nn::hio::HostFile::OpenDisp disp )
{
    if ( m_CloseOnDestroyFlag )
    {
        Close();
    }
    m_CanRead  = ( accessMode & nn::hio::HostFile::ACCESS_MODE_READ )  ? true : false;
    m_CanWrite = ( accessMode & nn::hio::HostFile::ACCESS_MODE_WRITE ) ? true : false;
    m_CloseEnableFlag = true;
    m_CloseOnDestroyFlag = true;
    m_IsAvailable = false;

    if ( m_File.Open( path, accessMode, disp ).IsSuccess() )
    {
        m_pOpenedFile = &m_File;
        s64 fileSize = GetHioFileSize( *m_pOpenedFile );
        m_FilePosition.SetFileSize( static_cast<u32>(fileSize) );
        m_pOpenedFile->Seek( 0, nn::hio::HostFile::SEEK_TYPE_SET );
        m_IsAvailable = true;
        return true;
    }
    return false;
}

#ifdef NW_PLATFORM_CTRWIN
bool HioFileStream::Open( ... )
{
    // TODO: PC 版は未対応
}
#else
bool HioFileStream::Open(
        nn::hio::HostFile* openedFile, bit32 accessMode, bool closeEnable )
{
    if ( m_CloseOnDestroyFlag )
    {
        Close();
    }
    m_CanRead  = ( accessMode & nn::hio::HostFile::ACCESS_MODE_READ )  ? true : false;
    m_CanWrite = ( accessMode & nn::hio::HostFile::ACCESS_MODE_WRITE ) ? true : false;

    // 外部でオープンされたファイルなので、デストラクタや Close 関数で、
    // クローズするかどうかはユーザ指定可能
    m_CloseEnableFlag = closeEnable;
    m_CloseOnDestroyFlag = true;
    m_IsAvailable = false;

    m_pOpenedFile = openedFile;
    s64 result = m_pOpenedFile->Seek( 0, nn::hio::HostFile::SEEK_TYPE_SET );
    if ( result != -1 )
    {
        s64 fileSize = GetHioFileSize( *m_pOpenedFile );
        m_FilePosition.SetFileSize( static_cast<u32>(fileSize) );
        m_pOpenedFile->Seek( 0, nn::hio::HostFile::SEEK_TYPE_SET );
        m_IsAvailable = true;
        return true;
    }
    return false;
}
#endif

void HioFileStream::Close()
{
    if ( m_CloseEnableFlag && m_IsAvailable )
    {
        nn::Result result = m_pOpenedFile->Close();
        NW_ASSERT( result.IsSuccess() );
        m_pOpenedFile = NULL;
        m_IsAvailable = false;
    }
}

s32 HioFileStream::Read( void* buf, u32 length )
{
    NW_ASSERTMSG( m_IsAvailable, "HostFile is not opened" );
    if ( m_CanRead == false )
    {
        return -1;
    }

    m_pOpenedFile->Seek( m_FilePosition.Tell(), nn::hio::HostFile::SEEK_TYPE_SET );
    s32 readBytes = m_pOpenedFile->Read( buf, length );
    if ( readBytes > 0 )
    {
        m_FilePosition.Skip( readBytes );
    }
    return readBytes;
}

s32 HioFileStream::Write( const void* buf, u32 length )
{
    NW_ASSERTMSG( m_IsAvailable, "HostFile is not opened" );
    if ( m_CanWrite == false )
    {
        return -1;
    }

    m_pOpenedFile->Seek( m_FilePosition.Tell(), nn::hio::HostFile::SEEK_TYPE_SET );
    s32 writeBytes = m_pOpenedFile->Write( buf, length );
    if ( writeBytes > 0 )
    {
        m_FilePosition.Skip( writeBytes );
    }
    return writeBytes;
}

void HioFileStream::Seek( s32 offset, u32 origin )
{
    NW_ASSERTMSG( m_IsAvailable, "HostFile is not opened" );
    m_FilePosition.Seek( offset, origin );
}


}   /* namespace io */
}   /* namespace nw */