/*
 * pHatt - PalmOS(TM) Hattrick (http://www.hattrick.org) Manager Assistant
 *
 * db.c - functions related to the palm-db
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
*/

#include "phat.h"

static DmOpenRef	DB;

static void initDB() {

	struct positionWeight w;

	prefs.currency = Country_England;
	prefs.isalarm = 0;
	prefs.positionPage = 0;
	prefs.selectedPlayer = 0;
	prefs.selectedScreen = 0;
	prefs.selectedPositionPage = PositionScreen;
	prefs.selectedEditPage = PlayerEditScreen;
	prefs.arenaPessimistic = 20;
	prefs.arenaNormal = 25;
	prefs.arenaOptimistic = 30;
	prefs.supporters = 500;
	prefs.arenaTerraces = 62;
	prefs.arenaBasic = 25;
	prefs.arenaRoof = 10;
	prefs.arenaVIP = 3;
	prefs.arenaHasTerraces = 7000;
	prefs.arenaHasBasic = 2000;
	prefs.arenaHasRoof = 0;
	prefs.arenaHasVIP = 0;
	prefs.orderby = PrefsOrderName;

	w.form		= 55;
	w.experience	= 50;
	w.stamina	= 0;
	w.goalie	= 100;
	w.playmaking	= 0;
	w.passing	= 0;
	w.winging	= 0;
	w.defending	= 0;
	w.scoring	= 0;
	w.setting	= 0;
	w.leading	= 0;
	setPositionWeight(Pos_Keeper, w);

	w.stamina	= 10;
	w.playmaking	= 17;
	w.goalie	= 0;
	w.defending	= 73;
	setPositionWeight(Pos_DefOff, w);

	w.playmaking	= 3;
	w.defending	= 87;
	setPositionWeight(Pos_Def, w);

	w.winging	= 12;
	w.defending	= 75;
	setPositionWeight(Pos_DefWing, w);

	w.stamina	= 0;
	w.playmaking	= 0;
	w.winging	= 33;
	w.defending	= 67;
	setPositionWeight(Pos_WBack, w);
	
	w.winging	= 20;
	w.defending	= 80;
	setPositionWeight(Pos_WBackDef, w);

	w.playmaking	= 5;
	w.winging	= 40;
	w.defending	= 55;
	setPositionWeight(Pos_WBackOff, w);

	w.stamina	= 10;
	w.playmaking	= 0;
	w.winging	= 15;
	w.defending	= 75;
	setPositionWeight(Pos_WBackMid, w);

	w.stamina 	= 20;
	w.winging	= 0;
	w.playmaking	= 50;
	w.passing	= 15;
	w.defending	= 15;
	setPositionWeight(Pos_Mid, w);

	w.passing	= 25;
	w.defending	= 5;
	setPositionWeight(Pos_MidOff, w);

	w.passing	= 12;
	w.defending	= 18;
	setPositionWeight(Pos_MidDef, w);

	w.winging	= 15;
	w.playmaking	= 35;
	w.passing	= 15;
	w.defending	= 15;
	setPositionWeight(Pos_MidWing, w);

	w.stamina	= 7;
	w.playmaking	= 26;
	w.winging	= 39;
	w.defending	= 13;
	setPositionWeight(Pos_Wing, w);

	w.winging	= 29;
	w.defending	= 23;
	setPositionWeight(Pos_WingDef, w);

	w.playmaking	= 34;
	w.winging	= 31;
	w.defending	= 13;
	setPositionWeight(Pos_WingMid, w);

	w.stamina 	= 12;
	w.playmaking	= 20;
	w.winging	= 60;
	w.passing	= 6;
	w.defending	= 2;
	setPositionWeight(Pos_WingOff, w);

	w.stamina	= 10;
	w.playmaking	= 3;
	w.winging	= 0;
	w.scoring	= 58;
	w.passing	= 29;
	w.defending	= 0;
	setPositionWeight(Pos_For, w);

	w.playmaking	= 13;
	w.scoring	= 45;
	w.passing	= 32;
	setPositionWeight(Pos_ForDef, w);

	w.playmaking 	= 0;
	w.scoring	= 0;
	w.passing	= 0;
	w.stamina	= 0;
	w.leading	= 100;
	w.experience	= -50;
	setPositionWeight(Pos_Captain, w);

	w.leading	= 0;
	w.setting	= 70;
	setPositionWeight(Pos_Setter,w );

}

static Int16 ReadDB(UInt16 *RecordNum, void *Data, UInt32 DataSize) {

	Int8 result = 0;
	MemHandle HandlePtr;
	void	*DataPtr;

	HandlePtr = DmGetRecord(DB, *RecordNum );
	if ( ! HandlePtr ) {
		( *RecordNum )++;
		return -1;
	}

	DataPtr = MemHandleLock(HandlePtr);
	if ( DataPtr )
		result = MemMove (Data, DataPtr, DataSize);
	else
		result = -1;

	MemHandleUnlock(HandlePtr);
	DmReleaseRecord(DB, *RecordNum, false);
	( *RecordNum )++;

	return result;
}

static Int16 WriteDB(UInt16 *RecordNum, void *Data, UInt32 DataSize) {

	Int8 result = 0;
	MemHandle RecHandle;
	void	*DataPtr;

	RecHandle = DmNewRecord(DB, RecordNum, DataSize);
	if ( RecHandle ) {
		DataPtr = MemHandleLock(RecHandle);
		if ( DataPtr ) 
			result = DmWrite(DataPtr, 0, Data, DataSize);
		else
			result = -1;

		MemHandleUnlock(RecHandle);
	}
	else
		result = -1;

	DmReleaseRecord(DB, *RecordNum, true);
	( *RecordNum )++;

	return result;
}

void DbSetPlayer(UInt16 p) {

	DmOpenRef db;
	MemHandle HandlePtr;
	void *DataPtr;
	struct preferences pref;

	db = DmOpenDatabaseByTypeCreator('Data', 'pHat', dmModeReadWrite);
	HandlePtr = DmGetRecord(db, 1);
	DataPtr = MemHandleLock(HandlePtr);
	MemMove(&pref, DataPtr, sizeof(struct preferences));
	pref.selectedPlayer = p;
	pref.selectedScreen = PlayerScreen;
	pref.isalarm = 1;
	DmWrite(DataPtr, 0, &pref, sizeof(struct preferences));
	MemHandleUnlock(HandlePtr);
	DmReleaseRecord(db, 1, false);
	DmCloseDatabase(db);
}

Err OpenPlayerDatabase() {

	Err	err;
	UInt16	recnum = 0;
	UInt16	version;
	UInt16	numrecords;
	UInt8	i;
	struct player	*p;
	struct player	*last;

	if ( ! ( DB = DmOpenDatabaseByTypeCreator('Data', 'pHat', dmModeReadOnly))){
		if (( err = DmCreateDatabase(0, "pHattDB", 'pHat', 'Data', false )))
			return err;
		
		DB = DmOpenDatabaseByTypeCreator('Data', 'pHat', dmModeReadOnly);
	}

	numrecords = DmNumRecords ( DB );
	if ( ! numrecords ) {
		firstStart = true;
		initDB();
		return 0;
	}

	ReadDB(&recnum, &version, sizeof(UInt16));
	
	if ( version == 1 ) {
		ReadDB(&recnum, &prefs, sizeof(struct preferences));
		prefs.isalarm = 0;
		ReadDB(&recnum, &NofPlayers, sizeof(UInt8));
		last = NULL;
		for ( i = 0; i < NofPlayers ; i++) {
			p = NewPlayer();
			ReadDB(&recnum, p, sizeof(struct player));
			p->name = MemPtrNew(p->namelen);
			ReadDB(&recnum, p->name, p->namelen);
			if ( last ) last->next = p;
			else players = p;
			last = p;
		}
		if ( ! NofPlayers ) firstStart = true;
	}

	DmCloseDatabase(DB);

	return 0;
}

void saveDB() {

	UInt16 numrecords;
	UInt16 recnum;
	UInt16 version = 1;
	Int8 i;
	struct preferences alarmcheck;

	struct player *p;
	struct player *l;

	DB = DmOpenDatabaseByTypeCreator('Data', 'pHat', dmModeReadWrite);

	/* Check whether we're closing because of our own alarm */
	if ( ! firstStart ) {
		recnum = 1;
		ReadDB(&recnum, &alarmcheck, sizeof(struct preferences));
		if ( alarmcheck.isalarm ) {
			prefs.selectedPlayer = alarmcheck.selectedPlayer;
			prefs.selectedScreen = alarmcheck.selectedScreen;
		}
	}

	/* Remove old Records */
	numrecords = DmNumRecords(DB);
	for ( i = 0; i < numrecords; i++ )
		DmRemoveRecord(DB, 0);

	recnum = 0;
	WriteDB(&recnum, &version, sizeof(UInt16));
	WriteDB(&recnum, &prefs, sizeof(struct preferences));
	WriteDB(&recnum, &NofPlayers, sizeof(UInt8));

	l = p = players;

	while ( p ) {
		p->namelen = StrLen(p->name) + 1;
		WriteDB(&recnum, p, sizeof(struct player));
		WriteDB(&recnum, p->name, p->namelen);
		p = p->next;
		MemPtrFree(l->name);
		MemPtrFree(l);
		l = p;
	}
	DmCloseDatabase(DB);
}