//====================================================================
// date.js - date conversion functions
//
// This file contains JavaScript code to support ProductCenter Web Client
//
// If you see this page in your browser, it is due to a missing entry
// in your web server's mime_types file that reads:
//                      application/x-javascript   js
//
// COPYRIGHT:	(c) Copyright, 2003 Softech, Inc.
//====================================================================

//====================================================================
// Examples of formats
//
// MMM      APR
// Mmm      Apr
// MM       04
// M        4
// full     April
//
// DD       08
// D        8
//
// YYYY     1998
// YY       98
//
// nice     April 8, 1998
//====================================================================

//====================================================================
// Find the format of a date string
// Recognized formats:
//
//    Mmm-DD-YYYY   - Core's format having called: 
//                    ValueCell::SetFormat(DATE_T, "%b-%d-%Y");
//    MM/DD/YY
//    MM/DD/YYYY
//
// Notes:
// - this is a hack for now
// - may not need to distinguish between MM/DD/YY and MM-DD-YY, etc. 
// - MM/DD/YY and M/D/YY aren't distinguishable for a date like 11/12/98
//====================================================================

function getFormat(dateString)
{
    if (dateString.charAt(12) == ',') {
        return "nice";
    }
    if (dateString.length == 6) {
        if (parseInt(dateString.substring(0,2)) > 12) {
            return "YYMMDD";
        }
        else {
            return "MMDDYY";
        }
    }
    if (dateString.length == 8) {
        var first = parseInt(dateString.substring(0,2));
        var second = parseInt(dateString.substring(2,4));
        var third = parseInt(dateString.substring(4,6));
        if (dateString.charAt(2) == '/') {
            if (first > 12) {
                if (second > 12) {
                    return "invalid format";
                }
                else {
                    // month is the second value
                    // the only marker we can possibly guess with is if the third value is over 12, if it is, chances
                    // are it's the day
                    if (third > 12) {
                        return "YY/MM/DD";
                    }
                    else {
                        return "DD/MM/YY";
                    }
                }
            }
            else {
                return "MM/DD/YY";
            }
        }
        else if (dateString.charAt(2) == '-') {
            if (first > 12) {
                if (second > 12) {
                    return "invalid format";
                }
                else {
                    // month is the second value
                    // the only marker we can possibly guess with is if the third value is over 12, if it is, chances
                    // are it's the day
                    if (third > 12) {
                        return "YY-MM-DD";
                    }
                    else {
                        return "DD-MM-YY";
                    }
                }
            }
            else {
                return "MM-DD-YY";
            }
        }
        else if (dateString.charAt(2) == '.') {         
            if (second > 12) {
                return "invalid format";
            }
            else {
                // month is the second value
                // the only marker we can possibly guess with is if the third value is over 12, if it is, chances
                // are it's the day
                if (third > 12) {
                    return "YY.MM.DD";
                }
                else {
                    return "DD.MM.YY";
                }
            }        
        }
        else {
            return "invalid format";
        }
    }
    if (dateString.length == 9) {
        // the year always seems to come last in these formats...
        if (dateString.charAt(6) == '/') {
            if (dateString.charAt(2) == '/') {
                return "DD/MON/YY";
            }
            else {
                return "MON/DD/YY";
            }
        }
        if (dateString.charAt(6) == '-') {
            if (dateString.charAt(2) == '-') {
                return "DD-MON-YY";
            }
            else {
                return "MON-DD-YY";
            }
        }
    }
    if (dateString.length == 10) {
        return "YYYY-MM-DD";
    }
    if (dateString.length == 11) {
        if ((dateString.charAt(3) == '-')&&(dateString.charAt(6) == '-')) {
            return "MMM-DD-YYYY";
        }
        if ((dateString.charAt(2) == '-')&&(dateString.charAt(6) == '-')) {
            return "DD-MMM-YYYY";
        }
    }
    if (dateString.length == 17) {
        if (dateString.charAt(2) == '.') {
            if (dateString.charAt(6) == '.') {
                return "DD.MON.YYYY HH24:MI";
            }
            return "YY.MM.DD.HH.MI.SS";
        }
        if (parseInt(dateString.substring(0,2)) > 12) {
            return "YY/MM/DD HH:MI:SS";
        }
        else {
            return "MM/DD/YY HH:MI:SS" ;
        }
    }
    if (dateString.length == 16) {
        return "MM/DD/YYYY HH24:MI";
    }
    if (dateString.length == 19) {
        return "YYYY:MM:DD HH24:MI:SS";
    }
    if (dateString.length == 20) {
        if (dateString.charAt(3) == '-') {
            return "MON-DD-YYYY HH24:MI:SS";
        }
        if (dateString.charAt(3) == '/') {
            return "MON/DD/YYYY HH24:MI:SS";
        }
    }

  return "invalid format";
}

//====================================================================
// Convert a Date object to a string in the given format.
//
// Input: adate - a valid date object
//        format - a valid format (new ones can be added)
//
//              Mmm-DD-YYYY
//              MMM-DD-YYYY
//              MON-DD-YYYY
//              M/D/YY  (3/15/98)
//              MM/DD/YY  (03/15/98)
//              MM/DD/YYYY
//              nice (March 15, 1998)
//====================================================================

function dateToString(adate, format)
{
  if (adate == null)
    return "";

  var dateString = "illegal format passed to dateToString";

  if (format == "Mmm-DD-YYYY") {
    dateString = getMmm(adate) + "-" + getDD(adate) + "-" + getYYYY(adate);
  }

  else if ((format == "MMM-DD-YYYY") ||(format == "MON-DD-YYYY")) {
    dateString = getMMM(adate) + "-" + getDD(adate) + "-" + getYYYY(adate);
  }

  else if (format == "M/D/YY") {
    var month = adate.getMonth() + 1;
    dateString = month + "/" + adate.getDate() + "/" + getYY(adate);
  }

  else if (format == "MM/DD/YY") {
    dateString = getMM(adate) + "/" + getDD(adate) + "/" + getYY(adate);
  }

  else if (format == "MM-DD-YY") {
    dateString = getMM(adate) + "-" + getDD(adate) + "-" + getYY(adate);
  }

  else if (format == "MM/DD/YYYY") {
    dateString = getMM(adate) + "/" + getDD(adate) + "/" + getYYYY(adate);
  }

  else if (format == "DD-MMM-YYYY") {
    dateString = getDD(adate) + "-" + getMMM(adate) + "-" + getYYYY(adate);
  }

  else if (format == "YY/MM/DD") {
    dateString = getYY(adate)  + "/" + getMM(adate) + "/" + getDD(adate)  ;
  }
  
  else if (format == "DD/MON/YY") {
    dateString = getDD(adate)  + "/" + getMMM(adate) + "/" + getYY(adate)  ;
  }

  else if (format == "YY-MM-DD") {
    dateString = getYY(adate)  + "-" + getMM(adate) + "-" + getDD(adate)  ;
  }

  else if (format == "YY.MM.DD") {
    dateString = getYY(adate)  + "." + getMM(adate) + "." + getDD(adate)  ;
  }

  else if (format == "DD.MM.YY") {
    dateString = getDD(adate)  + "." + getMM(adate) + "." + getYY(adate)  ;
  }

  else if (format == "DD/MM/YY") {
    dateString = getDD(adate)  + "/" + getMM(adate) + "/" + getYY(adate)  ;
  }

  else if (format == "MON-DD-YY") {
      dateString = getMMM(adate)  + "-" + getDD(adate) + "-" + getYY(adate);
  }

  else if (format == "MON-DD-YYYY HH24:MI:SS") {
    dateString = getMMM(adate)  + "-" + getDD(adate) + "-" + getYYYY(adate) 
	+ " " + getHH(adate) + ":" +  getMI(adate) + ":" +  getSS(adate) ;
  }

  else if (format == "MON/DD/YYYY HH24:MI:SS") {
    dateString = getMMM(adate)  + "/" + getDD(adate) + "/" + getYYYY(adate)  
	+ " " + getHH(adate) + ":" +  getMI(adate) + ":" + getSS(adate) ;
  }

  else if (format == "DD.MON.YYYY HH24:MI") {
    dateString = getDD(adate)  + "." + getMMM(adate) + "." + getYYYY(adate) 
	+ " " + getHH(adate) + ":" +  getMI(adate);

  }

  else if (format == "YYYY:MM:DD HH24:MI:SS") {
    dateString = getYYYY(adate)  + ":" + getMM(adate) + ":" + getDD(adate)  
	+ " " + getHH(adate) + ":" +  getMI(adate) + ":" + getSS(adate) ;
  }
  
  else if (format == "YYYY.MM.DD HH24:MI:SS") {
    dateString = getYYYY(adate)  + "." + getMM(adate) + "." + getDD(adate)  
	+ " " + getHH(adate) + ":" +  getMI(adate) + ":" + getSS(adate) ;
  }

  else if (format == "MM/DD/YYYY HH24:MI") {
    dateString = getMM(adate)  + "/" + getDD(adate) + "/" + getYYYY(adate)  
	+ " " + getHH(adate) + ":" + getMI(adate) ;
  }

  else if (format == "MM/DD/YY HH:MI:SS") {
    dateString = getMM(adate)  + "/" + getDD(adate) + "/" + getYYYY(adate)  
	+ " " + getHH(adate) + ":" + getMI(adate) + getSS(adate);
  }

  else if (format == "DD/MON/YY") {
      dateString = getDD(adate) + "/" + getMMM(adate) + "/" + getYY(adate);
  }
  
  else if (format == "DD-MON-YY") {
      dateString = getDD(adate) + "-" + getMMM(adate) + "-" + getYY(adate);
  }
  
  else if (format == "YYMMDD") {
      dateString = getYY(adate) + getMM(adate) + getDD(adate);
  }
  
  else if (format == "MMDDYY") {
      dateString = getMM(adate) + getDD(adate) + getYY(adate);
  }
  
  else if (format == "nice") {
    var month = adate.getMonth();
    dateString = numberToMonth(month, "full") + " " + adate.getDate() + ", " + getYYYY(adate);
  }

  return dateString;    
}

//====================================================================
// Convert a string with the given format to a Date object.
//
// Input: dateString - a date in string form
//        format - a valid format (new ones can be added)
//
//              MMM-DD-YYYY ||        MON-DD-YYYY
//              M/D/YY  (3/15/98)
//              MM/DD/YY  (03/15/98)
//              MM/DD/YYYY
//====================================================================

function stringToDate(dateString, format)
{
  if (dateString == "")
    return null;

  var month = getMonthFromString(dateString, format);
  var day = getDayFromString(dateString, format);
  var year = getYearFromString(dateString, format);

  // let us just add minute and other stuff FDA
  var hour = getHourFromString(dateString, format);
  var min = getMinuteFromString(dateString, format);
  var sec = getSecondFromString(dateString, format);

  return new Date(year, month, day,  hour, min, sec);
}



//====================================================================
// Convert a string with the given format to a Date/time object.
//
// Input: dateString - a date,time in string form
//        format - a valid format (new ones can be added)
//              
//              MM/DD/YY hh:mm:ss (03/15/98 12:24:33)
//====================================================================

function stringToDateTime(datetimeString, format)
{
  if (datetimeString == "")
    return "";

  var dateString = datetimeString.substring(0,8) //starting from
  var timeString = datetimeString.substr(9)  // starting from pos. 9
  if(format == "")
  format = "MM/DD/YY";
  var month = getMonthFromString(dateString, format);
  var day = getDayFromString(dateString, format);
  var year = getYearFromString(dateString, format);
  var hour = timeString.substr(0,2);
  var min =  timeString.substr(3,2);
  var sec =  timeString.substr(6,2);
  return new Date(year, month, day, hour, min, sec);
}

//
// Arrays for converting month number to abbreviation/name
//


var months = new Array("JAN", "FEB", "MAR", "APR", "MAY", "JUN",
                       "JUL", "AUG", "SEP", "OCT", "NOV", "DEC");

var smallMonths = new Array("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", 
                                           "Aug", "Sep", "Oct", "Nov", "Dec");

var fullMonths = new Array("January", "February", "March", "April", "May", "June", 
                                        "July", "August", "September", "October", "November",
                                        "December");

//==============================================================
// These convert parts of a Date object to different formats
//==============================================================

function getMMM(adate)
{
  var mo = adate.getMonth();  // 0-based is good here
  return months[mo];
}

function getMM(adate)
{
    var mo = parseInt(adate.getMonth()) + 1;
    return normalize(mo);
}

function getMmm(adate)
{
  var mo = adate.getMonth();
  return smallMonths[mo];
}

function getDD(adate)
{
  return normalize(adate.getDate());
}

function getHH(adate)
{
  return normalize(adate.getHours());
}

function getMI(adate)
{
  return normalize(adate.getMinutes());
}

function getSS(adate)
{
  return normalize(adate.getSeconds());
}


function getYYYY(adate)
{
  return getFullYear(adate);
}

function getYY(adate)
{
    var year = getFullYear(adate);
    year = year % 100;
    return normalize(year);
}

//====================================================================
// Get 4-digit year value. 
// The return format from the generic getYear method is too bizarre, so 
// always use this function to get the year. 
// Netscape 2 and 3 return a 2-digit year if the year is between 1900 and 1999.
// Otherwise they returns a 4-digit year.
// MS IE 3 returns the year minus 1900 (eg. 100 for year 2000), and cannot
// represent years prior to 1970, so the value is never negative.
//====================================================================

function getFullYear(adate)
{
  var fullYear = adate.getYear();

  if (fullYear < 1000) 
    fullYear = parseInt(fullYear) + 1900;

  return fullYear;
}

//====================================================================
// These extract numbers from a date string in the given format.
// They return -1 for invalid formats.
//====================================================================

//====================================================================
// Assumes that months in the string are NOT 0-based.
// Returns a 0-based month.
//====================================================================

function getMonthFromString(dateString, format)
{
  var month = -1;

  // Remember that in strings, months aren't 0-based.

  if (format == "Mmm-DD-YYYY") {
    month = dateString.substring(0, 3);
    return monthToNumber(month, "Mmm") -1;
  }
  else if ((format == "MMM-DD-YYYY") || (format == "MON-DD-YYYY") || (format == "MON-DD-YY")
	|| (format == "MON-DD-YYYY HH24:MI:SS") || (format == "MON/DD/YYYY HH24:MI:SS") ) {
    month = dateString.substring(0, 3);
    return monthToNumber(month, "MMM") -1;
  }
  else if ((format == "MM/DD/YY") || (format == "MM/DD/YYYY") || (format == "MM-DD-YY")
           || (format == "MM/DD/YYYY HH24:MI") || (format == "MMDDYY") ) {
    month = dateString.substring(0, 2);
    if (month.charAt(0) == 0)
      month = month.charAt(1);
    month--;
  }
  else if (format == "M/D/YY") {
    var index = dateString.indexOf("/");
    month = dateString.substring(0, index);
    month--;
  }
  else if ((format == "DD-MMM-YYYY") || (format == "DD.MON.YYYY HH24:MI") || (format == "DD/MON/YY")
           || (format == "DD-MON-YY")) {
    month = dateString.substring(3, 6);
	month =  monthToNumber(month, "MMM") -1;
  }
  else if ((format == "DD-MM-YY") || (format == "DD-MM-YY") || (format == "DD/MM/YY") || (format == "DD.MM.YY")
	|| (format == "YY-MM-DD") || (format == "YY.MM.DD") || (format == "YY/MM/DD")) {
    month = dateString.substring(3, 5);
    if (month.charAt(0) == 0)
      month = month.charAt(1);
    month--;
  }
  else if ((format == "YYYY:MM:DD HH24:MI:SS") || (format == "YYYY.MM.DD HH24:MI:SS")) {
    month = dateString.substring(5, 7);
    if (month.charAt(0) == 0)
      month = month.charAt(1);
    month--;
  }
  else if (format == "MM/DD/YY HH:MI:SS") {
    month = dateString.substring(0,2);
    if (month.charAt(0) == 0)
        month = month.charAt(1);
    month--;
  }
  else if (format == "nice") {
    month = dateString.substring(0, dateString.indexOf(" "));
    month =  monthToNumber(month, "full") -1;
  }
  
  else if (format == "YYMMDD") {
    month = dateString.substring(2,4);
    if (month.charAt(0) == 0)
        month = month.charAt(1);
    month--;
  }
  

  return month;
}



function getDayFromString(dateString, format)
{
  var day = -1;

  if ((format == "Mmm-DD-YYYY") || (format == "MMM-DD-YYYY") || (format == "MON-DD-YYYY") || (format == "MON-DD-YY")
	|| (format == "MON-DD-YYYY HH24:MI:SS") || (format == "MON/DD/YYYY HH24:MI:SS")) {
    day = dateString.substring(4, 6);

    // remove 0 from single-digit days
    if (day.charAt(0) == "0")
        day = day.charAt(1);
  }
  else if ((format == "MM/DD/YY") || (format == "MM-DD-YY") || (format == "MM/DD/YYYY")  || (format == "MM/DD/YYYY HH24:MI")) {
    day = dateString.substring(3, 5);
    if (day.charAt(0) == "0")
      day = day.charAt(1);
  }
  else if (format == "M/D/YY") {
    var first = dateString.indexOf('/') + 1;
    var last = dateString.lastIndexOf('/');
    day = dateString.substring(first, last);
  }
  else if ((format == "DD-MMM-YYYY") || (format == "DD.MON.YYYY HH24:MI") || (format == "DD.MM.YY")
           || (format == "DD/MON/YY") || (format == "DD-MON-YY")) {
    day = dateString.substring(0, 2);
    if (day.charAt(0) == "0")
      day = day.charAt(1);
  }
  else if ((format == "YY-MM-DD") || (format == "YY.MM.DD") || (format == "YY/MM/DD")) {
    day = dateString.substring(6, 8);
    if (day.charAt(0) == "0")
      day = day.charAt(1);
  }
  else if ((format == "YYYY:MM:DD HH24:MI:SS") || (format == "YYYY.MM.DD HH24:MI:SS"))  {
    day = dateString.substring(8, 10);
    if (day.charAt(0) == "0")
      day = day.charAt(1);
  }
  else if (format == "MM/DD/YY HH:MI:SS") {
    day = dateString.substring(3,5);
    if (day.charAt(0) == "0")
      day = day.charAt(1);
  }
  else if (format == "nice") {
      day = dateString.substring(10,12);
      if (day.charAt(0) == "0")
       day = day.charAt(1);
  }
  
  else if (format == "MMDDYY") {
      day = dateString.substring(2,4);
      if (day.charAt(0) == "0")
       day = day.charAt(1);
  }
  else if (format == "YYMMDD") {
      day = dateString.substring(4,6);
      if (day.charAt(0) == "0")
       day = day.charAt(1);
  } 

    return day;
}


function getYearFromString(dateString, format)
{
  var year = -1;

  if ((format == "Mmm-DD-YYYY") || (format == "MMM-DD-YYYY") || (format == "DD-MMM-YYYY") 
  || (format == "MON-DD-YYYY") || (format == "MON-DD-YYYY HH24:MI:SS")|| (format == "MON/DD/YYYY HH24:MI:SS")
  || (format == "DD.MON.YYYY HH24:MI")) 
    year = dateString.substring(7, 11);
  else if ((format == "MM/DD/YY") || (format == "MM-DD-YY") || (format == "DD/MM/YY")|| (format == "DD.MM.YY")) {
    year = dateString.substring(6, 8);
    year = normalizeYear(year);
  }
  else if ((format == "MM/DD/YYYY")  || (format == "DD-MM-YYYY") || (format == "MM/DD/YYYY HH24:MI"))
    year = dateString.substring(6, 10);
  else if (format == "M/D/YYYY") {
    var first = dateString.lastIndexOf('/') + 1;
    var last = dateString.length;
    year = dateString.substring(first, last);
  }
  else if ((format == "YY-MM-DD") || (format == "YY.MM.DD") || (format == "YY/MM/DD")) {
    year = dateString.substring(0, 2);
    year = normalizeYear(year);
  }
  else if ((format == "YYYY:MM:DD HH24:MI:SS") || (format == "YYYY.MM.DD HH24:MI:SS")) {
    year = dateString.substring(0,4);
  }
  else if (format == "M/D/YY"){
	var first = dateString.lastIndexOf('/');
	var last = dateString.length;
    year = dateString.substring(first, last);
  }

  else if (format == "MM/DD/YY HH:MI:SS") {
    year = dateString.substring(6,8);
    year = normalizeYear(year);
  }  
  else if ((format == "DD/MON/YY") || (format == "DD-MON-YY") || (format == "MON-DD-YY")) {
    year = dateString.substring(7,9);
    year = normalizeYear(year);
  }
  else if (format == "nice") {
      year = dateString.substring(14,18);
  }
  
  else if (format == "MMDDYY") {
      year = dateString.substring(4,6);
    year = normalizeYear(year);
  }
  else if (format == "YYMMDD") {
      year = dateString.substring(0,2);
    year = normalizeYear(year);
  } 
  
  return year;
  

}


function getSecondFromString(dateString, format)
{

var seconds = -1;

	switch (format) {
		case "MON-DD-YYYY HH24:MI:SS":
		case "MON/DD/YYYY HH24:MI:SS":
			seconds = dateString.substring(18,20);
			break;

		case "DD.MON.YYYY HH24:MI":
			seconds = 00;
			break;

		case "YYYY:MM:DD HH24:MI:SS":
		case "MM/DD/YYYY HH24:MI":
			seconds = dateString.substring(17,19);
			break;
		
		case "MM/DD/YY HH:MI:SS":
                        seconds = dateString.substring(16,18);
                        break;
                    
		default:
			seconds = 00;
			break;
	}
	return seconds;

}


function getMinuteFromString(dateString, format)
{

var minute = -1;

	switch (format) {
		case "MON-DD-YYYY HH24:MI:SS":
		case "MON/DD/YYYY HH24:MI:SS":
		case "DD.MON.YYYY HH24:MI":
			minute = dateString.substring(15,17);
			break;

		case "YYYY:MM:DD HH24:MI:SS":
		case "MM/DD/YYYY HH24:MI":
			minute = dateString.substring(14,16);
			break;
		

		case "MM/DD/YY HH:MI:SS":
                        seconds = dateString.substring(13,15);		
                        break;		
		
		default:
			minute = 00;
			break;
	}
	return minute;

}



function getHourFromString(dateString, format)
{

var hour = -1;

	switch (format) {
		case "MON-DD-YYYY HH24:MI:SS":
		case "MON/DD/YYYY HH24:MI:SS":
		case "DD.MON.YYYY HH24:MI":
			hour = dateString.substring(12,14);
			break;

		case "YYYY:MM:DD HH24:MI:SS":
		case "MM/DD/YYYY HH24:MI":
			hour = dateString.substring(11,13);
			break;
                case "MM/DD/YY HH:MI:SS":
                        seconds = dateString.substring(10,12);		
                        break;				
		
		default:
			hour = 00;
			break;
	}
	return hour;

}


function gettimestring(hourstring,minstring,secstring,format)
{
	var timestring = "";


	switch (format) {
		case "MON-DD-YYYY HH24:MI:SS":
		case "MON/DD/YYYY HH24:MI:SS":
		case "YYYY:MM:DD HH24:MI:SS":
			timestring = hourstring + ":" + minstring + ":" + secstring;
			break;

		case "MM/DD/YYYY HH24:MI":
		case "DD.MON.YYYY HH24:MI":
			timestring = hourstring + ":" + minstring ;
			break;
		
		default:
			timestring = "";
			break;
	}
	return normalizetimestring(timestring);

}

function normalizetimestring(timestring)
{
	if (timestring == "")
		return timestring;

	// if there is any single digit value it should be converted to double digit hh:mm:ss

	var newstring = "";
	temparray = timestring.split(":");
	for (var i = 0; i < temparray.length; i++) {
		if (temparray[i].substring(0,1) == "0")
			temparray[i] = temparray[i].substring(1,2)

		var val  = parseInt(temparray[i]);
		if (val < 10)
			val = "0" + val;
		newstring = newstring + ":" + val;
	}
	return newstring.substring(1,newstring.length);

}


//=================================================================
// Returns the 0-based number for a month.
// format is one of MMM (JAN), Mmm (Jan), or full (January).
// month is in the given format.
//=================================================================

function monthToNumber(month, format)
{
  var i;

  if (format == "Mmm") {
    for (i = 0; i < 12; i++) {
      if (smallMonths[i] == month)
        return i+1;  //we need to add 1 to month value since month is a zero based array
    }
  }
  else if (format == "MMM") {
    for (i = 0; i < 12; i++) {
      if (months[i] == month)
        return i+1;//we need to add 1 to month value since month is a zero based array
    }
  }
  else if (format == "full") {
    for (i = 0; i < 12; i++) {
      if (fullMonths[i] == month)
        return i+1;//we need to add 1 to month value since month is a zero based array
    }
  }

  return 0;
}

//====================================================================
// Given a 0-based month, convert it to a string in the given format.
// format is one of MMM (JAN), Mmm (Jan), or full (January).
//====================================================================

function numberToMonth(month, format)
{
  // check for invalid month
  if ((month < 0) || (month > 11))
    return "Invalid month given to numberToMonth";

  if (format == "Mmm")
    return smallMonths[month];
  else if (format == "MMM") 
    return months[month];
  else if (format == "full")
    return fullMonths[month];

  return "Invalid format given to numberToMonth";
}

//====================================================================
// Given a 0-based month, return the number of days in the month.
//====================================================================

var daysInMonths = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);

//====================================================================
// Given a 0-based month and the year, return the number of days in the month.
//====================================================================

function getDaysInMonth(month, year)
{
  var daysInMonth = daysInMonths[month];
  if ((month == 1) && (year % 4 == 0))
    daysInMonth = 29;
  return daysInMonth;
}

//====================================================================
// Normalize input to a two digit number
//====================================================================

function normalize(num)
{
  var numstr = num.toString();

  if (numstr.length == 1) {
    return('0' + numstr);
  } else {
    return(numstr);
  }
}

//====================================================================
// Normalize year to a four digit number.
// 80 - 99 are converted to 1980 - 1999
// 00 - 79 are converted to 2000 - 2079
//
// year - a two-digit year
//====================================================================

function normalizeYear(year)
{
  if (year > 1900)
    return year;

  // convert 80 - 99 to 20th century
  if (year >= 80)
    return parseInt(year) + 1900;

  // default to 21st century
  return parseInt(year) + 2000;
}

//====================================================================
// Returns true if dateString is a valid date in the given format.
// If showAlert is true, an alert is displayed for invalid dates
// which gives an example of the correct format.
// format is MM/DD/YYYY
//====================================================================

function isDateValid(dateString, format, showAlert)
{
  // allow empty strings
  if (dateString == "")
    return true;

  var mo, day, year, daysInMonth;
  var isValid = true;
  var errorMsg = "Please enter a date in the form " + format + ".\n\n";
  var separator = '/';
  // validate formats and parse string

  switch (format)
  {
    case "MM/DD/YYYY":
    {
      errorMsg += "Example: April 6, 2001 would be 04/06/2001.";
      if (dateString.length != 10)
	isValid = false;
      if ((dateString.charAt(2) != '/') || (dateString.charAt(5) != '/'))
	isValid = false;

      mo = dateString.substring(0, 2);
      day = dateString.substring(3, 5);
      year = dateString.substring(6, 10);
      break;
    }

    case "MM/DD/YY":
    case "MM-DD-YY": 
	{
		switch (format) {
		 
		 case "MM/DD/YY":
			errorMsg += "Example: April 6, 2001 would be 04/06/01.";
			separator= '/';
			break;

		 case "MM-DD-YY":
			errorMsg += "Example: April 6, 2001 would be 04-06-01.";
			separator= '-';
			break;

		}
		if (dateString.length != 8)
			isValid = false;
		if ((dateString.charAt(2) != separator) || (dateString.charAt(5) != separator))
			isValid = false;
		mo = dateString.substring(0, 2);
		day = dateString.substring(3, 5);
		year = dateString.substring(6, 8);
		year = normalizeYear(year).toString();
		break;
    }

    case "DD.MM.YY":
    {
      errorMsg += "Example: April 6, 2001 would be 06.04.01.";
      if (dateString.length != 8)
	isValid = false;
      if ((dateString.charAt(2) != '.') || (dateString.charAt(5) != '.'))
	isValid = false;

      day = dateString.substring(0, 2);
	  mo = dateString.substring(3, 5);
      year = dateString.substring(6, 8);
      year = normalizeYear(year).toString();
      break;
    }

    case "DD/MM/YY":
    {
      errorMsg += "Example: April 6, 2001 would be 06.04.01.";
      if (dateString.length != 8)
	isValid = false;
      if ((dateString.charAt(2) != '/') || (dateString.charAt(5) != '/'))
	isValid = false;

      day = dateString.substring(0, 2);
	  mo = dateString.substring(3, 5);
      year = dateString.substring(6, 8);
      year = normalizeYear(year).toString();
      break;
    }

    case "YY.MM.DD":
    case "YY-MM-DD":
    case "YY/MM/DD":
    {
		switch (format) {
		 
		 case "YY.MM.DD":
			errorMsg += "Example: April 6, 2001 would be 06.04.01.";
			separator= '.';
			break;

		 case "YY-MM-DD":
			errorMsg += "Example: April 6, 2001 would be 06-04-01.";
			separator= '-';
			break;

		 case "YY/MM/DD":
			errorMsg += "Example: April 6, 2001 would be 06/04/01.";
			separator= '/';
			break;
		}
		if (dateString.length != 8)
			isValid = false;
		if ((dateString.charAt(2) != separator) || (dateString.charAt(5) != separator))
			isValid = false;

      year = dateString.substring(0, 2);
      year = normalizeYear(year).toString();
	  mo = dateString.substring(3, 5);
      day = dateString.substring(6, 8);
      break;
    }

	

    case "MMM-DD-YYYY":
    case "MON-DD-YYYY":
    {
      errorMsg += "Example: April 6, 2001 would be APR-06-2001.";
      if (dateString.length != 11)
	isValid = false;
      if ((dateString.charAt(3) != '-') || (dateString.charAt(6) != '-'))
	isValid = false;

      mo = monthToNumber(dateString.substring(0, 3), "MMM");
      day = dateString.substring(4, 6);
      year = dateString.substring(7, 11);
      break;
    }

    case "DD-MMM-YYYY":
    {
      errorMsg += "Example: April 6, 2001 would be 06-APR-2001.";
      if (dateString.length != 11)
	isValid = false;
      if ((dateString.charAt(2) != '-') || (dateString.charAt(6) != '-'))
	isValid = false;

      day = dateString.substring(0, 2);
      mo = monthToNumber(dateString.substring(3, 6), "MMM");
      year = dateString.substring(7, 11);
      break;
    }

	case "MON-DD-YYYY HH24:MI:SS":
	{
		errorMsg += "Example: April 6 (8:40:15 p.m) would be APR-06-2001 20:40:15";
		if (dateString.length != 20)
			isValid = false;
		if ((dateString.charAt(3) != '-') || (dateString.charAt(6) != '-') || (dateString.charAt(11) != ' ')
				|| (dateString.charAt(14) != ':') || (dateString.charAt(17) != ':')	)
			isValid = false;

		mo = monthToNumber(dateString.substring(0, 3), "MMM");
		day = dateString.substring(4, 6);
		year = dateString.substring(7, 11);
		year = normalizeYear(year).toString();


		break;
	}
	
	case "MON/DD/YYYY HH24:MI:SS":
	{
		errorMsg += "Example: April 6 (8:40:15 p.m) would be APR/06/2001 20:40:15";
		if (dateString.length != 20)
			isValid = false;
		if ((dateString.charAt(3) != '/') || (dateString.charAt(6) != '/') || (dateString.charAt(11) != ' ')
				|| (dateString.charAt(14) != ':') || (dateString.charAt(17) != ':')	)
			isValid = false;

		mo = monthToNumber(dateString.substring(0, 3), "MMM");
		day = dateString.substring(4, 6);
		year = dateString.substring(7, 11);
		year = normalizeYear(year).toString();


		break;
	}

	case "YYYY:MM:DD HH24:MI:SS":
	{
		errorMsg += "Example: April 6 (8:40:15 p.m) would be 2001:04:06 20:40:15";
		if (dateString.length != 19)
			isValid = false;
		if ((dateString.charAt(4) != ':') || (dateString.charAt(7) != ':') || (dateString.charAt(10) != ' ')
				|| (dateString.charAt(13) != ':') || (dateString.charAt(16) != ':')	)
			isValid = false;

		year = dateString.substring(0, 4);
		mo = dateString.substring(5, 7);
		day = dateString.substring(8, 10);
		year = normalizeYear(year).toString();

		break;
	}


	case "YYYY.MM.DD HH24:MI:SS":
	{
		errorMsg += "Example: April 6 (8:40:15 p.m) would be 2001:04:06 20:40:15";
		if (dateString.length != 19)
			isValid = false;
		if ((dateString.charAt(4) != '.') || (dateString.charAt(7) != '.') || (dateString.charAt(10) != ' ')
				|| (dateString.charAt(13) != ':') || (dateString.charAt(16) != ':')	)
			isValid = false;

		year = dateString.substring(0, 4);
		mo = dateString.substring(5, 7);
		day = dateString.substring(8, 10);
		year = normalizeYear(year).toString();

		break;
	}

	case "DD.MON.YYYY HH24:MI":
	{
		errorMsg += "Example: April 6 (8:40:15 p.m) would be 06.APR.2001 20:40";
		if (dateString.length != 17)
			isValid = false;
		if ((dateString.charAt(2) != '.') || (dateString.charAt(6) != '.') || (dateString.charAt(11) != ' ')
				|| (dateString.charAt(14) != ':')	)
			isValid = false;

		day = dateString.substring(0, 2);
		mo = monthToNumber(dateString.substring(3, 6), "MMM");
		year = dateString.substring(7, 11);
		year = normalizeYear(year).toString();

		break;
	}


	case "MM/DD/YYYY HH24:MI":
	{
		errorMsg += "Example: April 6 (8:40:15 p.m) would be 04/06/2001 20:40";
		if (dateString.length != 16)
			isValid = false;
		if ((dateString.charAt(2) != '/') || (dateString.charAt(5) != '/') || (dateString.charAt(10) != ' ')
				|| (dateString.charAt(13) != ':')	)
			isValid = false;

		mo = dateString.substring(0, 2);
		day = dateString.substring(3, 5);
		year = dateString.substring(6, 10);
		year = normalizeYear(year).toString();
		break;
	}




  }

  // make sure date is an actual date

  if (isValid)
  {
    errorMsg = "The date " + dateString + " is invalid.\n\n";
    daysInMonth = getDaysInMonth(mo - 1, year);

    if ((mo < 1) || (mo > 12))
    {
      errorMsg += "The month is invalid.";
      isValid = false;
    }
    else if ((day < 1) || (day > daysInMonth))
    {
      errorMsg = errorMsg + "For " + fullMonths[mo-1] + ", the day must be between 1 and " + daysInMonth + ".";
      isValid = false;
    }
    else if ((year < 1900) || (year > 2200))
    {
      errorMsg += "You entered the year " + year;
      isValid = false;
    }
else if(isValid)
 {var err_msg = "";
  var day_count = 0;
  var year_count = 0;
  for(i=0;i<2;i++)
   {
    for(j=0;j<10;j++)
   {
     if(day.charAt(i)==j)
     {
     day_count++;
     break;
     }
   }
   }

   if(day_count < 2)
   {
    errorMsg += "The date is invalid";
    isValid = false;
    day_count = 0;
   }
   for(i=0;i<4;i++)

   {
     for(j=0;j<10;j++)
     {
     if(year.charAt(i)==j)
     {
      year_count++;
      break;
     }
     }
   }

   if(year_count < 4)
   {
    errorMsg += "\nThe year is invalid";
    isValid = false;
    year_count = 0;
   }
}
}  
// error message for nonexistant dates
  if ((!isValid) && (showAlert))
    alert(errorMsg);

  return isValid;
}


//=============================================================================
// Returns a date one week, one month or one year prior to the inDate object,
// depending on the input string
//=============================================================================

function getPreviousDate(input_date, prev_string)
{
  var difference;
  var input_time = input_date.getTime(); 
  if(prev_string == "yesterday")
    difference = (1 * 24 * 60 * 60 * 1000); // milliseconds in a day	
  if(prev_string == "week")
    difference = (7 * 24 * 60 * 60 * 1000); // milliseconds in a week
  else if(prev_string == "month")
    difference = (30 * 24 * 60 * 60 * 1000); // milliseconds in a month
  else if(prev_string == "year")
    difference = (365 * 24 * 60 * 60 * 1000); // milliseconds in a year

  var prev_time = input_time - difference;
  var prev_day = new Date();    // create a date corresponding to one week, month or year before
  prev_day.setTime(prev_time);  // today's date
  return prev_day;
}