/*******************************************************************************
 *	TmsLib.h	TMS Client library functions
 *			T.Barnaby,	BEAM Ltd,	2007-03-14
 *******************************************************************************
 */

#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <math.h>
#include <TmsLib.h>
#include <BDir.h>
#include <BEntry.h>
#include <BFile.h>

namespace Tms {

TmsCycleParams::TmsCycleParams(BString baseDir){
	obaseDir = baseDir;
}

BError TmsCycleParams::getCycleTypes(BList<BString>& typeList){
	BError		err;
	BDir		dir;
	BIter		i;
	BString		n;
	BEntryFile	f;
	
	typeList.clear();
	if(err = dir.open(obaseDir)){
		return err;
	}

	dir.setWild("*_0.spt");
	dir.setSort(1);

	for(dir.start(i); !dir.isEnd(i); dir.next(i)){
		if(!f.open(obaseDir + "/" + dir.entryName(i))){
			f.read();
			n = f.findValue("cycleType:");
			
			typeList.append(n);
		}
	}
	
	return err;
}

BError TmsCycleParams::getFileNames(BList<BString>& fileList){
	BError		err;
	BDir		dir;
	BIter		i;
	
	fileList.clear();

	if(err = dir.open(obaseDir)){
		return err;
	}

	dir.setWild("*.spt");
	dir.setSort(1);

	for(dir.start(i); !dir.isEnd(i); dir.next(i)){
		fileList.append(dir.entryName(i));
	}
	
	return err;
}


BError TmsCycleParams::getCycleParams(BString fileName, Tms::CycleParam& param){
	BString		pathName;
	
	pathName = obaseDir + "/" + fileName;
	
	return readCycleParams(pathName, param);
}

BError TmsCycleParams::setCycleParams(Tms::CycleParam param){
	BString		fileName;
	
	fileName = obaseDir + "/" + param.cycleType + "_" + param.channel + ".spt";
	
	return writeCycleParams(fileName, param);
}

BError TmsCycleParams::deleteCycleParams(BString cycleType, UInt32 puChannel){
	BError		err;
	BDir		dir;
	BIter		i;
	BString		n;
	BEntryFile	f;
	BString		pn;
	
	if(err = dir.open(obaseDir)){
		return err;
	}

	if(puChannel)
		dir.setWild(BString("*_") + puChannel + ".spt");
	else
		dir.setWild("*_*.spt");
	
	for(dir.start(i); !dir.isEnd(i); dir.next(i)){
		pn = obaseDir + "/" + dir.entryName(i);
		if(!f.open(pn)){
			f.read();
			n = f.findValue("cycleType:");
			if(n == cycleType){
				unlink(pn);
			}
		}
	}

#ifdef ZAP	
	err.set(ErrorNotImplemented, "Not Implemented");
#endif

	return err;
}

BError TmsCycleParams::readCycleParams(BString fileName, Tms::CycleParam& param){
	BError		err;
	BIter		i;
	BEntryFile	file;
	int		n;
	UInt32		p;
	BString		str;
	BList<BString>	strList;
	
	if(err = file.open(fileName)){
		err.set(err.getErrorNo(), BString("Unable to open file: ") + fileName);
		return err;
	}
	
	if(err = file.read()){
		err.set(err.getErrorNo(), BString("Unable to read file: ") + fileName);
		return err;
	}

	param.cycleType = file.findValue("cycleType:");
	param.info = file.findValue("info:");
	param.channel = file.findValue("channel:").retInt();
	param.pllInitialFrequency = file.findValue("pllInitialFrequency:").retInt();
	param.pllInitialFrequencyDelay = file.findValue("pllInitialFrequencyDelay:").retInt();
	param.pllFrefGain = file.findValue("pllFrefGain:").retInt();
	param.pllGain = file.findValue("pllGain:").retInt();
	param.pllDdsMinimum = file.findValue("pllDdsMinimum:").retInt();
	param.pllDdsMaximum = file.findValue("pllDdsMaximum:").retInt();

	param.frefPhaseDelay.resize(40);
	for(n = 0; n < 40; n++){
		param.frefPhaseDelay[n] = file.findValue(BString("frefPhaseDelay") + n + ":").retInt();
	}

	param.stateTable.resize(0);
	for(n = 0; n < 14; n++){
		if(!file.find(BString("stateTable") + n + ".state:"))
			break;

		param.stateTable.resize(n + 1);
		param.stateTable[n].state =  file.findValue(BString("stateTable") + n + ".state:").retInt();
		param.stateTable[n].numBunches =  file.findValue(BString("stateTable") + n + ".numBunches:").retInt();
		
		str = file.findValue(BString("stateTable") + n + ".phaseTable:");
		strList = str.getTokenList(",");
		param.stateTable[n].phaseTable.resize(tmsPhaseTableSize);
		for(p = 0, strList.start(i); (p < tmsPhaseTableSize) && (p < strList.number()); p++, strList.next(i)){
			param.stateTable[n].phaseTable[p] = strList[i].retInt();
		}
	}
	
	return err;
}

BError TmsCycleParams::writeCycleParams(BString fileName, Tms::CycleParam param){
	BError		err;
	unsigned int	n;
	unsigned int	p;
	BString		s;
	BString		str;
	BFile		file;

	if(err = file.open(fileName, "w")){
		err.set(err.getErrorNo(), BString("Unable to open file: ") + fileName);
		return err;
	}

	file.printf("cycleType: %s\n", param.cycleType.retStr());
	file.printf("info: %s\n", param.info.retStr());
	file.printf("channel: %u\n", param.channel);
	file.printf("pllInitialFrequency: %u\n", param.pllInitialFrequency);
	file.printf("pllInitialFrequencyDelay: %u\n", param.pllInitialFrequencyDelay);
	file.printf("pllFrefGain: %u\n", param.pllFrefGain);
	file.printf("pllGain: %u\n", param.pllGain);
	file.printf("pllDdsMinimum: %u\n", param.pllDdsMinimum);
	file.printf("pllDdsMaximum: %u\n", param.pllDdsMaximum);
	
	for(n = 0; n < param.frefPhaseDelay.size(); n++){
		file.printf("frefPhaseDelay%d: %u\n", n, param.frefPhaseDelay[n]);
	}

	for(n = 0; n < param.stateTable.size(); n++){
		file.printf("stateTable%d.state: 0x%x\n", n, param.stateTable[n].state);
		file.printf("stateTable%d.numBunches: %u\n", n, param.stateTable[n].numBunches);
		str = "";
		for(p = 0; p < param.stateTable[n].phaseTable.size(); p++){
			if(str.len())
				str = str + ",";
			s.printf("0x%x", param.stateTable[n].phaseTable[p]);
			str = str + s;
		}
		file.printf("stateTable%d.phaseTable: %s\n", n, str.retStr());
	}

	file.close();	

	return err;
}

BError TmsCycleParams::writeToString(Tms::CycleParam param, BString& string){
	BError		err;
	unsigned int	n;
	unsigned int	p;
	BString		s;
	BString		str;

	str.printf("cycleType: %s\n", param.cycleType.retStr()); string += str;
	str.printf("info: %s\n", param.info.retStr()); string += str;
	str.printf("channel: %u\n", param.channel); string += str;
	str.printf("pllInitialFrequency: %u\n", param.pllInitialFrequency); string += str;
	str.printf("pllInitialFrequencyDelay: %u\n", param.pllInitialFrequencyDelay); string += str;
	str.printf("pllFrefGain: %u\n", param.pllFrefGain); string += str;
	str.printf("pllGain: %u\n", param.pllGain); string += str;
	str.printf("pllDdsMinimum: %u\n", param.pllDdsMinimum); string += str;
	str.printf("pllDdsMaximum: %u\n", param.pllDdsMaximum); string += str;
	
	for(n = 0; n < param.frefPhaseDelay.size(); n++){
		str.printf("frefPhaseDelay%d: %u\n", n, param.frefPhaseDelay[n]);
		string += str;
	}

	for(n = 0; n < param.stateTable.size(); n++){
		str.printf("stateTable%d.state: 0x%x\n", n, param.stateTable[n].state);
		string += str;
		str.printf("stateTable%d.numBunches: %u\n", n, param.stateTable[n].numBunches);
		string += str;
		str = "";
		for(p = 0; p < param.stateTable[n].phaseTable.size(); p++){
			if(str.len())
				str = str + ",";
			s.printf("0x%x", param.stateTable[n].phaseTable[p]);
			str = str + s;
		}

		s.printf("stateTable%d.phaseTable: %s\n", n, str.retStr());
		string += s;
	}

	return err;
}

/// Calculates the base pickup phase values for the PS ring
void tmsPickupPositions(BArray<int>& pos){
	unsigned int	p = 43;		// The first pickup in the PS ring after injection
	unsigned int	n;
	
	pos.clear();
	pos.resize(tmsNumPickups);

	for(n = 0; n < tmsNumPickups; n++){
		pos[n] = int(round(((p - 43) * 512.0) / 100));

		if((p % 10) == 0){
			p += 3;
		}
		else if((p % 10) == 3){
			p += 2;
		}
		else if((p % 10) == 5){
			p += 2;
		}
		else if((p % 10) == 7){
			p += 3;
		}
	}
}

}