#include "stdafx.h"

#include "FileLoader.h"
#include "FileSystem.h"
#include "File.h"
#include "MemFile.h"

cFileLoader::cFileLoader()
{
	mMemUsed = false;
	mFile = 0;
}

cFileLoader::~cFileLoader()
{
	Close();
}

bool cFileLoader::Open( const cString& pathName, bool useMemory )
{
	/// ÀÌ¹Ì ¿­·ÁÀÖ´Â Áö °Ë»ç
	if( mFile )
	{
		LPCRITICAL_SECTION cs = FILESYSTEM->GetReadCS();

		EnterCriticalSection( cs );
		if( mFile->Open( pathName ) == true )
		{
			LeaveCriticalSection( cs );
			return true;
		}
		else
		{
			LeaveCriticalSection( cs );
			assert( 0 && "file is open error!!" );
			return false;
		}
	}

	mMemUsed = useMemory;

	if( useMemory )
	{
		mFile = FILESYSTEM->OpenMemFileToRead( pathName );
	}
	else
	{
		mFile = FILESYSTEM->OpenFileToRead( pathName );
	}
	return mFile != 0;
}

bool cFileLoader::OpenNoPack( const cString& pathName, bool useMemory )
{
	if( mFile )
	{
		assert( 0 && "file is already opened" );
		return false;
	}

	mMemUsed = useMemory;

	if( useMemory )
	{
		mFile = FILESYSTEM->OpenMemFileToRead_NoPack( pathName );
	}
	else
	{
		mFile = FILESYSTEM->OpenFileToRead_NoPack( pathName );
	}

	return mFile != 0;
}


int cFileLoader::Close()
{
	mMemUsed = false;

	if( mFile )
	{
		int ret = mFile->Close();
		delete mFile;
		mFile = 0;
		return ret;
	}
	return 0;
}

unsigned int cFileLoader::Read( void* buffer, unsigned int size )
{
	if( mFile )
	{
		return mFile->Read( buffer, size );
	}
	return 0;
}

bool cFileLoader::ReadInt( int* pvalue )
{
	if( mFile )
	{
		return mFile->Read( pvalue, sizeof(int) ) == sizeof(int);
	}
	return false;
}

bool cFileLoader::ReadUnsignedInt( unsigned int* pvalue )
{
	if( mFile )
	{
		return mFile->Read( pvalue, sizeof(unsigned int) ) == sizeof(unsigned int);
	}
	return false;
}

bool cFileLoader::ReadFloat( float* pvalue )
{
	if( mFile )
	{
		return mFile->Read( pvalue, sizeof(float) ) == sizeof(float);
	}
	return false;
}

unsigned int cFileLoader::ReadLine( char* buffer, unsigned int bufferSize )
{
	if( mFile )
	{
		return mFile->ReadLine( buffer, bufferSize );
	}
	return 0;
}

int cFileLoader::Seek( unsigned int offset, int origin )
{
	if( mFile )
	{
		return mFile->Seek( offset, origin );
	}
	return -1;
}

unsigned int cFileLoader::Tell() const
{
	if( mFile )
	{
		return mFile->Tell();
	}
	return 0;
}

unsigned int cFileLoader::GetSize() const
{
	if( mFile )
	{
		return mFile->GetSize();
	}
	return 0;
}

bool cFileLoader::IsEnd() const
{
	if( mFile )
	{
		return mFile->IsEnd();
	}
	return true;
}

bool cFileLoader::IsEmpty() const
{
	if( mFile )
	{
		return mFile->IsEmpty();
	}
	return true;
}

const char* cFileLoader::GetBufferPtr()
{
	if( mMemUsed && mFile )
	{
		return ((cMemFileToRead*)mFile)->GetBufferPtr();
	}
	return 0;
}

//-----------------------------------------------------------------------------------
cFileLoaderW::cFileLoaderW()
{
	mMemUsed = false;
	mFile = 0;
}

cFileLoaderW::~cFileLoaderW()
{
	Close();
}

bool cFileLoaderW::Open( const cStringW& pathName, bool useMemory )
{
	/// ÀÌ¹Ì ¿­·ÁÀÖ´Â Áö °Ë»ç
	if( mFile )
	{
		assert( 0 && "file is already opened" );
		return false;
	}

	mMemUsed = useMemory;

	if( useMemory )
	{
		mFile = FILESYSTEM->OpenMemFileToReadW( pathName );
	}
	else
	{
		mFile = FILESYSTEM->OpenFileToReadW( pathName );
	}
	return mFile != 0;
}

bool cFileLoaderW::OpenNoPack( const cStringW& pathName, bool useMemory )
{
	if( mFile )
	{
		assert( 0 && "file is already opened" );
		return false;
	}

	mMemUsed = useMemory;

	if( useMemory )
	{
		mFile = FILESYSTEM->OpenMemFileToRead_NoPackW( pathName );
	}
	else
	{
		mFile = FILESYSTEM->OpenFileToRead_NoPackW( pathName );
	}

	return mFile != 0;
}


int cFileLoaderW::Close()
{
	mMemUsed = false;

	if( mFile )
	{
		int ret = mFile->Close();
		delete mFile;
		mFile = 0;
		return ret;
	}
	return 0;
}

unsigned int cFileLoaderW::Read( void* buffer, unsigned int size )
{
	if( mFile )
	{
		return mFile->Read( buffer, size );
	}
	return 0;
}

bool cFileLoaderW::ReadInt( int* pvalue )
{
	if( mFile )
	{
		return mFile->Read( pvalue, sizeof(int) ) == sizeof(int);
	}
	return false;
}

bool cFileLoaderW::ReadUnsignedInt( unsigned int* pvalue )
{
	if( mFile )
	{
		return mFile->Read( pvalue, sizeof(unsigned int) ) == sizeof(unsigned int);
	}
	return false;
}

bool cFileLoaderW::ReadFloat( float* pvalue )
{
	if( mFile )
	{
		return mFile->Read( pvalue, sizeof(float) ) == sizeof(float);
	}
	return false;
}

unsigned int cFileLoaderW::ReadLine( wchar_t* buffer, unsigned int bufferSize )
{
	if( mFile )
	{
		return mFile->ReadLine( buffer, bufferSize );
	}
	return 0;
}

int cFileLoaderW::Seek( unsigned int offset, int origin )
{
	if( mFile )
	{
		return mFile->Seek( offset, origin );
	}
	return -1;
}

unsigned int cFileLoaderW::Tell() const
{
	if( mFile )
	{
		return mFile->Tell();
	}
	return 0;
}

unsigned int cFileLoaderW::GetSize() const
{
	if( mFile )
	{
		return mFile->GetSize();
	}
	return 0;
}

bool cFileLoaderW::IsEnd() const
{
	if( mFile )
	{
		return mFile->IsEnd();
	}
	return true;
}

bool cFileLoaderW::IsEmpty() const
{
	if( mFile )
	{
		return mFile->IsEmpty();
	}
	return true;
}

const wchar_t* cFileLoaderW::GetBufferPtr()
{
	if( mMemUsed && mFile )
	{
		return ((cMemFileToReadW*)mFile)->GetBufferPtr();
	}
	return 0;
}