//=========================================================
//
// As of v 5.7.1, WeatherLink will report time as
// hh:mm  (24-hour format) or
// hh:mmx (12 hour format, where x is (a)m or (p)m
// Therefore, test on length to infer time format
// 5 characters = 24h, 6 characters = 12h
//
//=========================================================
  function getUTCData (UTCDateCurr, UTCTimeCurr) {
    if (UTCTimeCurr.length == 6) {
        StationTimeFormat = '12h'}
    else {
        StationTimeFormat = '24h'}
      
    if (StationDateFormat == 'ymd')
    	  {UTCMonth = parseFloat(UTCDateCurr.substring(3,5))
         UTCDay = parseFloat(UTCDateCurr.substring(6,8))
         UTCYear = parseFloat(UTCDateCurr.substring(0,2)) + 2000}
         
    if (StationDateFormat == 'mdy')
    	  {UTCMonth = parseFloat(UTCDateCurr.substring(0,2))
         UTCDay = parseFloat(UTCDateCurr.substring(3,5))
         UTCYear = parseFloat(UTCDateCurr.substring(6,8)) + 2000}
    
	  UTCHour = parseFloat(UTCTimeCurr.substring(0,2))
	  UTCMinute = parseFloat(UTCTimeCurr.substring(3,5))
	  
	  if (StationTimeFormat == '12h') {
	    if (UTCTimeCurr.substring(5,6) == 'a') {
	        if (UTCHour == 12) {
	            UTCHour = 0
	           }
	        else UTCHour = UTCHour
	           }       
	    else {
        if (UTCHour < 12) {
            UTCHour = (UTCHour + 12)
          }
        }
      }
        
	  UTCDecimalHour = (UTCHour + UTCMinute/60)
	  UTCDayOfYear = calcDayOfYear(UTCMonth, UTCDay, UTCYear)
	  UTCDayOfYearDecimal  = UTCDayOfYear +(UTCDecimalHour/24)
	  UTCDayOfWeek =  calcDayOfWeek(UTCDayOfYear, UTCYear)
	  UTCJulianDay = calcJulianDay(UTCYear, UTCDayOfYearDecimal)
	  UTC_JD_String = (Math.round(UTCJulianDay * 1000)) +''
	  UTC_JD_StringDisplay = UTC_JD_String.substring(0,4) + ' ' + UTC_JD_String.substring(4,7)+ '.'+ UTC_JD_String.substring(7,10)
	  UTCLeapYearBoolean = logicLeapYear(UTCYear)
	  if (UTCLeapYearBoolean == 'true') {
        DaysInMonth[2] = 29
        }
    
    getUTCTomorrow(UTCYear, UTCMonth, UTCDay)

    return}
    
function getLSTData (UTCYear, UTCMonth, UTCDay, UTCDecimalHour) {
    LSTYear = UTCYear
    LSTMonth = UTCMonth
    LSTDay = UTCDay
    LSTHour = UTCDecimalHour + UTC_LSTOffset
    TempHour = Math.floor(LSTHour)
    LSTMinute = Math.round((LSTHour-TempHour) * 60)
    LSTHour = TempHour
    
    if (LSTMinute < 0) {
        LSTMinute = LSTMinute + 60,
        LSTHour = LSTHour - 1
        }
        
    if (LSTHour < 0) {
        LSTHour = LSTHour + 24,
        LSTDay = LSTDay - 1
        }
        
    if (LSTDay < 1) {
        if (LSTMonth == 1) {
            LSTYear = LSTYear - 1
            LSTMonth = 12
            LSTDay = 31}
        else {
             LSTMonth = LSTMonth - 1 
             LSTDay = DaysInMonth[LSTMonth]}
        }
    LSTDayOfYear = calcDayOfYear(LSTMonth, LSTDay, LSTYear)
	  LSTDayOfWeek =  calcDayOfWeek(LSTDayOfYear, LSTYear)   
        return}
        
function getLocalTimeData (UTCYear, UTCMonth, UTCDay, UTCDecimalHour, UTCDayOfYearDecimal) {
    calcDSTStartDayOfYear(UTCYear)
    calcDSTEndDayOfYear(UTCYear)
    
    LocalTimeZone = LSTTimeZone
    
    var TempOffset = UTC_LSTOffset
    
    if ((UTCDayOfYearDecimal >= (DSTStartDayOfYear)) && (UTCDayOfYearDecimal < (DSTEndDayOfYear))) {
        LocalTimeZone = LDTTimeZone
        TempOffset = UTC_LDTOffset
        }
        
    
    LocalYear = UTCYear
    LocalMonth = UTCMonth
    LocalDay = UTCDay
    LocalHour = UTCDecimalHour + TempOffset
    LocalSecond = 0
    LocalAMPM = 'a'
    var TempHour = Math.floor(LocalHour)
    LocalMinute = Math.round((LocalHour-TempHour) * 60)
    LocalHour = TempHour
    
    normaliseTimeAndDate(LocalYear, LocalMonth, LocalDay, LocalHour, LocalMinute, 0)
    LocalYear = WorkYear
    LocalMonth = WorkMonth
    LocalDay = WorkDay
    LocalHour = WorkHour
    LocalMinute = WorkMinute
    
    getAMPM(LocalHour, LocalAMPM)    
    LocalHour = WorkHour
    LocalAMPM = WorkAMPM
    
        
	  LocalDayOfYear = calcDayOfYear(LocalMonth, LocalDay, LocalYear)
	  LocalDayOfWeek =  calcDayOfWeek(LocalDayOfYear, LocalYear)
	  
	  logicLeapYear(LocalYear)
	  if (LeapYearBoolean == 'true')
      {LocalDaysRemaining = 366 - LocalDayOfYear}
    else  
      {LocalDaysRemaining = 365 - LocalDayOfYear}
      
    return}
    
function getLSTTomorrow (TempYear, TempMonth, TempDay)
    {
    LocalDayTomorrow = (LocalDay + 1)
    LocalMonthTomorrow = LocalMonth
    LocalYearTomorrow = LocalYear
    normaliseTimeAndDate (LocalYearTomorrow, LocalMonthTomorrow, LocalDayTomorrow, 0, 0, 0)  
    LocalYearTomorrow = WorkYear
    LocalMonthTomorrow = WorkMonth
    LocalDayTomorrow = WorkDay
    LocalDayOfYearTomorrow = calcDayOfYear(LocalMonthTomorrow, LocalDayTomorrow, LocalYearTomorrow)     
    return}
    
function getUTCTomorrow (TempYear, TempMonth, TempDay)
    {
    UTCDayTomorrow = (UTCDay + 1)
    UTCMonthTomorrow = UTCMonth
    UTCYearTomorrow = UTCYear
    normaliseTimeAndDate (UTCYearTomorrow, UTCMonthTomorrow, UTCDayTomorrow, 0, 0, 0)  
    UTCYearTomorrow = WorkYear
    UTCMonthTomorrow = WorkMonth
    UTCDayTomorrow = WorkDay
    UTCDayOfYearTomorrow = calcDayOfYear(UTCMonthTomorrow, UTCDayTomorrow, UTCYearTomorrow)     
    return}
    
function normaliseTimeAndDate (NormYear, NormMonth, NormDay, NormHour, NormMinute, NormSecond) {
	WorkYear=NormYear
	WorkMonth=NormMonth
	WorkDay=NormDay
	WorkHour=NormHour
	WorkMinute=NormMinute
	WorkSecond=NormSecond
	

    if (WorkMinute < 0) {
        WorkMinute = WorkMinute + 60,
        WorkHour = WorkHour - 1
        }

    if (WorkMinute > 59) {
        WorkMinute = WorkMinute - 60,
        WorkHour = WorkHour + 1
        }       
         
    if (WorkHour < 0) {
        WorkHour = WorkHour + 24,
        WorkDay = WorkDay - 1
        }
        
    if (WorkHour > 23) {
        WorkHour = WorkHour - 24,
        WorkDay = WorkDay + 1
        }
        
        
    if (WorkDay < 1) {
        if (WorkMonth == 1) {
            WorkYear = WorkYear - 1
            WorkMonth = 12
            WorkDay = 31}
        else {
             WorkMonth = WorkMonth - 1 
             WorkDay = DaysInMonth[WorkMonth]}
        }
        
    if (WorkDay > DaysInMonth[WorkMonth]) {
        if (WorkMonth > 11) {
            WorkYear = WorkYear + 1
            WorkMonth = 1
            WorkDay = 1}
        else {
             WorkMonth = WorkMonth + 1 
             WorkDay = 1}
        }

	NormYear=WorkYear
	NormMonth=WorkMonth
	NormDay=WorkDay
	NormHour=WorkHour
	NormMinute=WorkMinute
	NormSecond=WorkSecond
	
    return (WorkYear, WorkMonth, WorkDay, WorkHour, WorkMinute, WorkSecond)}

function getAMPM (NormHour, NormAMPM)    
    {
    WorkDay = NormHour
    WorkAMPM = 'a'

    if (WorkHour >= 12) {
        WorkAMPM = 'p'
        }

    if (WorkHour > 12) {
        WorkHour = WorkHour - 12
        }

    if (WorkHour == 0) {
        WorkHour = 12
        }
    return}

function calcJulianDay (Year, DayOfYearDecimal) {    
    JulianDay = 2454101 // Julian Day at 31 Dec 2006, 12 UTC
  	JulianDay = JulianDay + DayOfYearDecimal 
  	JulianDay = JulianDay - 0.5 // Julian Day starts at 12 UTC
  	TempCounter = 2007  //set counter to start at initial Julian Day index above
  	  
    while (TempCounter < Year) {
      logicLeapYear (TempCounter)
	      if (LeapYearBoolean == 'true') {
	  	    JulianDay = JulianDay + 366
	  	    }
	  	  else {
	  	    JulianDay = JulianDay + 365
	  	    }
  	  TempCounter++
  	}
  	return JulianDay}
  	
    
    
	
//=========================================================
//
// Calculates start day of year for DST 
//
//=========================================================
  function calcDSTStartDayOfYear(TestYear) {
    var StartDate = 1
    var Sundays = 0
    var LoopEnd = DSTBeginSunday * 7
    var TempCounter = 0
    while (TempCounter <= LoopEnd) {
	  	TempDate = StartDate + TempCounter
	  	TempDayofYear = calcDayOfYear(DSTBeginMonth, TempDate, TestYear)
	  	TempDayName = calcDayOfWeek(TempDayofYear, TestYear)
	  	if (TempDayName == 'Sunday') {
        Sundays = Sundays + 1}
		  if (Sundays == DSTBeginSunday) {
		    DSTStartDayOfYear = TempDayofYear, TempCounter = LoopEnd}
  	  TempCounter++}
  	DSTStartDayOfYear = DSTStartDayOfYear + BeginTimeLDTinUTC  
	  return DSTStartDayOfYear}
	
//=========================================================
//
// Calculates end date for DST 
//
//=========================================================
  function calcDSTEndDayOfYear(TestYear) {
	  var StartDate = 1
	  var Sundays = 0
	  var LoopEnd = DSTEndSunday * 7
	  var TempCounter = 0
	  while (TempCounter <= LoopEnd) {
	  	TempDate = StartDate + TempCounter
		  TempDayOfYear = calcDayOfYear(DSTEndMonth, TempDate, TestYear)
		  day_name = calcDayOfWeek(TempDayOfYear, TestYear)
		  if (day_name == 'Sunday') {
		    Sundays = Sundays + 1
		    }
		  if (Sundays == DSTEndSunday) {
        DSTEndDayOfYear = TempDayOfYear, TempCounter = LoopEnd
        }
	    TempCounter++	  }
	  DSTEndDayOfYear = DSTEndDayOfYear + EndTimeLDTinUTC    
	  return DSTEndDayOfYear}
	
	
//=========================================================
//
// Calculates first day of a given year
//
//=========================================================
  function calcFirstDayOfWeek(TestYearFirstDay) {
	  var LoopYear = 2007  // Year 2007 started on a Monday
	  FirstDayOfWeek = 1
	  while (LoopYear < TestYearFirstDay) {
	  	FirstDayOfWeek = FirstDayOfWeek + 1
		  logicLeapYear(LoopYear)
		  if (LeapYearBoolean == "true") {
		    FirstDayOfWeek = FirstDayOfWeek + 1}
		  if (FirstDayOfWeek > 7) {
		    FirstDayOfWeek = FirstDayOfWeek - 7}
  	LoopYear++}
	  return FirstDayOfWeek}

//=========================================================
//
// Determines if a given year is a leap year
//
//=========================================================
  function logicLeapYear(TestYearLeap) {
	  LeapYearBoolean = 'false'
	  if (TestYearLeap % 4 == 0) {
	    LeapYearBoolean = 'true'}
	  if (TestYearLeap % 100 == 0) {
	    LeapYearBoolean = 'false'}
	  if (TestYearLeap % 400 == 0) {
	    LeapYearBoolean = 'true'}
	  return}

//=========================================================
//
// Calculates day of the year
//
//=========================================================
  function calcDayOfYear(current_month, current_day, current_year)
	  {logicLeapYear(current_year)
	  i = 1
	  prior_days = 0
	  while (i < current_month) {prior_days = prior_days + DaysInMonth[i], i++}
	  DayOfYear = prior_days + current_day
	  if (current_month > 2) {
      if (LeapYearBoolean == 'true') {
          DayOfYear = DayOfYear +1  }
                            }
	  return DayOfYear}

//=========================================================
//
// Calculates day of week from day of year
//
//=========================================================
  function calcDayOfWeek(DayNo, yy) {
  	week = Math.floor(DayNo / 7)
	  day_in_week = DayNo - (7 * week) + calcFirstDayOfWeek(yy) - 1
	  if (day_in_week == 0) {
	      day_in_week = 7}
	  if (day_in_week > 7) {
	      day_in_week = day_in_week - 7}
	  return DayOfWeekName[day_in_week]}

//=========================================================
//
// Calculates 'friendly' hh:mm:ss from decimal hour
//
//=========================================================
  function calcFriendlyHMS(TempHour, TempDayOfYear) {
  	TempUTCDayHour = TempDayOfYear + (TempHour/24)
  	if ((TempUTCDayHour >= DSTStartDayOfYear) && (TempUTCDayHour <= DSTEndDayOfYear)) {
      DecHour = (TempHour + UTC_LDTOffset)}
    else {DecHour = (TempHour + UTC_LSTOffset)}
  	if (DecHour >= 24) {
        DecHour = DecHour - 24
        }

    DecMin = (DecHour - Math.floor(DecHour))*60
    DecSec = (DecMin - Math.floor(DecMin))*60

    DecHour = Math.floor(DecHour)
    DecMin = Math.floor(DecMin)
    DecSec = Math.round(DecSec)
    
    if (DecSec >= 60) {
        DecSec = DecSec = DecSec - 60
        DecMin = DecMin + 1
        }
       
    if (DecMin >= 60) {
        DecMin = DecMin = DecMin - 60
        DecHour = DecHour + 1
        }

  	if (DecHour >=24) {
        DecHour=DecHour -24
        }

    if (DecHour >= 12) {
        DecAMPM = 'p'
        }
    else {DecAMPM = 'a'}
    
    if (DecHour > 12) {
        DecHour = DecHour - 12
        }

    if (DecHour < 1) {
        DecHour = 12
        }
          
    return (DecHour, DecMin, DecSec, DecAMPM)
    }

//=========================================================
//
// Calculates hh:mm:ss delta between two decimal hours
//
//=========================================================

  function calcDeltaT(HourLast, HourFirst) {
  	DeltaTHour = (HourLast - HourFirst)
    DeltaTMin = (DeltaTHour - Math.floor(DeltaTHour))*60
    DeltaTSec = (DeltaTMin - Math.floor(DeltaTMin))*60

    DeltaTHour = Math.floor(DeltaTHour)
    DeltaTMin = Math.floor(DeltaTMin)
    DeltaTSec = Math.round(DeltaTSec)
    
    if (DeltaTSec >= 60) {
        DeltaTSec = DeltaTSec = DeltaTSec - 60
        DeltaTMin = DeltaTMin + 1
        }
       
    if (DeltaTMin >= 60) {
        DeltaTMin = DeltaTMin = DeltaTMin - 60
        DeltaTHour = DeltaTHour + 1
        }

    return (DeltaTHour, DeltaTMin, DeltaTSec)
    }

    
//***********************************************************************/
//* Name:    calcJDSince2008							*/
//* Type:    Function									*/
//* Purpose: calculate the number of days since 2008.0 Jan 0 00h TT	(jd 2454 465.5)			*/
//* Arguments:										*/
//*   jd1 : current value of the Julian day				*/
//* Return value:										*/
//*   the number of days since 2008.0 Jan 0 00h TT			*/
//***********************************************************************
	
	function calcJDSince2008(jd1)
	{
    JDSince2008 = (jd1 - 2454465.5);
    return JDSince2008;
  }
  

//***********************************************************************/
//* Name:    calcJCentSince2000							*/
//* Type:    Function									*/
//* Purpose: calculate the number of Julian centuries since the last Epoch [2000.0]	(jd 2454 465.5)			*/
//* Arguments:										*/
//*   jd1 : current value of the Julian day				*/
//* Return value:										*/
//*   the number of Julian centuries since Epoch 2000.0			*/
//***********************************************************************
	
	function calcJCentSince2000(jd1)
	{
    JCentSince2000 = ((jd1 - 2451545)/36525);  
    return JCentSince2000;
  }