SugarAppInfoType* app;
	SugarAppInfoType* appHelper = 0;
	
	app = GetAppInfoPtr(CurrentDB);
	
	DmWrite(app, (UInt32)&appHelper -> rawWordCount, &newWordCount, sizeof(newWordCount));
	
	MemPtrUnlock(app);
}

void IncrementRawWordCount(){
	SugarAppInfoType* app;
	SugarAppInfoType* appHelper = 0;
	UInt16 count;
	
	app = GetAppInfoPtr(CurrentDB);
	count = app -> rawWordCount;
	count++;
	
	DmWrite(app, (UInt32)&appHelper -> rawWordCount, &count, sizeof(count));
	
	MemPtrUnlock(app);
}


void DecrementRawWordCount(){
	SugarAppInfoType* app;
	SugarAppInfoType* appHelper = 0;
	UInt16 count;
	
	app = GetAppInfoPtr(CurrentDB);
	count = app -> rawWordCount;
	if (count > 0) count--;
	
	DmWrite(app, (UInt32)&appHelper -> rawWordCount, &count, sizeof(count));
	
	MemPtrUnlock(app);
}
//*******************************************************************
//
//	Database operation
//	1.CreateWordDB(char* name);
//	2.RenameWordDB(char* name);
//	3.Boolean DeleteWordDB(UInt16 cardNo, LocalID dbID);
//
//*******************************************************************

//	create database
Boolean CreateWordDB(char* name){
	
	LocalID dbID;
	DmOpenRef db;
	UInt16 cardNo = 0; //internal mem
	UInt16 i;
	
	Err err = DmCreateDatabase(cardNo, name, appFileCreator, appVocabularyDB, false); //not resource db
	
	//popup error info
	if (err){ 
		ErrAlert(err);
		return false;
	}
	
	dbID = DmFindDatabase(cardNo, name);
	db = DmOpenDatabase(cardNo, dbID, dmModeReadWrite);
	
	//initialize app info
	err = SugarDBAppInfoInit(db);
	
	if (err) {
		ErrAlert(err);
		DmCloseDatabase(db);
		DeleteWordDB(cardNo, dbID);
		return false;
	}
	
	for (i = TestingRecordIndex; i<HeaderIndexCounts; i++)
		CreateHeaderRecord(db, i);
	
	DmCloseDatabase(db);
	return true;
}

// 	rename database
Boolean RenameWordDB(char* originalName){
	return false;
}

//	delete databaase
Boolean DeleteWordDB(UInt16 cardNo, LocalID dbID){
	Err error;
	DmOpenRef db;
	UInt16 num, j;
	UInt32 progress, newProgress;
	Char message[20] = "Deleting....";
	
	db = DmOpenDatabase(cardNo, dbID, dmModeReadWrite);
	num = DmNumRecords(db);
	
	progress = 0;
	ProgressPie(progress, message);
		
	for (j = 0; j < num; j++){
		DmDeleteRecord(db, num - 1 - j);
		
		newProgress = (j + 1) * ProgressFull / num;
		
		if (newProgress != progress){	
			progress = newProgress;
			ProgressPie(progress, message);
		}
	}
	
	DmCloseDatabase(db);
	
	error = DmDeleteDatabase(cardNo, dbID);	
	if (error) return false;
		
	return true;
}
//*******************************************************************
//
//	header record operation and maintenance
//
//	1.CreateHeaderRecord(DmOpenRef db, HeaderIndex headerIndex);
//	2.ClearHeaderRecord(DmOpenRef db, HeaderIndex headerIndex);
//	3.GetHeaderItemNumber(DmOpenRef db, HeaderIndex headerIndex);
//	4.GetHeaderItem(DmOpenRef db, HeaderIndex headerIndex, HeaderItem* ItemP, UInt16 index);
//	5.AddHeaderItem(DmOpenRef db, HeaderIndex headerIndex, HeaderItem* ItemP);
//	6.AddHeaderItemByDBIndex(DmOpenRef db, HeaderIndex headerIndex, UInt16 dbIndex);
//
//	7.RemoveHeaderItem(DmOpenRef db, HeaderIndex headerIndex, UInt16 index);
//	8.RemoveHeaderItemByID(DmOpenRef db, HeaderIndex headerIndex, UInt32 uniqueID);
//	9.RemoveHeaderItemByDBIndex(DmOpenRef db, HeaderIndex headerIndex, UInt16 dbIndex);
//	10.MoveHeaderItem(DmOpenRef db, HeaderIndex headerIndex, UInt16 index);
//
//	11.RebuildLearningQueue(DmOpenRef db);
//	12.UpdateTestingQueue();
//
//*******************************************************************


//This function create header record at certain index, so be sure to 
//create all header records in sequence when creating database, 
//wrong order may cause potential chaos
Boolean CreateHeaderRecord(DmOpenRef db, HeaderIndex headerIndex){

	MemHandle recordH;
	MemPtr recordP;
	HeaderRecord hRecord;	
	Err error;
	
	//prepare header flag
	hRecord.header.allBits = 0;
	SetBitMacro(hRecord.header.allBits, HeaderFlag);
	switch(headerIndex){
		case LearningRecordIndex:
			SetBitMacro(hRecord.header.allBits, LearningQFlag);
			break;
		case TestingRecordIndex:
			SetBitMacro(hRecord.header.allBits, TestingQFlag);
			break;
		case LearningChoiceBuffer:
			SetBitMacro(hRecord.header.allBits, LearningBFlag);
			break;
		case TestingChoiceBuffer:
			SetBitMacro(hRecord.header.allBits, TestingBFlag);
			break;
	}
	
	//set item number to 0
	hRecord.itemNumbers = 0;
	
	//allocate memory for an empty header record
	recordH = DmNewHandle(db, sizeof(HeaderRecord)); 
	
	if (recordH == NULL) return false;
	
	recordP = MemHandleLock(recordH); //lock once
	DmWrite(recordP, 0, &hRecord, sizeof(hRecord));
	MemPtrUnlock(recordP); //unlock once
		
	error = DmAttachRecord(db, &headerIndex, recordH, NULL);
	
	if (error) {
		MemHandleFree(recordH);	//release the memory resources if failed
		return false;
	}
	
	return true;
}

//clear header record, used for rebuild header record, 
//this function can be combined with create header record.
Boolean ClearHeaderRecord(DmOpenRef db, HeaderIndex headerIndex){

	MemHandle recordH, oldH;
	MemPtr recordP;
	HeaderRecord hRecord;	
	Err error;
	
	//prepare header flag
	hRecord.header.allBits = 0;
	SetBitMacro(hRecord.header.allBits, HeaderFlag);
	switch(headerIndex){
		case LearningRecordIndex:
			SetBitMacro(hRecord.header.allBits, LearningQFlag);
			break;
		case TestingRecordIndex:
			SetBitMacro(hRecord.header.allBits, TestingQFlag);
			break;
	}
	
	//set item number to 0
	hRecord.itemNumbers = 0;
	
	//allocate memory for an empty header record
	recordH = DmNewHandle(db, sizeof(HeaderRecord)); 
	
	if (recordH == NULL) return false;
	
	recordP = MemHandleLock(recordH); //lock once
	DmWrite(recordP, 0, &hRecord, sizeof(hRecord));
	MemPtrUnlock(recordP); //unlock once
		
	error = DmAttachRecord(db, &headerIndex, recordH, &oldH);
	
	if (error) {
		MemHandleFree(recordH);	//release the memory resources if failed
		return false;
	}
	
	MemHandleFree(oldH);
	
	return true;
}


//Get Item numbers in learning or testing queue
UInt16 GetHeaderItemNumber(DmOpenRef db, HeaderIndex headerIndex){
	
	UInt16 number;
	MemHandle recordH;
	HeaderRecord* recordP;
	
	recordH = DmQueryRecord(db, headerIndex); //error not handled 
	
	recordP = (HeaderRecord*)MemHandleLock(recordH);
	number = recordP -> itemNumbers;
	MemPtrUnlock(recordP);
	
	return number;
}

//Get learning or testing item
Boolean GetHeaderItem(DmOpenRef db, HeaderIndex headerIndex, HeaderItem* ItemP, UInt16 index){

	MemHandle recordH;
	HeaderRecordHelper* recordP;
	HeaderItem* p;
	
	recordH = DmQueryRecord(db, headerIndex);
	if (recordH == NULL) return false;
	
	recordP = (HeaderRecordHelper*)MemHandleLock(recordH);
	
	if (index > recordP -> itemNumbers - 1) return false;
	
	//point to the first item
	p = &recordP->firstItem;
	p += index;
	
	*ItemP = *p;
	
	MemPtrUnlock(recordP);
	
	return true;
}

//Add header item to tail
Boolean AddHeaderItem(DmOpenRef db, HeaderIndex headerIndex, HeaderItem* ItemP){

	MemHandle recordH;
	MemPtr recordP;
	UInt16 number, size, newSize;
	
	number = GetHeaderItemNumber(db, headerIndex);
	size = sizeof(HeaderRecord) + number * sizeof(HeaderItem);
	newSize = size + sizeof(HeaderItem);
	
	recordH = DmResizeRecord(db, headerIndex, newSize);
	if (recordH == NULL) return false;
	
	recordP = MemHandleLock(recordH);
	
	DmWrite(recordP, size, ItemP, sizeof(*ItemP));
	
	number++;
	DmWrite(recordP, sizeof(Header), &number, sizeof(number));
	
	MemHandleUnlock(recordH);
	
	return true;
}
	
	
	
	/*old function, using DmAttach method

	MemHandle recordH, oldH;
	MemPtr srcP, destP;
	HeaderRecordHelper* p = 0;
	UInt16 number, size, newSize, index;
	Err error;

	//calculate newsize
	number = GetHeaderItemNumber(db, headerIndex);
	size = sizeof(HeaderRecord) + number * sizeof(HeaderItem);
	newSize = size + sizeof(HeaderItem);
	
	//get original learning record
	srcP = MemHandleLock(DmQueryRecord(db, headerIndex)); //source locked
	
	//allocate new record			
	recordH = DmNewHandle(db, newSize);
	if (recordH == NULL) return false;
	
	destP = MemHandleLock(recordH);	//dest locked
	
	//copy original data
	DmWrite(destP, 0, srcP, size);

	//write new item
	DmWrite(destP, ((UInt32)&p->firstItem) + number * sizeof(HeaderItem), ItemP, sizeof(HeaderItem));
	
	//write new number
	number++;
	DmWrite(destP, (UInt32)&p->itemNumbers, &number, sizeof(number));
		
	//unlock src pointer
	MemPtrUnlock(srcP); //src unlocked
	
	//attach new record
	index = headerIndex;
	error = DmAttachRecord(db, &index, recordH, &oldH);
	
	//unlock dest pointer
	MemPtrUnlock(destP);
	
	if (error) {
		MemHandleFree(recordH);
		return false;
	}
	//release orphan data
	MemHandleFree(oldH);
	
	return true;
}*/



//	add header item by record index
Boolean AddHeaderItemByDBIndex(DmOpenRef db, HeaderIndex headerIndex, UInt16 dbIndex){
	
	HeaderItem item;
	
	DmRecordInfo (db, dbIndex, NULL, &item, NULL);
	return AddHeaderItem(db, headerIndex, &item);
	
}

Boolean ShuffleHeaderItem(DmOpenRef db, HeaderIndex headerIndex){
	
	MemHandle recordH;
	HeaderRecordHelper* recordP;
	HeaderItem item, *itemp1, *itemp2;
	UInt16 number, j1, j2, i, sizeofHeaderRecord = sizeof(HeaderRecord), sizeofHeaderItem = sizeof(HeaderItem);
	Err error;
	
	number = GetHeaderItemNumber(db, headerIndex);
	
	if (number == 0) return true;
	
	recordH = DmQueryRecord(db, headerIndex);
	if (recordH == NULL) return false;
	
	recordP = MemHandleLock(recordH);
	
	i = number;
	while (i > 0){
		j1 = SysRandom(0);
		j1 = (((UInt32)j1 * number) - 1) / sysRandomMax;
		j2 = SysRandom(0);
		j2 = (((UInt32)j2 * number) - 1) / sysRandomMax;
		
		if (j1 != j2){
		
			itemp1 = &recordP->firstItem;
			itemp1 += j1;
			
			itemp2 = &recordP->firstItem;
			itemp2 += j2;

			//save item 1
			item = *itemp1;			
			
			error = DmWriteCheck(recordP, sizeofHeaderRecord + j1 * sizeofHeaderItem, sizeofHeaderItem);
			if (error) {
				ErrAlert(error);
			}
			DmWrite(recordP, sizeofHeaderRecord + j1 * sizeofHeaderItem, itemp2, sizeofHeaderItem);
			
			error = DmWriteCheck(recordP, sizeofHeaderRecord + j2 * sizeofHeaderItem, sizeofHeaderItem);
			if (error) {
				ErrAlert(error);
			}
			DmWrite(recordP, sizeofHeaderRecord + j2 * sizeofHeaderItem, &item, sizeofHeaderItem);
		}
		
		i--;
	}
	
	MemHandleUnlock(recordH);
	
	return true;
}

/*
Boolean ShuffleHeaderItem(DmOpenRef db, HeaderIndex headerIndex){

	UInt16 number, size, i, random;
	MemHandle recordH, oldH;
	MemPtr srcP, destP;
	HeaderItem item;
	Err error;

	i = 0;
	number = GetHeaderItemNumber(db, headerIndex);
	size = sizeof(HeaderRecord) + number * sizeof(HeaderItem);
	
	recordH = DmNewHandle(db, size);
	if (recordH == NULL) return false;
	destP = MemHandleLock(recordH);

	//	copy header	
	srcP = MemHandleLock(DmQueryRecord(db, headerIndex));
	DmWrite(destP, 0, srcP, sizeof(HeaderRecord));
	MemPtrUnlock(srcP);
		
	while (number > 0){
		
		random = SysRandom(0);
		random = ((UInt32)random * (number - 1)) / sysRandomMax;
		
		GetHeaderItem(db, headerIndex, &item, random);
		
		DmWrite(destP, sizeof(HeaderRecord) + i * sizeof(HeaderItem), &item, sizeof(item));