// Copyright 1998,1999 Macromedia, Inc. All rights reserved.

// Localization strings
var TRACK_system_not_found = "Tracking system not found.";

//Constructs an Interaction
function MM_interaction(theSelf,
               theJudgeOnSel, theAllowMultiSel, theAllThatApply, theUnknownIsCorrect,
               theDisabled, theTriesLimit, theTimeLimit,
               theTrackIntId, theTrackObjectiveId,
               theTrackQType, theTrackWeight, theKTrack)
{
	// properties
	this.judgeOnSel = theJudgeOnSel;
	this.allowMultiSel = theAllowMultiSel;
	this.allThatApply = theAllThatApply;
	this.unknownIsCorrect = theUnknownIsCorrect;
	this.disabled = theDisabled;
	this.tries = 0;
	this.triesLimit = (theTriesLimit) ? theTriesLimit : 0;
	this.triesAtLimit = false;
	this.time = 0;
	this.timeLeft = 0;
	this.timeLimit = (theTimeLimit) ? theTimeLimit : 0;
	this.timeAtLimit = false;
	this.trackIntId = theTrackIntId;
	this.trackObjectiveId = theTrackObjectiveId;
	this.trackQType = theTrackQType;
	this.trackWeight = theTrackWeight;
	this.knowledgeTrack = theKTrack;
	this.totalElems = 0;
	this.possCorrect = 0;
	this.possIncorrect = 0;
	this.knownResponse = false;
	this.totalCorrect = 0;
	this.totalIncorrect = 0;
	this.correct = false;
	this.score = 0;

	this._self = theSelf;
	this._timeStart = 0;
	this._timerID = 0;

	this.browserIsNS = (navigator.appName.indexOf('Netscape') != -1);
	this.browserIsIE = (navigator.appName.indexOf('Microsoft') != -1);
	this.osIsWindows = (navigator.appVersion.indexOf('Win') != -1);
	this.osIsMac = (navigator.appVersion.indexOf('Mac') != -1); // ????
	this.browserVersion = parseFloat(navigator.appVersion);

	this.e = new Array();
	this.b = new Array();

	// methods
	this.init = MM_intInit;
	this.reset = MM_intReset;
	this.resetElems = MM_intResetElems;
	this.enable = MM_intEnable;
	this.disable = MM_intDisable;
	this.setDisabled = MM_intSetDisabled;
	this.update = MM_intUpdate;
	this.add = MM_intAdd;
	this.setTries = MM_intSetTries;
	this.setTriesLimit = MM_intSetTriesLimit;
	this.setTime = MM_intSetTime;
	this.setTimeLimit = MM_intSetTimeLimit;
	this.track = MM_intTrack
	this.getTime = MM_intGetTime;

	this.am = MM_intAm;
	this.judge = MM_intJudge;
	this.resetActionMgr = MM_intResetActionMgr;
	this.setSegmNode = MM_intSetSegmNode;
	this.getSegmNode = MM_intGetSegmNode;
	this.setSegmDisabled = MM_intSetSegmDisabled;
	this.getSegmDisabled = MM_intGetSegmDisabled;
}

//Calls the element init funtions if they exist, and then does a reset
function MM_intInit()
{
	var i, j, localPC;

	with (this)
	{
		// init elems, and set totalElems, possCorrect, possIncorrect;
		totalElems = 0;
		possCorrect = 0;
		possIncorrect = 0;
		for (i in e) if (i != 'length')
		{
			if (e[i].init != null) e[i].init();
			totalElems++;
			localPC = 0;
			for (j in e[i].c) if (j != 'length' && e[i].c[j].isCorrect != null)
				(e[i].c[j].isCorrect) ? localPC++ : possIncorrect++;
			if (e[i]._singleChoice != null && localPC > 1)
				localPC = 1;
			possCorrect += localPC;
		}
		reset();
		if (knowledgeTrack)
		{
			var frm = findcmiframe(null);
			if (frm == null)
			{
				installcmi(window); //layers in NS
				if (!CMIIsPresent())
				{
					var cmi = cmiinit(window);
					if (cmi) CMIInitialize();
					else if (!window.trackwarning)
					{
						alert(TRACK_system_not_found);
						window.trackwarning = true;
					} 
				} 
			}
			else
			{
				if (window.CMIInitialize == null) frm.installcmi(window);
				if (window.CMIInitialize != null) CMIInitialize();
				if (!CMIIsPresent() && !window.trackwarnings)
				{
					alert(TRACK_system_not_found);
					window.trackwarning = true;
				} 
			} 
		} 
	}
	window["'" + this._self + "'"] = this._self; //redeclare global on window in case inserted in layer
}

//Called to reset the interaction
function MM_intReset()
{
	with (this)
	{
		tries = 0;
		triesAtLimit = false;
		_timeStart = Math.floor((new Date()).getTime() / 1000);
		if (_timerID) clearTimeout(_timerID);
		if (!disabled && timeLimit) _timerID = setTimeout(_self + ".judge()", (timeLimit + 1) * 1000);
		time = 0;
		timeLeft = timeLimit;
		timeAtLimit = false;

		resetActionMgr();
		resetElems();
		update(true);
	}
}

//Calls the reset for the individual elements
function MM_intResetElems()
{
	with (this)
	{
		for (var i in e) if (i != 'length')
			if (e[i].reset != null) e[i].reset();
		update(true);
	}
}

//Enables the interaction
function MM_intEnable()
{
	if (this.disabled) with (this)
	{
		_timeStart = Math.floor((new Date()).getTime() / 1000) - time;
		if (timeLimit)
			_timerID = setTimeout(_self + ".judge()", Math.max(0, (timeLimit - time) + 1) * 1000);
		disabled = false;
		update(true);
		for (var i in e) if (i != 'length')
			if (e[i].enable != null) e[i].enable();
	}
}

//Disables the interaction
function MM_intDisable()
{
	if (!this.disabled) with (this)
	{
		update(true);  // update 'time'
		if (_timerID) clearTimeout(_timerID);  // clear the timer
		disabled = true;
		for (var i in e) if (i != 'length')
			if (e[i].disable != null) e[i].disable();
	}
}

//Calls the approppriate disable or enable function
function MM_intSetDisabled(theDisabled)
{
	if (theDisabled) this.disable();
	else this.enable();
}

//Update the interaction state
// Note: tries will be updated by the judge method, and time will
//       be updated by both this method and the judge method.
function MM_intUpdate(noJudge)
{
	if (!this.disabled) with (this)
	{
		knownResponse = false;
		totalCorrect = 0;
		totalIncorrect = 0;
		correct = false;
		score = 0;
		for (var i in e) if (i != 'length')
		{
			for (var j in e[i].c) if (j != 'length')
			{
				if (e[i].c[j].selected)
				{
					knownResponse = true;
					score += e[i].c[j].score;
					if (e[i].c[j].isCorrect != null)
						(e[i].c[j].isCorrect) ? totalCorrect++ : totalIncorrect++;
				} 
			} 
		}
		if (!knownResponse) correct = unknownIsCorrect;
		else if (totalIncorrect != 0) correct = false;
		else if (totalCorrect == 0) correct = null; // not judged
		else correct = (!allThatApply || totalCorrect >= possCorrect);

		time = Math.floor((new Date()).getTime() / 1000) - _timeStart;
		if (timeLimit && !timeAtLimit)
		{
			timeLeft = Math.max(0, timeLimit - time);
			timeAtLimit = (time > timeLimit);
		}

		if (judgeOnSel && !noJudge) judge();
	}
}

function MM_intSetTries(theTries)
{
	with (this)
	{
		tries = theTries;
		triesAtLimit = (triesLimit) ? (tries >= triesLimit) : false;
	}
}

function MM_intSetTriesLimit(theTriesLimit)
{
	with (this)
	{
		triesLimit = theTriesLimit;
		triesAtLimit = (triesLimit) ? (tries >= triesLimit) : false;
	}
}

function MM_intSetTime(theTime)
{
	with (this)
	{
		time = Math.max(0, theTime);
		_timeStart = Math.floor((new Date()).getTime() / 1000) - time;
		timeLeft = (timeLimit) ? Math.max(0, timeLimit - time) : timeLimit;
		timeAtLimit = (timeLimit) ? (time > timeLimit) : false;
		if (_timerID) clearTimeout(_timerID);  // clear the timer
		if (!disabled && timeLimit)
			_timerID = setTimeout(_self + ".judge()", Math.max(0, (timeLimit - time) + 1) * 1000);
	}
}

function MM_intSetTimeLimit(theTimeLimit)
{
	with (this)
	{
		if (!disabled)
			time = Math.floor((new Date()).getTime() / 1000) - _timeStart;
		timeLimit = theTimeLimit;
		timeLeft = (timeLimit) ? Math.max(0, timeLimit - time) : timeLimit;
		timeAtLimit = (timeLimit) ? (time > timeLimit) : false;
		if (_timerID) clearTimeout(_timerID);  // clear the timer
		if (!disabled && timeLimit)
			_timerID = setTimeout(_self + ".judge()", Math.max(0, (timeLimit - time) + 1) * 1000);
	}
}

function MM_intAdd(theType, A, B, C, D, E, F, G, H, I, J, K, L, M)
{
	var theObj = eval("new MM_" + theType + "(" + this._self + ", A, B, C, D, E, F, G, H, I, J, K, L, M)");
	if (theObj._isChoice != null)
		this.e[A].c[B] = theObj;
	else
		this.e[A] = theObj;
}

function MM_intTrack()
{
	var aDt = new Date();
	var curHr = aDt.getHours() + '', curMin = aDt.getMinutes() + '', curSec = aDt.getSeconds() + '';
	var curDay = aDt.getDate() + '', curMonth = aDt.getMonth() + 1 + '', curYear = aDt.getYear(), dmy;
	var lat = Math.floor(aDt.getTime() / 1000) - this._timeStart;
	var x = 3600;
	var y = 60;
	var hrs = Math.round(lat / x - lat % x / x) + '';
	var min = Math.round((lat - hrs * x) / y - (lat - hrs * x) % y / y) + '';
	var sec = Math.round(lat - hrs * x - min * y) + '';
	var sRes, cRes, res, aName, bName, isC, isNC, isSel, iType;

	if (curYear < 1900) curYear += 1900;
	if (curDay.toString().length == 1) curDay = '0' + curDay;
	if (curMonth.toString().length == 1) curMonth = '0' + curMonth;
	dmy = curDay + "/" + curMonth + "/" + curYear;

	sRes = cRes = res = aName = bName = ""

	with (this)
	{
		if (trackQType.length == 0) return;
		iType = trackQType.charAt(0).toLowerCase();
		if (allThatApply && possCorrect > 1) sRes = cRes = '{';

		for (var i in e) if (i != 'length')
		{
			for (var j in e[i].c) if (j != 'length')
			{
				isC = e[i].c[j].isCorrect;
				isSel = e[i].c[j].selected;
				if (iType == 'm')
				{
					aName = e[i].c[j]._elem._name;
					bName = e[i].c[j]._target._name;
					if (isC) cRes += aName + '.' + bName + ',';
					if (isSel) sRes += aName + '.' + bName + ',';
				}
				else if (iType == 'f')
				{
					aName = e[i].value;
					bName = MM_textDeencrypt(e[i].c[j].expectedValue);
					if (isC) cRes += bName + ',';
					if (isSel) sRes += aName + ',';
				}
				else if ((iType == 'c') || (iType == 't'))
				{
					if (e[i]._trkObj != null)
					{
						aName = e[i].c[j].expectedValue;
						x = aName.indexOf(':');
						aName = aName.substring(0, x) + '-' + aName.substring(x + 1, aName.length)
						bName = e[i].value
					}
					else if (e[i]._tick != null)
					{
						aName = e[i].c[j].expectedValue;
						if (isSel) bName = aName;
					}
					else if (e[i]._stateMask != null && totalElems == 1)
					{
						aName = e[i].expectedValue;
						bName = e[i].value;
					}
					else
						aName = bName = e[i].c[j]._name;

					if (isC) cRes += aName + ',';
					if (isSel) sRes += bName + ',';
				}
				else
				{
					aName = bName = '';
					if (isC) cRes += ',';
					if (isSel) sRes += ',';
				}

				isNC = (isC == false) && isSel;
				isC = isC && isSel;
				if (possCorrect > 1) res = res + (isC ? 'c,' : isNC ? 'w,' : isSel ? 'n,' : '');
				else if (isSel) res = isC ? 'c' : isNC ? 'w' : 'n';
			}
		}

		if (sRes.charAt(sRes.length - 1) == ',') sRes = sRes.substring(0, sRes.length - 1);
		if (cRes.charAt(cRes.length - 1) == ',') cRes = cRes.substring(0, cRes.length - 1);
		if (res.charAt(res.length - 1) == ',') res = res.substring(0, res.length - 1);
		if (allThatApply && possCorrect > 1)
		{
			sRes = sRes + '}';
			cRes = cRes + '}';
		}
		if (window.CMIIsPresent && CMIIsPresent())
		{
			if (hrs.toString().length == 1) hrs = '0' + hrs;
			if (min.toString().length == 1) min = '0' + min;
			if (sec.toString().length == 1) sec = '0' + sec;
			if (curHr.toString().length == 1) curHr = '0' + curHr;
			if (curMin.toString().length == 1) curMin = '0' + curMin;
			if (curSec.toString().length == 1) curSec = '0' + curSec;
			CMIAddInteraction(dmy, curHr + ":" + curMin + ":" + curSec,
       trackIntId, trackObjectiveId, trackQType,
       cRes, sRes, res, trackWeight, hrs + ":" + min + ":" + sec);
		}
	}
}


function MM_intGetTime()
{
	var date = new Date();
	this.time = (date.getTime() / 1000 - this._timeStart) * 1000;
	return this.time / 1000;
}


//Finds any object in either browser using recursion.
//Only pass the first argument, the name of the object to find.
//Returns a pointer the object if found, else an empty string.
//  MM_intFindObject('bar') returns the object
//  document.layers['foo'].document.layers['bar']

function MM_intFindObject(objName, parentObj)
{
	var i, tempObj = "", found = false, curObj = "";
	var NS = (navigator.appName.indexOf("Netscape") != -1);
	if (!NS && document.all) curObj = document.all[objName]; //IE4
	if (!curObj)
	{
		parentObj = (parentObj != null) ? parentObj.document : document;
		if (parentObj[objName] != null) curObj = parentObj[objName]; //at top level
		else
		{ //if in form
			if (parentObj.forms) for (i = 0; i < parentObj.forms.length; i++)
			{  //search level for form object
				if (parentObj.forms[i][objName])
				{
					curObj = parentObj.forms[i][objName];
					found = true; break;
				} 
			}
			if (!found && NS && parentObj.layers && parentObj.layers.length > 0)
			{
				parentObj = parentObj.layers;
				for (i = 0; i < parentObj.length; i++)
				{ //else search for child layers
					tempObj = MM_intFindObject(objName, parentObj[i]); //recurse
					if (tempObj) { curObj = tempObj; break; } //if found, done
				} 
			} 
		} 
	}
	return curObj;
}

//Called from within conditions to check document properties
function MM_getDocProp(theName, theProp, theType)
{
	var theObj = MM_intFindObject(theName);
	if (theObj) return eval('theObj.' + theProp);
	else return null;
}


//*********  ACTION MGR METHODS  *********

function MM_intJudge(treeRoot, curRoot, level)
{
	var i = 0, theNode, retVal = true, firstCond = true;
	level = (curRoot == null) ? 0 : level + 1;
	if (!level)
	{
		curRoot = this; //set tree to highest level
		if (this.disabled) retVal = false;
		else
		{
			this.time = Math.floor((new Date()).getTime() / 1000) - this._timeStart;
			if (this.timeLimit && !this.timeAtLimit)
			{
				this.timeLeft = Math.max(0, this.timeLimit - this.time);
				this.timeAtLimit = (this.time > this.timeLimit);
			}
			this.tries++;
			if (this.triesLimit)
				this.triesAtLimit = (this.tries >= this.triesLimit);
		} 
	} else if (treeRoot.curNode != null && curRoot == treeRoot.curNode) //if at curNode
		i = treeRoot.curIndex;  //offset by index
	for (i; (retVal && i < curRoot.b.length); i++)
	{
		theNode = curRoot.b[i];
		if (this.disabled) retVal = false;
		else if (theNode.disabled) continue;
		else if (theNode.type == "segm")
		{ //SEGMENT
			curNode = (theNode.curNode) ? theNode.curNode : theNode;
			if (curNode != 'done')
				retVal = MM_intJudge(theNode, curNode, level);   //start from that node
			else if (!level) continue;
		} else if (theNode.type == 'cond')
		{ //CONDITION
			if (eval(theNode.data))
			{
				if (!treeRoot.data) treeRoot.curNode = 'done';  //if not "auto-reset tree", set curNode
				retVal = MM_intJudge(treeRoot, theNode, level);
				if (level) break;
			} else if (firstCond)
			{
				firstCond = false;
				if (!treeRoot.data) { treeRoot.curNode = curRoot; treeRoot.curIndex = i; }
			}
		} else if (theNode.type == 'actn')
		{ //ACTION
			if (!treeRoot.data) //not auto-reset
				if (i < (curRoot.b.length - 1))
			{ //not last node
				treeRoot.curNode = curRoot; treeRoot.curIndex = i + 1; //set curNode to next node
			} else treeRoot.curNode = 'done'; //last node, clear curNode
			if (theNode.data == 'stop') retVal = false; //STOP
			else eval(theNode.data);
		} 
	}
	if (!level && curRoot != null && curRoot.knowledgeTrack) curRoot.track();
	return retVal
}


//Disables or enables ActionMgr segments. If no segment passed,
//disables *all* segments. Returns false if segment not found.

function MM_intSetSegmDisabled(segmName, disable)
{
	var i, retVal = false;
	for (i = 0; i < this.b.length; i++) //search for segment
		if (!segmName || this.b[i].name == segmName)
	{
		this.b[i].disabled = disable; retVal = true;
		if (segmName) break;
	}
	return retVal
}


//Returns the disabled flag from an ActionMgr segment.
//Returns null if segment not found.

function MM_intGetSegmDisabled(segmName)
{
	var i, retVal = null;
	for (i = 0; i < this.b.length; i++) //search for segment
		if (this.b[i].name == segmName)
	{
		retVal = this.b[i].disabled; break;
	}
	return retVal
}


function MM_intResetActionMgr(segmName)
{
	var i;
	if (segmName != null) MM_intTreeSetCurNode(segmName, null, this); //clear single curNode
	else for (i = 0; i < this.b.length; i++) this.b[i].curNode = null; //clear all curNodes
}


function MM_intSetSegmNode(segmName, condName)
{
	var i, curRoot = null;
	if (!condName) this.resetActionMgr(segmName);
	else
	{
		for (i = 0; i < this.b.length; i++) //search for segment, set as curRoot
			if (this.b[i].name == segmName) { curRoot = this.b[i]; break; }
		MM_intTreeSetCurNode(condName, null, curRoot, curRoot);
	}
}


function MM_intTreeSetCurNode(nodeName, newVal, treeRoot, curRoot)
{
	var i, theNode;
	if (curRoot == null) curRoot = treeRoot; //if first time, use treeRoot
	for (i = 0; i < curRoot.b.length; i++)
	{
		theNode = curRoot.b[i];
		if (theNode.type == "segm")
		{ //SEGMENT
			if (theNode.name == nodeName) theNode.curNode = newVal;
			else MM_intTreeSetCurNode(nodeName, newVal, theNode, theNode);
		} else if (theNode.type == 'cond')
		{ //CONDITION
			if (theNode.name == nodeName)
			{  //if name found
				treeRoot.curNode = curRoot; treeRoot.curIndex = i;
				break;
			} else MM_intTreeSetCurNode(nodeName, newVal, treeRoot, theNode);
		} 
	}
}


//Returns the current node for the given Segment, returned as:
// top of segment    - "" (empty string)
// middle of segment - condition name
// end of segment    - "done"

function MM_intGetSegmNode(segmName)
{
	var i, curNode = '';
	for (i = 0; i < this.b.length; i++) //search for segment
		if (this.b[i].name == segmName)
	{
		curNode = this.b[i].curNode;
		if (curNode == null) curNode = "";
		else if (curNode != "done") curNode = curNode.b[this.b[i].curIndex].name;
		break;
	}
	return curNode
}



//*********  ACTION MGR NODE CLASS  *********

function MM_intNode(theType, theName, theData)
{
	this.type = (theType) ? theType : '';
	this.name = (theName) ? theName : '';
	this.data = (theData) ? theData : '';
	this.b = new Array();
}


//Create Action Manager (tree)

function MM_intAm(theType, theName, theData)
{
	if (theType == "segm")
	{
		if (!this.tParent)
		{ //initialize system
			this.tParent = new Array(); //tree parent nodes
			this.tIndex = new Array();  //child indexes
			this.tIndex[0] = -1;        //set index for root depth
		}
		this.tLevel = 0;            //reset level to 0
		this.tIndex[this.tLevel]++; //increment the index
		this.b[this.tIndex[this.tLevel]] = new MM_intNode("segm", theName, theData); //create tree
		this.tParent[this.tLevel] = this.b[this.tIndex[this.tLevel]]; //put this tree root at top level
		this.tIndex[this.tLevel + 1] = -1;                              //reset child level index

	} else if (theType == "actn")
	{
		var parentNode = this.tParent[this.tLevel];    //get parent
		var levelIndex = ++this.tIndex[this.tLevel + 1]; //get index
		parentNode.b[levelIndex] = new MM_intNode('actn', theName, theData); //add action

	} else if (theType == "cond")
	{
		var parentNode = this.tParent[this.tLevel];    //get parent
		var levelIndex = ++this.tIndex[this.tLevel + 1]; //get index
		parentNode.b[levelIndex] = new MM_intNode('cond', theName, theData); //add condition

		this.tLevel++; //go down a level
		this.tParent[this.tLevel] = parentNode.b[levelIndex]; //save this node as parent
		this.tIndex[this.tLevel + 1] = -1;                      //reset child level index

	} else if (theType == "end")
	{
		this.tLevel--;  //go up a level
	}
}