// ----------------------------------------------------------------------------
// NAME         : date.js
// VERSION      : 1.0
// DESCRIPTION  : Utility library of date based functions
// DEPENDENCIES : None
// ----------------------------------------------------------------------------

// ----------------------------- Function List --------------------------------
//
// string date_stringHowManyDays (string month, int year = currentYear)
// int    date_howManyDays (int month, int year = currentYear)
// bool   date_isItNextYear (int month)
// int    date_getCurrentYear ()
// bool   duration_validate (form, string ci (prefix), string co (prefix))
// string expiry_validate(object expiryDate)
// string dropdate_validate (object OutDay, object OutMon, object OutYear)
// bool   dropDate_AfterToday (object OutDay, object OutMon, object OutYear);
// bool   is_DOB(object ddob, object mdob, object ydob)
// string compare_date(object dayval, object monthval, object yearval);
// bool   comp_dropdates(object OutDay, object OutMon, object OutYear,
//                       object RetDay, object RetMon, object RetYear);
// bool   compMMYYDate(string date1, string date2);
// date   addToDate(date date1, int displacement);
// string longDate(date date1);
// string strLongDate(string date1);
// string formatFSSDate(date date1);
// object createDate(string date);
//
// ----------------------------------------------------------------------------

// -------------------------- date_stringHowManyDays --------------------------
// NAME       : date_stringHowManyDays
// PARAMETERS : string thisMonth   ("01" to "12")
//            : int thisYear = current year 
// RETURNS    : int monthDays
// BEHAVIOUR  : Returns the number of days in the month
// ----------------------------------------------------------------------------
function date_stringHowManyDays (thisMonth, thisYear)
{
	return date_howManyDays (thisMonth - 1, thisYear);
}

// -------------------------- date_howManyDays --------------------------------
// NAME       : date_howManyDays
// PARAMETERS : int thisMonth    (0 to 11)
//            : int thisYear = current year 
// RETURNS    : int monthDays
// BEHAVIOUR  : Returns the number of days in the month
// ----------------------------------------------------------------------------
function date_howManyDays (thisMonth, thisYear)
{
	// default the year if it hasn't been entered
	if (!thisYear)
	{
		thisYear = date_getCurrentYear ();
		if (date_isItNextYear (thisMonth))
		{
			thisYear++;
		}
	}

	var monthDays = new Array(31,28,31,30,31,30,31,31,30,31,30,31);
	if (thisMonth != 1)
	{
		return monthDays[thisMonth];
	}
	else
	{
		// month is february
		if (   (   (thisYear%400)  == 0 ) 
				|| (   ((thisYear%100) != 0 ) 
						&& ((thisYear%4)   == 0 )
					 ) 
			 )
		{
			return 29;
		}
		else
		{
			return 28;
		}
	}
}

// -------------------------- date_isItNextYear -------------------------------
// NAME       : date_isItNextYear
// PARAMETERS : int  themonth
// RETURNS    : bool returnvalue
// BEHAVIOUR  : Check to see if a month is this year or next...
// ----------------------------------------------------------------------------
function date_isItNextYear (themonth)
{
	var returnvalue  = false;
	var currentDate  = new Date();
	var currentMonth = currentDate.getMonth();
	if (themonth < currentMonth)
	{
		returnvalue = true;
	}

	return returnvalue;
}

// ------------------------- date_getCurrentYear ------------------------------
// NAME       : date_getCurrentYear
// PARAMETERS : none
// RETURNS    : int y
// BEHAVIOUR  : Returns the current year in four digit format
// ----------------------------------------------------------------------------
function date_getCurrentYear () {
	var currentDate = new Date();
	var y = currentDate.getFullYear();
	if (y < 1000) {
		y += 1900;
	}
	return y;
}

//-------------------------- duration_validate --------------------------------
// NAME       : duration_validate
// PARAMETERS : form, string ci (prefix), string co (prefix)
// RETURNS    : bool
// BEHAVIOUR  : function ensures out date is same or greater than in date
//              activated on form submit, submition continues if returns 'true'
//-----------------------------------------------------------------------------
function duration_validate(f, ci, co) {
	var msg;    //The error message
	var err=0;  //Default error flag to 0 (no error)

	//Now if any errors, display them and return false to prevent form
	//submition, otherwise return true
	msg  = "______________________________________________________\n\n";
	msg += "The form was not submitted because of the following error(s).\n";
	msg += "Please correct these error(s) and re-submit.\n";
	msg += "______________________________________________________\n\n";

	if (parseFloat(getDropDownValue(eval("f."+ci+"Mon"))) > 
			parseFloat(getDropDownValue(eval("f."+co+"Mon")))) {
		msg += "The check-out date must be after the check-in date";
		err = 1; //set the error flag, error has occured
	}

	if (parseFloat(getDropDownValue(eval("f."+ci+"Mon"))) == 
			parseFloat(getDropDownValue(eval("f."+co+"Mon")))) {
		if (parseFloat(getDropDownValue(eval("f."+ci+"Day"))) > 
				parseFloat(getDropDownValue(eval("f."+co+"Day")))) {
			msg += "The check-out date must be after the check-in date";
			err = 1;
		}
	}

	if (err == 0) return true;
	return false;  
}

function setDays(direction) {
	var currentYear = date_getCurrentYear();
	var yearField = eval("document.FSSform."+direction+"Year");
	if (typeof yearField == 'object') {
		if (yearField.type == "text") {
			currentYear = yearField.value;
		} else { // Must be a drop down
			currentYear = yearField.options[yearField.selectedIndex].value;
		}
	}

	var month = eval("document.FSSform." + direction + "Mon.selectedIndex");
	var selIn = 0;
	var currentDate = new Date();

	if (month != currentDate.getMonth()) {
		if ((date_isItNextYear(month+1)) && (typeof yearField == 'undefined')) {
			currentYear++;
		}
	}

	var monlen = date_howManyDays(month, currentYear);
	var datesel = eval("document.FSSform." + direction + "Day");
	selIn = datesel.selectedIndex;
	datesel.length = 28;

	for (var i=datesel.length;i<monlen;i++) {
		var optext = i+1;
		if (optext == 29 || optext == 30) {
			optext += "th";
		}
		else {
			optext += "st";
		}
		datesel.options[i] = new Option(optext,i+1,false,false);
	}

	if (datesel.length-1 < selIn) {
		selIn = datesel.length-1;
	}

	datesel.selectedIndex = selIn;

// Hacked in by TinK
  var monthString = month + 1;
  if (monthString < 10)
  {
    monthString = "0" + monthString;
  }

  var dateString = datesel.selectedIndex+1;

  if (dateString < 10) 
  {
    dateString = "0" + dateString;
  }

  var thedate=currentYear + monthString + "" + dateString;

var weekday=new Array(7)
weekday[0]="Sun"
weekday[1]="Mon"
weekday[2]="Tue"
weekday[3]="Wed"
weekday[4]="Thu"
weekday[5]="Fri"
weekday[6]="Sat"
var d=new Date("20"+currentYear, monthString-1, dateString);

  if (direction == "Out")
  {
	document.FSSform.outDate.value=thedate;
	document.getElementById("shortOutDay").innerHTML = weekday[d.getDay()];
  }
  else if (direction == "Ret")
  {
	document.FSSform.retDate.value=thedate;
	document.getElementById("shortRetDay").innerHTML = weekday[d.getDay()];
  }


}

//--------------------------- expiry_validate ---------------------------------
// NAME       : expiry_validate
// PARAMETERS : object expiryDate
// RETURNS    : string status (3 chars long '123')
//              '1' indicates date structure error
//              '2' indicates 01-12 month range error
//              '3' indicates expiry date before today error
//              '4' indicates 01-31 day range error
//              '5' indicates invalid date (eg 31 Sep)
// BEHAVIOUR  : returns empty string if expiry date is correct structure & 
//              > today
//-----------------------------------------------------------------------------
function expiry_validate(expiryDate, datelen) {

	if (datelen == null) datelen = 4;

	var evstr = "";            //Date validation variable
	var today = new Date;      //Todays date
	var newmonth;        //Used to check expiry is after today
	var theyear;         //Holds expiry year
	var expdate;         //Proposed date of expiry
	var errstr = "";           //The error string returned initialised to
	//no errors

	//Now validate the expiry date format MM/YY is length correct?
	if (expiryDate.value.length != datelen) {
		errstr = "1"; //Set error string to '1' representing MM/YY type error
	}

	// Grab day from date
	var theDay = "01";
	if (datelen>5)
		theDay = expiryDate.value.substr(0,2);

	if (parseFloat(theDay) < 1 || parseFloat(theDay) > 31)
		errstr += "4";

	//Grab month from expiry date
	evstr = expiryDate.value.substr((datelen-4),2);

	//Is month in correct range?
	if (parseFloat(evstr) < 1 || (parseFloat(evstr) > 12)) {
		errstr += "2"; //Set str to str + 2 indicating month range type error
	}

	//Grab the year
	theyear = expiryDate.value.substr((datelen-2),2);

	if (datelen < 5) {
		//newmonth is the expiry month + 1
		if (parseFloat(evstr) == 12) {
			newmonth = 1;
			theyear = parseFloat(theyear) + 1;
		}

		if (parseFloat(evstr) != 12) {
			newmonth = parseFloat(evstr) + 1;
		}
	} else {
		newmonth = evstr;
	}

	//Format year correctly
	if (parseFloat(theyear) < 10) {
		theyear = "0" + parseFloat(theyear);
	}

	if (parseFloat(theyear) > 89) {
		theyear = "19" + theyear;
	}
	else theyear = "20" + theyear;

	if (theDay > date_howManyDays((parseFloat(evstr)-1), theyear))
		errstr += "5";

	//Create date for comparison with date object (today)
	if (parseFloat(theDay) <10) theDay = "0" + parseFloat(theDay);
	if (parseFloat(newmonth) <10) newmonth = "0" + parseFloat(newmonth);
	expdate = theDay + (newmonth + "") + theyear;

	//if (theDay < 10) expdate = "0" + expdate;

	//Now check expiry is after today
	//Check the year
	if (parseFloat(expdate.substr(4,4)) < parseFloat(today.getFullYear())) {
		errstr += "3";  //Set str to hold 3 indicating expires before or on today
	}

	//Check the month if year is same
	if (parseFloat(expdate.substr(4,4)) == parseFloat(today.getFullYear())) {
		if (parseFloat(expdate.substr(2,2)) < parseFloat(today.getMonth() + 1)) {
			if (errstr.indexOf("3") == -1)
				errstr += "3"; //If this error type is not already assigned do it
		}
	}

	//Check the day against today if same year and month
	if ((parseFloat(expdate.substr(4,4)) == parseFloat(today.getFullYear())) &&
			(parseFloat(expdate.substr(2,2)) == parseFloat(today.getMonth() + 1))) {
		if (parseFloat(expdate.substr(0,2)) <= parseFloat(today.getDate())) {
			if (errstr.indexOf("3") == -1)
				errstr += "3";
		}
	}

	return(errstr);
}


//--------------------------- dropdate_validate -------------------------------
// NAME       : dropdate_validate
// PARAMETERS : object OutDay, object OutMon, object OutYear
// RETURNS    : year drop down object 
//            
// BEHAVIOUR  : returns same year as passed in if whole date is after today
//              otherwise returns next year 
// DEPENDENCY : compare_date
//-----------------------------------------------------------------------------
function dropdate_validate(OutDay, OutMon, OutYear) {
	var today = new Date;      //Todays date
	var compareYear = "";
	var compareMonth = "";
	var compareDay = "";
	var compareDate = "";
	var inputDate = "";
	var inputYear = "";

	compareYear = today.getFullYear();
	compareMonth = today.getMonth() + 1;
	compareDay = today.getDate() + 1;
	compareDate += compareYear;
	compareDate += compareMonth;
	compareDate += compareDay;

	inputDate += getDropDownValue(OutYear);
	inputYear = inputDate;
	inputDate += getDropDownValue(OutMon);
	inputDate += getDropDownValue(OutDay); 

	if (parseFloat(inputDate) < parseFloat(compareDate)) {
		inputYear = (inputYear - 0) + 1;
	}

	return(inputYear);
}


//--------------------------- dropDate_AfterToday -----------------------------
// NAME       : dropDate_AfterToday
// PARAMETERS : object OutDay, object OutMon, object OutYear
// RETURNS    : bool, true if date set is after today 
//            
// BEHAVIOUR  : else false if date set is not after today 
// DEPENDENCY : compare_date            
//-----------------------------------------------------------------------------
function dropDate_AfterToday(OutDay, OutMon, OutYear) {
	var errString = ""; //The returned error string

	errString = compare_date(OutDay, OutMon, OutYear);

	if (errString == 1) return true;
	else return false;
}

//--------------------------- is_DOB ------------------------------------------
// NAME       : is_DOB
// PARAMETERS : object ddob, object mdob, object ydob
// RETURNS    : bool, true if date is a valid birthday 
//            
// BEHAVIOUR  : checks structure of birth date and if is before today
// DEPENDENCY : compare_date
//-----------------------------------------------------------------------------
function is_DOB(ddob, mdob, ydob) {
	var errString = ""; //The returned error string
 
	errString = compare_date(ddob, mdob, ydob);

	if (errString == "-1") return true;
	else return false;
}

//--------------------------- compare_date ------------------------------------
// NAME       : compare_date
// PARAMETERS : object dayval, object monthval, object yearval
// RETURNS    : string (-1 or 1 or 0 or 9)  -1= < today
//               1= > today
//               0= is today
//               9= input is not a date
// BEHAVIOUR  : checks structure of birth date and if is before today
//              function works with drop downs and text boxes
// CALLED FROM: can be called from; dropDate_validate,
//                                  dropDate_AfterToday
//            is_DOB 
//-----------------------------------------------------------------------------
function compare_date(ddob, mdob, ydob) {
	var today = new Date(); //Todays date

	var compareYear = "";
	var compareMonth = "";
	var compareDay = "";
	var compareDate = "";
	var inputDate = "";     //Users inputted date
	var maxDays = "";       //Maximum no. days for given month and year
	var inDay = "";   //Users Day
	var inMonth = "";   //Users month
	var inYear = "";    //Users year

	compareYear = today.getFullYear();   //Todays date
	compareMonth = today.getMonth() + 1;
	if (parseInt(compareMonth) < 10)
		compareMonth = "0" + compareMonth;
	compareDay = today.getDate();
	if (parseInt(compareDay) < 10)
		compareDay = "0" + compareDay;
	compareDate += compareYear;
	compareDate += compareMonth;
	compareDate += compareDay;

	//Deal with both text boxes and dropdowns
	if (ydob.type == "text") {
		inputDate = ydob.value;
		inYear = ydob.value;
	}
	else {
		inputDate = getDropDownValue(ydob);
		inYear = getDropDownValue(ydob);
	}
	if (mdob.type == "text") {
		inputDate += mdob.value;
		inMonth = mdob.value;
	}
	else {
		inputDate += getDropDownValue(mdob);
		inMonth = getDropDownValue(mdob);
	}
	if (ddob.type == "text") {
		inputDate += ddob.value;
		inDay = ddob.value;
	}
	else {
		inputDate += getDropDownValue(ddob);
		inDay = getDropDownValue(ddob);
	}
	

	//Check if users value is valid date day range/month range for given year
	//Is month in correct range?
	if (parseFloat(inMonth) < 1 || (parseFloat(inMonth) > 12)) {
		return "9"; //Is not valid date
	}

	//Is day value valid for the month and the year?
	//Grab max days for month value
	maxDays = date_stringHowManyDays (inMonth, inYear);
	if ((inDay < 1) || (inDay > maxDays)) return "9"; //Not a valid date

	if (inputDate < compareDate) return "-1"; //Date B4 today
	if (inputDate > compareDate) return "1";  //Date after today
	if (inputDate == compareDate) return "0"; //Date is today
}

//--------------------------- comp_dropdates ----------------------------------
// NAME       : comp_dropdates
// PARAMETERS : object OutDay, object OutMon, object OutYear,
//              object RetDay, object RetMon, object RetYear
// RETURNS    : bool, true if RetDate is >= OutDate
//            
// BEHAVIOUR  : checks if RetDate is >= OutDate
// DEPENDENCY : 
//-----------------------------------------------------------------------------
function comp_dropdates(OutDay, OutMon, OutYear, RetDay, RetMon, RetYear) {
// parseInt -- taken out of Month -- Ret and Out Mon

	if (parseInt(getDropDownValue(RetYear)) < parseInt(getDropDownValue(OutYear))) {
		return false;
	}

	if (parseInt(getDropDownValue(RetYear)) == parseInt(getDropDownValue(OutYear))) {
		if ((getDropDownValue(RetMon)) < (getDropDownValue(OutMon))) {
			return false;
		}
	}

	if (parseInt(getDropDownValue(RetYear)) == parseInt(getDropDownValue(OutYear))) {
		if ((getDropDownValue(RetMon)) == (getDropDownValue(OutMon))) {
			if (parseFloat(getDropDownValue(RetDay)) < parseFloat(getDropDownValue(OutDay))) {
				return false;
			}
		}
	}

	return true;
}

//--------------------------- comp_daterange ----------------------------------
// NAME       : comp_daterange
// PARAMETERS : object form, string OutDay ,string OutMon string OutYear
//    string default start date, string default end date  
// RETURNS    : bool 
//            
// BEHAVIOUR  : if true -= the date is correct, false= alert msg to user
// DEPENDENCY : NONE
//-----------------------------------------------------------------------------

function comp_daterange(OutDay, OutMon, OutYear, start_rng, end_rng) {
	// check that year is with in range
	// if it is 
	//check that month within the required year range
	// if the month is right check that the day is with in the range
	var test_day = getDropDownValue(OutDay);
	var test_month = getDropDownValue(OutMon);
	var test_yr = getDropDownValue(OutYear);

	test_yr = (parseInt(test_yr)) % 100;
	
	var test_date = ""+test_yr+test_month+test_day;

	if (test_yr < 10) test_date = "0" + test_date;

	if ((test_date <start_rng) || (test_date > end_rng)) {
		return false;
	} else {
		return true;
	}
}

//----------------------------- compMMYYDate ----------------------------------
// NAME       : compMMYYDate
// PARAMETERS : string date 1, string date 2
// 
// RETURNS    : bool
// BEHAVIOUR  : returns true if date2 is after date1
//
//-----------------------------------------------------------------------------
function compMMYYDate(date1, date2) {
	if (parseFloat(date1.substr(2,2)) > parseFloat(date2.substr(2,2))) 
		return false;

	if (parseFloat(date1.substr(2,2)) == parseFloat(date2.substr(2,2)))
		if (parseFloat(date1.substr(0,2)) > parseFloat(date2.substr(0,2)))
			return false; 

	return true;
}

// ---------------------------- prepare_date ----------------------------------
// NAME       : prepare_date
// PARAMATERS : object datedropdown, object datedropdown, object datedropdown
//     
// RETURNS    : string 6 char date ie 010101
// BEHAVIOUR  : builds a standard 6 char date from three drop downs 
// ----------------------------------------------------------------------------
function prepare_date(dateDay, dateMonth, dateYear) {
	var theYear; //Must grab a two character year
	var theMonth = getDropDownValue(dateMonth);
	var theDate;

	if (theYear == null) {
		theYear = date_getCurrentYear();
		if (date_isItNextYear(theMonth)) theYear++;
		theYear += '';
	} else {
		theYear = getDropDownValue(dateYear);
	}
	if (theYear.length == 4)
		theYear = theYear.substr(2,2);
	theDate = theYear + theMonth + getDropDownValue(dateDay);
	return theDate;
	
}

// --------------------------------- addToDate --------------------------------
// NAME       : addToDate
// PARAMETERS : date date1, int displacement (number of days displacement)
//
// RETURNS    : date new date
// BEHAVIOUR  : Adds displacement to date, and returns new date
// ----------------------------------------------------------------------------
function addToDate(oldDate, numDays) {
	var odMilli = oldDate.getTime();
	var inMilli = numDays * (24 * 60 * 60 * 1000);
	var newDate = new Date(odMilli + inMilli);
	
	return newDate;
}

// ------------------------------- longDate -----------------------------------
// NAME       : longDate
// PARAMETERS : date date1
//
// RETURNS    : string
// BEHAVIOUR  : Takes date object and returns as string ie (3 March 2001)
// ----------------------------------------------------------------------------
function longDate(theDate) {
	var months = new Array("January","February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December");

	var grabMonth = theDate.getMonth();
	grabMonth = months[grabMonth];

	var dString = theDate.getDate() + " " + grabMonth + " " + 
								theDate.getFullYear();

	return dString;
}

// ----------------------------- strLongDate ----------------------------------
// NAME       : strLongDate
// PARAMETERS : string date1
//
// RETURNS    : string
// BEHAVIOUR  : Takes date string YYMMDD format and returns 3 March 2001 etc
// ----------------------------------------------------------------------------
function strLongDate(theDate) {
	var yearOK = "20" + theDate.substr(0,2); //Always Y2K it
	var passDate = new Date(parseInt(yearOK),(parseFloat(theDate.substr(2,2)) - 1),parseFloat(theDate.substr(4,2)));
	var dString = longDate(passDate);  

	return dString;
}

// ------------------------------ formatFSSDate -------------------------------
// NAME       : formatFSSDate
// PARAMETERS : date date1
// 
// RETURNS    : string 
// BEHAVIOUR  : Takes date object and returns as string YYMMDD format
// ----------------------------------------------------------------------------
function formatFSSDate(theDate) {
	var grabYear = theDate.getYear() + "";
	grabYear = parseInt(grabYear.substr(2,2));
	if (grabYear < 10) grabYear = "0" + grabYear;
	var grabMonth = theDate.getMonth();
	grabMonth++;
	if (grabMonth < 10) grabMonth = "0" + grabMonth;
	var grabDate = theDate.getDate();
	if (grabDate < 10) grabDate = "0" + grabDate;
	var newDate = grabYear + grabMonth + grabDate;
	
	return newDate;
}

// --------------------------------- createDate -------------------------------
// NAME       : createDate
// PARAMETERS : string date
// 
// RETURNS    : date object
// BEHAVIOUR  : converts string YYMMDD date into new date object
// ----------------------------------------------------------------------------
function createDate(theDate) {
	var theYear = parseFloat("20" + theDate.substr(0,2));
	var theMonth = parseFloat(theDate.substr(2,2) - 1);
	var theDay = parseFloat(theDate.substr(4,2));
	var newDate = new Date(theYear, theMonth, theDay);

	return newDate;
}

function setDateDDB(strDate, dateName) {
	var theDate = createDate(strDate);
	var yrDDB  = eval("document.FSSform."+dateName+"Year");
	var monDDB = eval("document.FSSform."+dateName+"Mon");
	var dayDDB = eval("document.FSSform."+dateName+"Day");

	setDropDown(yrDDB,  theDate.getYear);
	setDropDown(monDDB, theDate.getMonth+1);
	setDays(dateName);
	setDropDown(dayDDB, theDate.getDay);
}

function calcDuration(startDate, endDate) {
	return Math.round((endDate.getTime() - startDate.getTime()) /(1000*24*60*60))
}