// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

//-----------------------------------------------------------------------------
// includes
//-----------------------------------------------------------------------------

#include "stdpch.h"
#include "nel/misc/path.h"
#include "nel/misc/sha1.h"
#include "bnp_patch.h"


#define PERSISTENT_TOKEN_FAMILY RyzomTokenFamily


//-----------------------------------------------------------------------------
// Handy utility routines
//-----------------------------------------------------------------------------

void normaliseBnpFileName(std::string& fileName)
{
	BOMB_IF(fileName.empty(),"Can't normalise an empty bnp file name",return);
	if (NLMISC::CFile::getExtension(fileName).empty() && fileName[fileName.size()-1]!='.')
		fileName+=".bnp";
}

void applyDate (const std::string &sFilename, uint32 nDate)
{
	// change the file time
	if(nDate != 0)
	{
//		_utimbuf utb;
//		utb.actime = utb.modtime = nDate;
		NLMISC::CFile::setRWAccess(sFilename);
		NLMISC::CFile::setFileModificationDate(sFilename, nDate);
//		_utime (sFilename.c_str (), &utb);
	}
}



//-----------------------------------------------------------------------------
// class CBNPFileVersion
//-----------------------------------------------------------------------------

CBNPFileVersion::CBNPFileVersion()
{
	_FileTime= 0;
	_FileSize= 0;
	_7ZFileSize=0;
	_PatchSize= 0;
	_VersionNumber= std::numeric_limits<uint32>::max();
}

// setup record contents from a file name and version number
// returns false if the file didn't exist
bool CBNPFileVersion::setup(const std::string &fileName, uint32 versionNumber)
{
	// make sure the file exists...
	BOMB_IF(!NLMISC::CFile::fileExists(fileName),("File not found: "+fileName).c_str(),return false);

	// generate a hash key for the file and store it in a vector of uint32
	CHashKey hashKey= getSHA1(fileName);
	nlassert(hashKey.HashKeyString.size()==20);
	_HashKey.clear();
	for (uint32 i=0;i<5;++i)
		_HashKey.push_back(*(uint32*)&hashKey.HashKeyString[4*i]);

	// get the other file properties
	_FileTime= NLMISC::CFile::getFileModificationDate(fileName);
	_FileSize= NLMISC::CFile::getFileSize(fileName);

	// setup the version number
	_VersionNumber= versionNumber;

	return true;
}

void CBNPFileVersion::setVersionNumber(uint32 nVersionNumber)
{
	_VersionNumber = nVersionNumber;
}

void CBNPFileVersion::set7ZipFileSize(uint32 n7ZFileSize)
{
	_7ZFileSize = n7ZFileSize;
}

void CBNPFileVersion::setPatchSize(uint32 nPatchSize)
{
	_PatchSize = nPatchSize;
}

void CBNPFileVersion::setTimeStamp(uint32 nTimeStamp)
{
	_FileTime = nTimeStamp;
}


// accessors
uint32 CBNPFileVersion::getVersionNumber() const
{
	return _VersionNumber;
}

uint32 CBNPFileVersion::getTimeStamp() const
{
	return _FileTime;
}

uint32 CBNPFileVersion::getFileSize() const
{
	return _FileSize;
}

uint32 CBNPFileVersion::get7ZFileSize() const
{
	return _7ZFileSize;
}

uint32 CBNPFileVersion::getPatchSize() const
{
	return _PatchSize;
}

CHashKey CBNPFileVersion::getHashKey() const
{
	nlassert(_HashKey.size()==5);
	CHashKey hashKey;
	for (uint32 i=0;i<5;++i)
	{
		*(uint32*)&hashKey.HashKeyString[4*i]=_HashKey[i];
	}
	return hashKey;
}

// == operator
bool CBNPFileVersion::operator==(const CBNPFileVersion& other) const
{
	// make sure the file sizes match
	if (_FileSize!=other._FileSize)
		return false;

	// make sure the hash keys match
	if (_HashKey!=other._HashKey)
		return false;

	// we don't compare version numbers or file dates as they're not interesting
	return true;
}

// != operator
bool CBNPFileVersion::operator!=(const CBNPFileVersion& other) const
{
	return !operator==(other);
}


//-----------------------------------------------------------------------------
// Persistent data for CBNPFileVersion
//-----------------------------------------------------------------------------

#define PERSISTENT_CLASS CBNPFileVersion
#define PERSISTENT_DATA \
	PROP(uint32,_VersionNumber) \
	PROP(uint32,_FileSize) \
	PROP(uint32,_7ZFileSize) \
	PROP(uint32,_FileTime) \
	PROP(uint32,_PatchSize) \
	PROP_VECT(uint32,_HashKey)

//#      pragma message( PERSISTENT_GENERATION_MESSAGE )
#include "persistent_data_template.h"

#undef PERSISTENT_CLASS
#undef PERSISTENT_DATA


//-----------------------------------------------------------------------------
// class CBNPFile
//-----------------------------------------------------------------------------

CBNPFile::CBNPFile()
{
	_IsIncremental= true;
}

bool CBNPFile::addVersion(const std::string& bnpDirectory, const std::string& /* refDirectory */, IVersionNumberGenerator& version)
{
	nlinfo("Checking need to add new version to file: %s",_FileName.c_str());

	// perform a quick check to see if the time stamp and file size of the new BNP file match the last version in the index
	std::string fullFileName= bnpDirectory+_FileName;
	if (!NLMISC::CFile::fileExists(fullFileName))
		return false;
	if (!_Versions.empty())
	{
		if ((NLMISC::CFile::getFileSize(fullFileName)==(uint32)_Versions.back().getFileSize())
		&&  (NLMISC::CFile::getFileModificationDate(fullFileName)==(uint32)_Versions.back().getTimeStamp()))
			return true;

		NLMISC::InfoLog->displayNL("File: %s\n size(%d != %d) || time(%d != %d)",
			fullFileName.c_str(),
			NLMISC::CFile::getFileSize(fullFileName),
			(uint32)_Versions.back().getFileSize(),
			NLMISC::CFile::getFileModificationDate(fullFileName),
			(uint32)_Versions.back().getTimeStamp()
			);
	}

	// create a new record for the BNP file that we have on the disk at the moment
	// if no file was found then give up (return)
	CBNPFileVersion fileVersion;
	bool result= fileVersion.setup(fullFileName,~0u);
	if (result==false)
		return false;

	// compare the fileVersion record to the last record in the history.
	// If they don't match then append it
	if (_Versions.empty() || _Versions.back()!=fileVersion)
	{
		// if we haven't yet generated the version number for this version then go for it now
		version.grabVersionNumber();
		fileVersion.setVersionNumber(version.getPackageVersionNumber());

		// make sure that our version numbers are ever increasing... it would be fatal to have an out-of-order version
		if (!_Versions.empty())
			nlassert(_Versions.back().getVersionNumber()<version.getPackageVersionNumber());

		// the file's current checksum doesn't match the previous checksum so add the new version
		nlinfo("- Adding version %05u to file: %s",version.getPackageVersionNumber(),_FileName.c_str());
		_Versions.push_back(fileVersion);

		// copy the file to create a new reference file...
//		NLMISC::CSString refFileName= NLMISC::CSString(refDirectory+_FileName).replace(".",NLMISC::toString("_%05u.",version.getPackageVersionNumber()).c_str());
//		NLMISC::CFile::copyFile(refFileName, fullFileName);
	}
	else
	{
		// the file's size & current checksum match the previous version so just fix the file's timestamp
		nlinfo("Files contents matches previous version but time stamp is different: %s",fullFileName.c_str());
		applyDate(fullFileName,_Versions.back().getTimeStamp());
	}

	// if we're flagged as non-incremental then we don't need a version history
	if (!_IsIncremental && _Versions.size()>1)
	{
		_Versions[0]= _Versions.back();
		_Versions.resize(1);
	}

	return true;
}

uint32 CBNPFile::getLatestVersionNumber(uint32 max) const
{
	if (_Versions.empty())
		return 0;
	uint32 i=0;
	for (i=(uint32)_Versions.size();i--;)
		if (_Versions[i].getVersionNumber()<=max)
			return _Versions[i].getVersionNumber();

	nlinfo("File %s didn't exist before version %d",_FileName.c_str(),max);
	return 0;
}

uint32 CBNPFile::versionCount() const
{
	return (uint32)_Versions.size();
}

const CBNPFileVersion& CBNPFile::getVersion(uint32 idx) const
{
	nlassert(idx<versionCount());
	return _Versions[idx];
}

CBNPFileVersion& CBNPFile::getVersion(uint32 idx)
{
	nlassert(idx<versionCount());
	return _Versions[idx];
}

void CBNPFile::setFileName(const std::string& fileName)
{
	_FileName= fileName;
}

const std::string& CBNPFile::getFileName() const
{
	return _FileName;
}

void CBNPFile::setIncremental(bool value)
{
	_IsIncremental=value;

	// if we're flagged as non-incremental then we don't need a version history
	if (!_IsIncremental && _Versions.size()>1)
	{
		_Versions[0]= _Versions.back();
		_Versions.resize(1);
	}
}

bool CBNPFile::isIncremental()
{
	return _IsIncremental;
}


//-----------------------------------------------------------------------------
// Persistent data for CBNPFile
//-----------------------------------------------------------------------------

#define PERSISTENT_CLASS CBNPFile
#define PERSISTENT_DATA\
	PROP(std::string,_FileName)\
	STRUCT_VECT(_Versions)

//#      pragma message( PERSISTENT_GENERATION_MESSAGE )
#include "persistent_data_template.h"

#undef PERSISTENT_CLASS
#undef PERSISTENT_DATA


//-----------------------------------------------------------------------------
// class CBNPFileSet
//-----------------------------------------------------------------------------

void CBNPFileSet::removeFile(const std::string &filename)
{
	for( uint k = 0; k < _Files.size(); ++k)
	{
		if (_Files[k].getFileName() == filename)
		{
			_Files.erase(_Files.begin() + k);
		}
	}
}


// add a version to the file
// returns highest version number in files after operation
uint32 CBNPFileSet::addVersion(const std::string& bnpDirectory, const std::string& refDirectory, IVersionNumberGenerator& version)
{
	nlinfo("Updating package index...");
	uint32 result=0;

	// add versions to different files
	for (uint32 i=(uint32)_Files.size();i--;)
		if (_Files[i].addVersion(bnpDirectory,refDirectory,version)!=false)
			result= std::max(result,_Files[i].getLatestVersionNumber());

	return result;
}

// look through the referenced files for the highest version number
uint32 CBNPFileSet::getVersionNumber() const
{
	uint32 result=0;

	for (uint32 i=(uint32)_Files.size();i--;)
		result= std::max(result,_Files[i].getLatestVersionNumber());

	return result;
}

void CBNPFileSet::clear()
{
	_Files.clear();
}

uint32 CBNPFileSet::fileCount() const
{
	return (uint32)_Files.size();
}

const CBNPFile& CBNPFileSet::getFile(uint32 idx) const
{
	return const_cast<CBNPFileSet*>(this)->getFile(idx);
}

const CBNPFile* CBNPFileSet::getFileByName(const std::string& fileName) const
{
	return const_cast<CBNPFileSet*>(this)->getFileByName(fileName);
}

CBNPFile& CBNPFileSet::getFile(uint32 idx)
{
	nlassert(idx<fileCount());
	return _Files[idx];
}

CBNPFile* CBNPFileSet::getFileByName(const std::string& fileName)
{
	// look for the file by name
	for (uint32 i=0;i<fileCount();++i)
		if (getFile(i).getFileName()==fileName)
			return &getFile(i);

	// file not found so return NULL
	return NULL;
}

void CBNPFileSet::addFile(const std::string& fileName,bool isIncremental)
{
	// see if the file already exists in the files container
	if (getFileByName(fileName)!=NULL)
	{
		if (!isIncremental)
			getFileByName(fileName)->setIncremental(false);
		return;
	}

	// file is new so need to add it
	std::string s= fileName;
	normaliseBnpFileName(s);
	nlinfo("- adding file: %s",s.c_str());
	_Files.resize(_Files.size()+1);
	_Files.back().setFileName(s);
	_Files.back().setIncremental(isIncremental);
}


//-----------------------------------------------------------------------------
// Persistent data for CBNPFileSet
//-----------------------------------------------------------------------------

#define PERSISTENT_CLASS CBNPFileSet
#define PERSISTENT_DATA\
	STRUCT_VECT(_Files)
//#      pragma message( PERSISTENT_GENERATION_MESSAGE )
#include "persistent_data_template.h"

#undef PERSISTENT_CLASS
#undef PERSISTENT_DATA


//-----------------------------------------------------------------------------
// class CBNPCategory
//-----------------------------------------------------------------------------

CBNPCategory::CBNPCategory()
{
	_IsOptional=true;
	_IsIncremental=true;
	_Hidden=false;
}

bool CBNPCategory::hasFile(const std::string &fileName) const
{
	return std::find(_Files.begin(), _Files.end(), fileName) != _Files.end();
}

const std::string& CBNPCategory::getName() const
{
	return _Name;
}

void CBNPCategory::setName(const std::string& name)
{
	_Name=name;
}

void CBNPCategory::setOptional(bool value)
{
	_IsOptional= value;
}

bool CBNPCategory::isOptional() const
{
	return _IsOptional;
}

void CBNPCategory::setUnpackTo(const std::string &n)
{
	_UnpackTo = n;
}

const std::string &CBNPCategory::getUnpackTo() const
{
	return _UnpackTo;
}

void CBNPCategory::setIncremental(bool value)
{
	_IsIncremental= value;
}

bool CBNPCategory::isIncremental() const
{
	return _IsIncremental;
}

void CBNPCategory::setCatRequired(const std::string &cat)
{
	_CatRequired = cat;
}

const std::string &CBNPCategory::getCatRequired() const
{
	return _CatRequired;
}

void CBNPCategory::setHidden(bool value)
{
	_Hidden = value;
}

bool CBNPCategory::isHidden() const
{
	return _Hidden;
}

uint32 CBNPCategory::fileCount() const
{
	return (uint32)_Files.size();
}

const std::string& CBNPCategory::getFile(uint32 idx) const
{
	nlassert(idx<fileCount());
	return _Files[idx];
}

void CBNPCategory::addFile(const std::string& fileName)
{
	// make sure file doesn't already exist
	for (uint32 i=0;i<_Files.size();++i)
		if (_Files[i]==fileName)
			return;

	// add the new file
	_Files.push_back(fileName);
}


//-----------------------------------------------------------------------------
// Persistent data for CBNPCategory
//-----------------------------------------------------------------------------

#define PERSISTENT_CLASS CBNPCategory
#define PERSISTENT_DATA\
	PROP(std::string,		_Name)\
	LPROP(bool,				_IsOptional,	if(!_IsOptional))\
	LPROP(std::string,		_UnpackTo,		if(!_UnpackTo.empty()))\
	LPROP(bool,				_IsIncremental,	if(!_IsIncremental))\
	LPROP(std::string,		_CatRequired,	if(!_CatRequired.empty()))\
	LPROP(bool,				_Hidden,		if(_Hidden))\
	PROP_VECT(std::string,	_Files)\

//#      pragma message( PERSISTENT_GENERATION_MESSAGE )
#include "persistent_data_template.h"

#undef PERSISTENT_CLASS
#undef PERSISTENT_DATA


//-----------------------------------------------------------------------------
// class CBNPCategorySet
//-----------------------------------------------------------------------------

void CBNPCategorySet::clear()
{
	_Category.clear();
}


const CBNPCategory* CBNPCategorySet::getCategoryFromFile(const std::string &fileName) const
{
	for(std::vector<CBNPCategory>::const_iterator it = _Category.begin(); it != _Category.end(); ++it)
	{
		if (it->hasFile(fileName))
		{
			return &(*it);
		}
	}
	return NULL;
}


void CBNPCategorySet::deleteCategory(uint32 index)
{
	nlassert(index <  _Category.size());
	_Category.erase(_Category.begin() + index);
}


uint32 CBNPCategorySet::fileCount() const
{
	uint32 result=0;
	for (uint32 i=0;i<_Category.size();++i)
		result+=_Category[i].fileCount();
	return result;
}

const std::string& CBNPCategorySet::getFile(uint32 idx) const
{
	uint32 i=0;
	for (;;++i)
	{
		nlassert(i<_Category.size());

		if (_Category[i].fileCount()>idx)
			break;

		idx-=_Category[i].fileCount();
	}

	return _Category[i].getFile(idx);
}

uint32 CBNPCategorySet::categoryCount() const
{
	return (uint32)_Category.size();
}

CBNPCategory& CBNPCategorySet::getCategory(uint32 idx)
{
	nlassert(idx<categoryCount());
	return _Category[idx];
}

const CBNPCategory& CBNPCategorySet::getCategory(uint32 idx) const
{
	return const_cast<CBNPCategorySet*>(this)->getCategory(idx);
}

const CBNPCategory* CBNPCategorySet::getCategory(const std::string& categoryName) const
{
	// look for a category with matching name
	for (uint32 i=0;i<categoryCount();++i)
		if (getCategory(i).getName()==categoryName)
			return &(getCategory(i));
	return NULL;
}

// check whether a named category exists and add a new one if need be
CBNPCategory* CBNPCategorySet::getCategory(const std::string& categoryName, bool addIfNotExist)
{
	// look for a category with matching name
	for (uint32 i=0;i<categoryCount();++i)
		if (getCategory(i).getName()==categoryName)
			return &(getCategory(i));

	// the category wasn't found so return NULL if need be
	if (!addIfNotExist)
		return NULL;

	// create a new category if need be
	_Category.resize(_Category.size()+1);
	_Category.back().setName(categoryName);
	nlinfo("- New category created: %s",categoryName.c_str());

	return &_Category.back();
}

void CBNPCategorySet::addFile(const std::string& categoryName,const std::string& fileName)
{
	// make sure the category exists
	CBNPCategory* theCategory= getCategory(categoryName,true);

	// look to see if the file already exists in the category
	for (uint32 i=0;i<theCategory->fileCount();++i)
		if (theCategory->getFile(i)==fileName)
			return;

	// the file doesn't already exist so add it
	theCategory->addFile(fileName);
	nlinfo("- File added to category %s::%s",categoryName.c_str(),fileName.c_str());
}

bool CBNPCategorySet::isFileIncremental(const std::string& fileName) const
{
	// for each category
	for (uint32 i=0;i<categoryCount();++i)
	{
		const CBNPCategory& theCategory= getCategory(i);

		// if the category is incremental then skip it
		if (theCategory.isIncremental())
			continue;

		// if the file exists in this category then return 'false' meaning non-incremental
		for (uint32 i=0;i<theCategory.fileCount();++i)
			if (theCategory.getFile(i)==fileName)
				return false;
	}

	// the file wasn't found in a non-incremental category so it must be incremental
	return true;
}


//-----------------------------------------------------------------------------
// Persistent data for CBNPCategorySet
//-----------------------------------------------------------------------------

#define PERSISTENT_CLASS CBNPCategorySet
#define PERSISTENT_DATA\
	STRUCT_VECT(_Category)
//#      pragma message( PERSISTENT_GENERATION_MESSAGE )
#include "persistent_data_template.h"

#undef PERSISTENT_CLASS
#undef PERSISTENT_DATA


//-----------------------------------------------------------------------------
// class CProductDescriptionForClient
//-----------------------------------------------------------------------------

void CProductDescriptionForClient::clear()
{
	_Categories.clear();
	_Files.clear();
}

void CProductDescriptionForClient::setCategories(CPersistentDataRecord &pdr)
{
	_Categories.clear();
	_Categories.apply(pdr);
}

void CProductDescriptionForClient::setFiles(CPersistentDataRecord &pdr)
{
	_Files.clear();
	_Files.apply(pdr);
}

void CProductDescriptionForClient::getCategories(CPersistentDataRecord &pdr)
{
	pdr.clear();
	_Categories.store(pdr);
}

void CProductDescriptionForClient::getFiles(CPersistentDataRecord &pdr)
{
	pdr.clear();
	_Files.store(pdr);
}

bool CProductDescriptionForClient::load(const std::string& filePath)
{
	// read new contents from input file
	if (!NLMISC::CFile::fileExists(filePath))
		return false;

	clear();
	static CPersistentDataRecord pdr;
	pdr.clear();
	pdr.readFromBinFile(filePath);
	apply(pdr);

	return true;
}

void CProductDescriptionForClient::serial(NLMISC::IStream &f)
{
	static CPersistentDataRecord pdr("RyzomTokenFamily");
	pdr.clear();
	if (f.isReading())
	{
		bool ok = pdr.fromBuffer(f);
		if (ok)
		{
			apply(pdr);
		}
		else
		{
			throw NLMISC::Exception("Can't retrieve file desc");
		}
	}
	else
	{
		store(pdr);
		pdr.toStream(f);
	}
}


//-----------------------------------------------------------------------------
// Persistent data for CProductDescriptionForClient
//-----------------------------------------------------------------------------

#define PERSISTENT_CLASS CProductDescriptionForClient
#define PERSISTENT_DATA\
	STRUCT(_Files)\
	STRUCT(_Categories)

//#      pragma message( PERSISTENT_GENERATION_MESSAGE )
#include "persistent_data_template.h"

#undef PERSISTENT_CLASS
#undef PERSISTENT_DATA


//================================================================================================
//================================================================================================
//================================================================================================
//================================================================================================

//#if 0
//
////-----------------------------------------------------------------------------
//// class CBNPPatchDescription
////-----------------------------------------------------------------------------
//// a little object used to describe patches in CBNPUnpatcher class
//
//std::string CBNPPatchDescription::getPatchFileName() const
//{
//	return NLMISC::CFile::getFilenameWithoutExtension(getTargetFileName())+NLMISC::toString("_%05d.patch",getVersion());
//}
//
//
////-----------------------------------------------------------------------------
//// class CBNPUnpatcher
////-----------------------------------------------------------------------------
//
////-----------------------------------------------------------------------------
//// initialisation
//
//CBNPUnpatcher::CBNPUnpatcher(const std::string& productName,uint32 version,const std::string& appRootDirectory,const std::string& patchDirectory)
//{
//	_AppRootDirectory=	NLMISC::CPath::standardizePath(appRootDirectory,true);
//	_PatchDirectory=	NLMISC::CPath::standardizePath(patchDirectory,true);
//	_ProductName=		productName;
//	_Version=			version;
//}
//
//bool CBNPUnpatcher::isIndexUpToDate()
//{
//	return (_Files.getVersionNumber()==_Version);
//}
//
//CBNPPatchDescription CBNPUnpatcher::getIndexFileDownloadDescription()
//{
//	return CBNPPatchDescription(productName+"_patch_index",_Version,0,!isIndexUpToDate())
//}
//
//
////-----------------------------------------------------------------------------
//// accessors for directories
//
//std::string getRootDirectory() const
//{
//	return _AppRootDirectory;
//}
//
//std::string getDataDirectory() const
//{
//	return _AppRootDirectory+"data/";
//}
//
//std::string getPatchDirectory() const
//{
//	return _PatchDirectory;
//}
//
//
////-----------------------------------------------------------------------------
//// accessors for retrieving info on required patches
//
//bool CBNPUnpatcher::isUpToDate()
//{
//	return (isIndexUpToDate() && !isPatchMandatory() && !isPatchOptional())
//}
//
//bool CBNPUnpatcher::_isPatch(bool isBySelectionFlag,bool isOptionalFlag=false)
//{
//	nlassert(isIndexUpToDate()==true);
//
//	// scan all categories for a mandatoy category with non-up-to-date files
//	for (uint32 i=0;i<_Categories.categoryCount();++i)
//	{
//		CBNPCategory* theCategory= _Categories.getCategory(i);
//
//		// decide whether or not to skip this category
//		if (isBySelectionFlag==true)
//		{
//			if (theCategory->isOptional() &&
//				_SelectedCategories.find(theCategory->getName())==_SelectedCategories.end()))
//				continue;
//		}
//		else
//		{
//			if (theCategory->isOptional()!=isOptionalFlag)
//				continue;
//		}
//
//		// if one of the files is not up to date then we return 'true' as we need to patch
//		for (uint32 j=0;j<theCategory->fileCount();++j)
//			if (!isFileUpToDate(theCategory->getFile(j)))
//				return true;
//	}
//
//	return false;
//}
//
//bool CBNPUnpatcher::isPatchMandatory()
//{
//	return _isPatch(false,false);
//}
//
//bool CBNPUnpatcher::isPatchOptional()
//{
//	return _isPatch(false,true);
//}
//
//bool CBNPUnpatcher::isPatchRequired()
//{
//	return _isPatch(true);
//}
//
//// return true if it's necessary to download patches for the selected options
//bool CBNPUnpatcher::isDownloadRequired()
//{
//	if (!isPatchRequired())
//		return false;
//
//	std::vector<CBNPPatchDescription> hold;
//	getDownloadPatches(hold);
//	return !hold.empty();
//}
//
//// return true if it's necessary to download the next patch that needs to be applied (in order)
//bool CBNPUnpatcher::isNextPatchDownloadRequired()
//{
//	if (!isPatchRequired())
//		return false;
//
//	return getNextPatch().getRequiresDownload();
//}
//
//
////-----------------------------------------------------------------------------
//// crunching routines
//
//// scan the directories for files - identifies the set of required patches
//// and also the set of these patches that is missing from the patch directory
//void CBNPUnpatcher::scanForFiles()
//{
//	std::vector<std::string> patchFiles;
//	std::vector<std::string> patchFiles;
//	std::vector<std::string> dataFiles;
//
//	// get the list of files in the patch directory
//	NLMISC::CPath::getPathContent(getPatchDirectory(),false,false,true,patchFiles);
//
//	// get the list of files in the data directory
//	NLMISC::CPath::getPathContent(getDataDirectory(),false,false,true,dataFiles);
//
//	for (uint32 i=0;i<_Categories.fileCount();++i)
//	{
//		_Categories.getFile()
//		result.push_back(_Categories.getCategory(i).getName());
//	}
//	xxx
//}
//
//// apply the mandatory and selected optional patches
//// nlerror if isDownloadRequired() is not false
//void CBNPUnpatcher::applyPatches()
//{
//	nlassert(isIndexUpToDate()==true);
//	nlassert(!isDownloadRequired());
//	xxx
//}
//
//// apply the next patch (in order)
//// nlerror if isNextPatchDownloadRequired() is not false
//void CBNPUnpatcher::applyNextPatch()
//{
//	// note that if the index isn't up to date then it is classed as the next patch
//	nlassert(!isNextPatchDownloadRequired());
//	xxx
//}
//
//
////-----------------------------------------------------------------------------
//// managing the set of selected optional patch categories
//
//// get the names of all optional categories
//void CBNPUnpatcher::getAllOptionalCategories(std::vector<std::string>& result)
//{
//	nlassert(isIndexUpToDate()==true);
//
//	result.clear();
//	for (uint32 i=0;i<_Categories.categoryCount();++i)
//	{
//		result.push_back(_Categories.getCategory(i).getName());
//	}
//}
//
//// get the names of the optional categories that require patching
//void CBNPUnpatcher::getPatchableOptionalCategories(std::vector<std::string>& result)
//{
//	nlassert(isIndexUpToDate()==true);
//
//	result.clear();
//	for (uint32 i=0;i<_Categories.categoryCount();++i)
//	{
//		CBNPCategory* theCategory= _Categories.getCategory(i);
//		uint32 j;
//
//		// if one of the files is not up to date then we return 'true' as we need to patch
//		for (j=0;j<theCategory->fileCount();++j)
//			if (!isFileUpToDate(theCategory->getFile(j)))
//				break;
//
//		// if we broke out before the end of the for loop then we need to add this category
//		if (j<theCategory->fileCount())
//			result.push_back(_Categories.getCategory(i).getName());
//	}
//}
//
//// select or unselect an optional package
//void CBNPUnpatcher::setOptionalCategorySelectFlag(const std::string& categoryName, bool value)
//{
//	nlassert(isIndexUpToDate()==true);
//	_SelectedCategories.insert(categoryName);
//}
//
//// select or unselect all optional packages
//void CBNPUnpatcher::setAllOptionalCategorySelectFlags(bool value)
//{
//	nlassert(isIndexUpToDate()==true);
//
//	_SelectedCategories.clear();
//	for (uint32 i=0;i<_Categories.categoryCount();++i)
//	{
//		_SelectedCategories.insert(_Categories.getCategory(i).getName());
//	}
//}
//
//
////-----------------------------------------------------------------------------
//// getting lists of applicable patches
//
//// get the ordered list of mandatory + optional patches that need to be applied to update selected packages
//void CBNPUnpatcher::getSelectedPatches(std::vector<CBNPPatchDescription>& result)
//{
//	nlassert(isIndexUpToDate()==true);
//
//	std::vector<CBNPPatchDescription> mandatoryPatches;
//	getMandatoryPatches(mandatoryPatches);
//
//	std::vector<CBNPPatchDescription> optionalPatches;
//	getSelectedOptionalPatches(optionalPatches);
//
//	result=	mandatoryPatches+ optionalPatches;
//}
//
//// get the ordered list of optional patches that need to be applied to update selected packages
//void CBNPUnpatcher::getSelectedOptionalPatches(std::vector<CBNPPatchDescription>& result)
//{
//	nlassert(isIndexUpToDate()==true);
//	xxx
//}
//
//// get the ordered list of patches that need to be applied for a minimum update
//void CBNPUnpatcher::getMandatoryPatches(std::vector<CBNPPatchDescription>& result)
//{
//	nlassert(isIndexUpToDate()==true);
//	xxx
//}
//
//// get an ordered list of the patches that need to be applied for a full update
//void CBNPUnpatcher::getAllPatches(std::vector<CBNPPatchDescription>& result)
//{
//	// store the selected category set in temporary variable
//	std::set<std::string> selectedCategories= _SelectedCategories;
//
//	// select all of the categories and delegate to getSelectedPatches()
//	setAllOptionalCategorySelectFlags();
//	getSelectedPatches(result);
//
//	// restore the _SelectedCategories set from temp variable
//	_SelectedCategories= selectedCategories;
//}
//
//// get the name of the next patch that needs to be applied (for progress display)
//const std::string& CBNPUnpatcher::getNextPatchName()
//{
//	CBNPPatchDescription patch= getNextPatch();
//	return patch.getTargetFileName()+NLMISC::toString(":%d",patch.getVersion());
//}
//
//// get the patch description for the next patch to apply
//CBNPPatchDescription CBNPUnpatcher::getNextPatch()
//{
//	// make sure that index is up to date and patching is required
//	nlassert(isIndexUpToDate());
//	nlassert(isPatchRequired());
//
//	// treat the case of !uptodate() here and get the index file as the next patch
//	if (!isIndexUpToDate())
//	{
//		return getIndexFileDownloadDescription();
//	}
//
//	for (uint32 i=0;i<_Categories.categoryCount();++i)
//	{
//		CBNPCategory* theCategory= _Categories.getCategory(i);
//		uint32 j;
//
//		// if one of the files is not up to date then we return 'true' as we need to patch
//		for (j=0;j<theCategory->fileCount();++j)
//			if (!isFileUpToDate(theCategory->getFile(j)))
//				break;
//
//		// if we broke out before the end of the for loop then we need to add this category
//		if (j<theCategory->fileCount())
//			result.push_back(_Categories.getCategory(i).getName());
//	}
//
//	xxx
//}
//
//// get the list of patches that need to be downloaded
//void CBNPUnpatcher::getSelectedDownloadPatches(std::vector<CBNPPatchDescription>& result)
//{
//	nlassert(isIndexUpToDate()==true);
//	xxx
//}
//
//// get the list of patches that need to be downloaded
//void CBNPUnpatcher::getAllDownloadPatches(std::vector<CBNPPatchDescription>& result)
//{
//	// store the selected category set in temporary variable
//	std::set<std::string> selectedCategories= _SelectedCategories;
//
//	// select all of the categories and delegate to getSelectedDownloadPatches()
//	setAllOptionalCategorySelectFlags();
//	getSelectedDownloadPatches(result);
//
//	// restore the _SelectedCategories set from temp variable
//	_SelectedCategories= selectedCategories;
//}
//
//
////-----------------------------------------------------------------------------
//
//
//#endif