// startstopentry.js
// created 10/27/06 JLD
// enables AJAX call
//
// requires following libraries:
//
// * prototype.js for cross-browser AJAX code and form variable convenience functions ($, $F, etc.)
// * ajax.js for DSI-specific AJAX implementation
// * util.js for generic functions used by prototype.js and ajax.js
//
var formObj;		// form to submit.  populated on checkDateArray, cleared on error or on AJAX call.

function getNormalDate(dateVar)
{
	var out;
	
	if (dateVar)
		out = String((dateVar.getMonth() + 1)) + "/" + String(dateVar.getDate()) + "/" + String(dateVar.getFullYear());
	else
		out = "";
	
	return out;
}

function checkDate(stopDate, restartDate, checkDateURL)
{
	var stopDateURL = "", restartDateURL = "";
	
	if (stopDate)
		stopDateURL = getNormalDate(stopDate);
	if (restartDate)
		restartDateURL = getNormalDate(restartDate);
	
	requestXML(checkDateURL + '&a_stop_date=' + stopDateURL + '&a_restart_date=' + restartDateURL, { method: 'get', asynchronous: true, parameters: '', onComplete: checkDateComplete });
}
function checkDateComplete(originalRequest)
{
	try
	{
		var xmlResponse		= xmlResponseParse(originalRequest, 0); // 10443 added index param for multiple XML objects
		
		if (xmlResponse.redirect)
		{
			// this means there was a server timeout, or some other failure that requires redirect to login
			window.top.location.replace(xmlResponse.redirect);
			return;
		}
		else if (xmlResponse.sqlcode)
		{
			// error caught by procedure, re-packaged as XML
			alert(xmlResponse.sqlerror);
			return;
		}
		else
		{
			if (xmlResponse.code < 0)			// this is an error message
				alert(xmlResponse.msg.replace("|||||", "\n"));
			else if (xmlResponse.code == 1)		// 1 = success, so submit the form
				formObj.submit();
			else								// this is bad
				alert('Invalid response from date check. (' + xmlResponse.msg + ')');
		}
	}
	catch(e)
	{
		alert('Error during date check (' + e.description + ')');	
	}
}

function checkDateArray(form, ajaxUrl)
{
	var stopDate, restartDate, stopDateCompare, restartDateCompare;
	var dateMonth, dateDay, dateYear;

	var errorText = "The dates provided are invalid: ";
	var errorsFound = 0;
	var errorTextTemp = "", errorSkipOther = false, errorFoundOnFirst = false;
	
	var insertType;

	var /*lastTrans, 12815*/ lastTransStatus;
	var stopLastTrans, restartLastTrans /*12815 fix case*/, stopNextTrans, restartNextTrans;
	var stopDateDone = false, restartDateDone = false, inVacPackPeriod = false, ignoreRestart = false;
	var blockingTransCount = 0, blockingTransDateList = "";
	var vacPackBegin;
	
	var datesOK = false;
	
	var today = new Date();
	today = new Date(today.getFullYear(), today.getMonth(), today.getDate());	// this strips time of day from the date value

	// set form in global
	formObj = form;
	
	//
	// 1. GET FORM DATES INTO JS DATE OBJECT
	//
	// pull stop year/mo/day fields into JS placeholders
	//
	if ($("p_year1"))
	{
		dateYear = $F("p_year1");
		dateMonth = Number($F("p_month1")) - 1;
		dateDay = $F("p_day1");
	}
	else
	{
		dateYear = undefined;
		dateMonth = undefined;
		dateDay = undefined;
	}
	//alert("STOP: dateYear = " + dateYear + " \ndateMonth = " + dateMonth + " \ndateDay = " + dateDay);
	
	if (((String(dateMonth+1)) && (dateDay) && (dateYear)) && ((String(dateMonth+1) != "") && (dateDay != "") && (dateYear != "")))
	{
		// for some reason, comparisons are not working on dates themselves, use getTime() to compare milliseconds
		stopDate = new Date(dateYear, dateMonth, dateDay);
		stopDateCompare = stopDate.getTime();	
		
		// if not a future date, raise error and halt
		if (stopDateCompare <= today)
		{
			alert(errorMsgText(errorMessages.pastDate, {p1: getNormalDate(stopDate)}));
			return false;
		}
	}
	else
	{
		// mark vals as undefined for later existence checks
		stopDate = undefined;
		stopDateCompare = undefined;
	}
	
	// now pull restart year/mo/day fields into JS placeholders
	if ($("p_nostart"))
		ignoreRestart = $("p_nostart").checked;
	
	if (($("p_year2")) && (!ignoreRestart))
	{
		dateYear = $F("p_year2");
		dateMonth = Number($F("p_month2")) - 1;
		dateDay = $F("p_day2");
	}
	else
	{
		dateYear = undefined;
		dateMonth = undefined;
		dateDay = undefined;
	}

	//alert("RESTART: dateYear = " + dateYear + " \ndateMonth = " + dateMonth + " \ndateDay = " + dateDay);
	//alert("date existence = " + ((String(dateMonth+1)) && (dateDay) && (dateYear)) + "\n non-stringness = " + (String(dateMonth+1) != "") + "/" + (dateDay != "") + "/" + (dateYear != ""));
	
	if (((String(dateMonth+1)) && (dateDay) && (dateYear)) && ((String(dateMonth+1) != "") && (dateDay != "") && (dateYear != "")))
	{
		restartDate = new Date(dateYear, dateMonth, dateDay);
		restartDateCompare = restartDate.getTime();
		
		// if not a future date, raise error and halt
		if (restartDateCompare <= today)
		{
			alert(errorMsgText(errorMessages.pastDate, {p1: getNormalDate(restartDate)}));
			return false;
		}
	}
	else
	{
		// mark vals as undefined for later existence checks
		restartDate = undefined;
		restartDateCompare = undefined;
	}
	
	// 2. DETERMINE WHETHER THIS IS A TRANSACTION PAIR, AND WHAT KIND
	//
	// 		1 = stop/restart
	// 		2 = restart/stop
	// 		3 = stop
	// 		4 = restart
	
	if ((stopDate) && (restartDate))
	{
		if (stopDateCompare == restartDateCompare)
		{
			alert(errorMsgText(errorMessages.stopRestartSame, {p1: getNormalDate(restartDate)}));
			return false;
		}
		
		if (restartDateCompare > stopDateCompare)
			insertType = 1;
		else
			insertType = 2;
	}
	else if (stopDate)
	{
		insertType = 3;
		restartDateDone = true;
	}
	else if (restartDate)
	{
		insertType = 4;
		stopDateDone = true;
	}
	else
	{
		alert(errorMessages.datesNotValid);
		return false;
	}
	
	// ***************************** //
	// from this point forward, the entire analysis of dates will proceed regardless of whether a "failure"
	// condition is encountered.  All such conditions will be aggregated, and raised later as a single alert.
	//
	// ***************************** //
	
	//
	// 3. GET THE PREVIOUS/NEXT STATUSES FOR EACH DATE BASED ON ARRAY OF TRANSACTIONS
	//
	//		(and check for vacpacks, date conflicts, transaction straddling if a pair of dates, etc.)
	//
	
	// 12815 for case where array is empty
/*	if (transArray.length == 0)
	{
		stopLastTrans = minDateObject;
		restartLastTrans = minDateObject;
		//stopNextTrans = maxDateObject;
		//restartNextTrans = maxDateObject;
	}*/
	for (i=1;i<transArray.length;i++)
	{
		// if we haven't yet passed the stop date then 
		if (!stopDateDone)
		{
			if ((transArray[i].transDate.getTime() == stopDateCompare))
			{
				errorText += ("\n" + errorMsgText(errorMessages.transExists, {p1: getNormalDate(stopDate), p2: transArray[i].transStatusEnglish}));
				errorsFound++;
				stopDateDone = true;
			}
			else if (transArray[i].transDate.getTime() > stopDateCompare)
			{
				if (inVacPackPeriod)
				{
					errorText += ("\n" + errorMsgText(errorMessages.vacPack, {p1: getNormalDate(stopDate), p2: getNormalDate(vacPackBegin.transDate), p3: getNormalDate(transArray[i].transDate) }));
					errorsFound++;
					stopDateDone = true;
				}
				else
				{
					// mark current as NEXT
					stopNextTrans = transArray[i];
					stopDateDone = true;
				}
			}
			else	// mark current as PREVIOUS
				stopLastTrans = transArray[i];						
		}

		// if we haven't yet passed the stop date then 
		if (!restartDateDone)
		{
			if ((transArray[i].transDate.getTime() == restartDateCompare))
			{
				errorText += ("\n" + errorMsgText(errorMessages.transExists, {p1: getNormalDate(restartDate), p2: transArray[i].transStatusEnglish}));
				errorsFound++;
				restartDateDone = true;
			}
			else if (transArray[i].transDate.getTime() > restartDateCompare)
			{
				if (inVacPackPeriod)
				{
					errorText += ("\n" + errorMsgText(errorMessages.vacPack, {p1: getNormalDate(restartDate), p2: getNormalDate(vacPackBegin.transDate), p3: getNormalDate(transArray[i].transDate) }));
					errorsFound++;
					restartDateDone = true;
				}
				else
				{
					// mark current as NEXT
					restartNextTrans = transArray[i];
					restartDateDone = true;
				}
			}
			else	// mark current as PREVIOUS
				restartLastTrans = transArray[i];						
		}
		
		//	check whether we're entering a vacpack period
		if ((!inVacPackPeriod) && (transArray[i].transStatus == 'V+'))
		{
			vacPackBegin = transArray[i];
			inVacPackPeriod = true;
		}
		else if ((inVacPackPeriod) && (transArray[i].transStatus == 'V-'))
			inVacPackPeriod = false;
		
		// if we're all done, get out
//		if ((stopDateDone) && (restartDateDone))
//			break;
		// NO... stick around, so we can see whether a stop/restart is entirely surrounded by 		



		// if one date is in the past, but not both (b/c we would've hit the BREAK above), and a status change is detected,
		// then note this for the error processor
		//
		// requirements:
		//		1. date pair (insertType = 1 or 2)
		//		2. one of the dates has been encountered, and the other hasn't
		//		3. current trans date is not the same as either date
		//		4. status hasn't changed since last transaction (for future use... in case we ever include records besides those that change active/inactive status)
		//
		// (technically, just having the current transaction fall between one date but not the other would suffice.  
		// however, doing it this way in case transactions other than A/I/V+/V- ever come into the equation.)
		//
		if (transArray[i-1])
			lastTransStatus = transArray[i-1].lastStatusIdx;
		else
			lastTransStatus = -1;
		
		if ((insertType < 3) && (((stopDateDone) || (restartDateDone)) && (!((stopDateDone) && (restartDateDone)))) && (stopDateCompare != transArray[i].transDate.getTime()) && (restartDateCompare != transArray[i].transDate.getTime()) && (lastTransStatus != transArray[i].lastStatusIdx))
		{
			//errorText += ("\n" + errorMsgText(errorMessages.blockingTrans, {p1: transArray[i].transStatusEnglish, p2: getNormalDate(transArray[i].transDate)}));
			//errorText += "\n" + errorMessages.blockingTrans + " (" + transArray[i].transStatusEnglish + " on " + getNormalDate(transArray[i].transDate) + ")";
			errorsFound++;
			blockingTransCount++;
			if (blockingTransDateList == "")
				blockingTransDateList = getNormalDate(transArray[i].transDate);
			else
				blockingTransDateList += (", " + getNormalDate(transArray[i].transDate));
		}
	}
	
	// so now that we know what kind of trans date configuration was submitted,
	// we evaluate the situation of each type
	
	switch (insertType)
	{
		// stop/restart
		case 1:
			// conditions:
			//		1. no blocking transactions
			//		2. no errors
			//		3. last status prior to stop was A or V- (active or end-of-vacpack)
			//
			if (stopLastTrans) // 12815
			{
				if ((stopLastTrans.transStatus != "A") && (stopLastTrans.transStatus != "V-"))
				{
					// ADD THIS ERROR LATER, AFTER WE DETERMINE WHETHER WE'RE RAISING THE ENVELOPED PAIR ERROR
					errorTextTemp = ("\n" + errorMsgText(errorMessages.stopNextToStop, {p1: getNormalDate(stopDate), p2: getNormalDate(stopLastTrans.transDate)}));
					errorsFound++;
					errorFoundOnFirst = true;
				}
			}
			if (restartNextTrans)
			{
				if ((restartNextTrans.transStatus == "A") || (restartNextTrans.transStatus == "V-"))
				{
					if (errorFoundOnFirst) // if previous is stop, and next is restart, then a stop/restart envelops the proposed stop/restart
					{
						errorText += ("\n" + errorMsgText(errorMessages.stopRestartEnveloped, {p1: getNormalDate(stopDate), p2: getNormalDate(restartDate), p3: getNormalDate(stopLastTrans.transDate), p4: getNormalDate(restartNextTrans.transDate)}));
						errorSkipOther = true;
					}
					else
						errorText += ("\n" + errorMsgText(errorMessages.restartNextToRestart, {p1: getNormalDate(restartDate), p2: getNormalDate(restartNextTrans.transDate)}));
					errorsFound++;
				}
			}
			if ((!errorSkipOther) && (errorFoundOnFirst))
				errorText += errorTextTemp;
			if (blockingTransCount > 0)
			{
				errorText += ("\n" + errorMsgText(errorMessages.blockingTrans, {p1: blockingTransCount, p2: blockingTransDateList}));
				errorsFound++;
			}
			
			break;
		// restart/stop
		case 2:			
			// conditions:
			//		1. no blocking transactions
			//		2. no errors
			//		3. last status prior to stop was I (active or end-of-vacpack)
			//
			if (restartLastTrans) // 12815
			{
				if (restartLastTrans.transStatus != "I")
				{
					// ADD THIS ERROR LATER, AFTER WE DETERMINE WHETHER WE'RE RAISING THE ENVELOPED PAIR ERROR
					errorTextTemp = ("\n" + errorMsgText(errorMessages.restartNextToRestart, {p1: getNormalDate(restartDate), p2: getNormalDate(restartLastTrans.transDate)}));
					errorsFound++;
					errorFoundOnFirst = true;
				}
			}
			if (stopNextTrans)
			{
				if (stopNextTrans.transStatus == "I")
				{
					if (errorFoundOnFirst) // if previous is restart, and next is stop, then a restart/stop envelops the proposed restart/stop
					{
						errorText += ("\n" + errorMsgText(errorMessages.restartStopEnveloped, {p1: getNormalDate(stopDate), p2: getNormalDate(restartDate), p3: getNormalDate(restartLastTrans.transDate), p4: getNormalDate(stopNextTrans.transDate)}));
						errorSkipOther = true;
					}
					else
						errorText += ("\n" + errorMsgText(errorMessages.stopNextToStop, {p1: getNormalDate(stopDate), p2: getNormalDate(stopNextTrans.transDate)}));
					errorsFound++;
				}
			}
			if ((!errorSkipOther) && (errorFoundOnFirst))
				errorText += errorTextTemp;
			if (blockingTransCount > 0)
			{
				errorText += ("\n" + errorMsgText(errorMessages.blockingTrans, {p1: blockingTransCount, p2: blockingTransDateList}));
				errorsFound++;
			}
			
			break;
		// stop
		case 3:			
			// conditions:
			//		1. last status prior to stop was A or V-
			//		2. must be end of time
			//
			if (stopLastTrans) // 12815 
			{
				if ((stopLastTrans.transStatus != "A") && (stopLastTrans.transStatus != "V-"))
				{
					errorText += ("\n" + errorMsgText(errorMessages.stopNextToStop, {p1: getNormalDate(stopDate), p2: getNormalDate(stopLastTrans.transDate)}));
	//				errorText += ("\n" + errorMessages.stopAfterStop + " (" + getNormalDate(stopDate) + ")");
					errorsFound++;
				}
			}
			if (stopNextTrans)
			{
				errorText += ("\n" + errorMsgText(errorMessages.notEndOfTime, {p1: getNormalDate(stopDate), p2: getNormalDate(stopNextTrans.transDate)}));
//				errorText += ("\n" + errorMessages.notEndOfTime + " (" + getNormalDate(stopNextTrans.transDate) + ")");
				errorsFound++;
			}
			break;
		// restart
		case 4:			
			// conditions:
			//		1. last status prior to stop was I
			//		2. must be end of time
			//
			if (restartLastTrans) // 12815
			{
				if ((restartLastTrans.transStatus != "I"))
				{
					errorText += ("\n" + errorMsgText(errorMessages.restartNextToRestart, {p1: getNormalDate(restartDate), p2: getNormalDate(restartLastTrans.transDate)}));
	//				errorText += ("\n" + errorMessages.restartNextToRestart + " (" + getNormalDate(restartDate) + ")");
					errorsFound++;
				}
			}
			if (restartNextTrans)
			{
				errorText += ("\n" + errorMsgText(errorMessages.notEndOfTime, {p1: getNormalDate(restartDate), p2: getNormalDate(restartNextTrans.transDate)}));
//				errorText += ("\n" + errorMessages.notEndOfTime + " (" + getNormalDate(restartNextTrans.transDate) + ")");
				errorsFound++;
			}
			break;
	}
	
	if (errorsFound > 0)
		alert(errorText);
	else
	{
		checkDate(stopDate, restartDate, ajaxUrl);
	}
}