//Argus Calendar  


 
ArgusCalendar = function (calendarContainerName, dateSelectionType, submitFormOnOk, allowRangeSelection, mode, 
	availableRange, restrictRangeStartDate, restrictRangeEndDate, restrictRangeDates, allowWeekendSelect,
	 nullDateValue, todayValue, allowEmptyDate, enable)
{
	ArgusCalendarStorage.Calendars.length++;
 	ArgusCalendarStorage.Calendars[ArgusCalendarStorage.Calendars.length - 1] = new ArgusCalendarStorage(calendarContainerName, this);
 	this.container = document.getElementById(calendarContainerName);
	this.dateSelectionType = dateSelectionType;
	this.submitFormOnOk = submitFormOnOk;
	this.allowRangeSelection = allowRangeSelection;
	this.mode = mode;
	this.availableRange = availableRange;
	this.restrictRangeStartDate = restrictRangeStartDate;
	this.restrictRangeEndDate = restrictRangeEndDate;
	
	this.restrictRangeDates = restrictRangeDates;
	
	
	this.allowWeekendSelect = allowWeekendSelect;
	this.nullDateValue = nullDateValue;
	this.todayValue = todayValue;
	this.allowEmptyDate = allowEmptyDate;
	//ArgusCalendar.SortDates(this.restrictRangeDates);
	
	this.views = new Array(2);
	this.views[0] = new ArgusCalendarView(1, this);
	this.views[1] = new ArgusCalendarView(2, this);
	
	this.showClearButton();
	this.InitGlobalVariables();
	
	this.isDisabled = !enable;
			
	/*
  if (!allowRangeSelection)
  {
		visible(findElementByNamePart('ac_cal_2', this.container).id, '0');
		visible(findElementByNamePart('ac_captions', this.container).id, '0');
		visible(findElementByNamePart('ac_lbl_to', this.container).id, '0');
		visible(findElementByNamePart('ac_lbl_from', this.container).id, '0');
		visible(findElementByNamePart('ac_date_2', this.container).id, '0');
  }
  else
  {
		visible(findElementByNamePart('ac_cal_2', this.container).id, '1');
		visible(findElementByNamePart('ac_captions', this.container).id, '1');
		visible(findElementByNamePart('ac_lbl_to', this.container).id, '1');
		visible(findElementByNamePart('ac_lbl_from', this.container).id, '1');
		visible(findElementByNamePart('ac_date_2', this.container).id, '1');
  }
  */
  
  if (this.mode == ArgusCalendar.FlatMode)
  {
  /*
		findElementByNamePart('ac_popup', this.container).className = 'ddparent';
		visible(findElementByNamePart('ac_flat', this.container).id, '0');
		visible(findElementByNamePart('ac_popup', this.container).id, '1');
		visible(findElementByNamePart('ac_buttons', this.container).id, '0');
		visible(findElementByNamePart('ac_popup_caption', this.container).id, '0');
		findElementByNamePart('ac_popup', this.container).className = 'ddflat';
		*/
		this.views[0].Show();
		this.views[1].Show();
  }
  
  if(this.isDisabled){ this.Disable(); }
  
  addEvent(findElementByNamePart('ac_flat', this.container), "click", ArgusCalendar.ShowCalendar);
  
  addEvent(findElementByNamePart('ac_hide', this.container), "click", ArgusCalendar.HideCalendar);
  addEvent(findElementByNamePart('ac_cancel', this.container), "click", ArgusCalendar.HideCalendar);
  addEvent(findElementByNamePart('ac_ok', this.container), "click", ArgusCalendar.OkButtonClicked);
  addEvent(findElementByNamePart('ac_clear_ref', this.container), "click", ArgusCalendar.ClearButtonClicked);
};

ArgusCalendar.prototype.Disable = function()
{ 
	this.isDisabled = true; 
	this.views[0].Disable();
  this.views[1].Disable();
};
ArgusCalendar.prototype.Enable = function()
{ 
	this.isDisabled = false; 
	this.views[0].Enable();
  this.views[1].Enable();
};

ArgusCalendar.prototype.showPopupCalendar = function()
{
	if(this.isDisabled){ return; }
	
	this.views[0].Show();
  this.views[1].Show();

	var div = findElementByNamePart('ac_popup', this.container);
	var frame = findElementByNamePart('ac_framePopup', this.container);
  
  this.UpdateZIndexes(true);
  showDropDownDiv(this.container.id, div.id);
  if(frame != null){ showDropDownDiv(this.container.id, frame.id); }
}

ArgusCalendar.prototype.hidePopupCalendar = function()
{
	if(this.isDisabled){ return; }
	
  visible(findElementByNamePart('ac_popup', this.container).id, '0');
  
  this.UpdateZIndexes(false);
  
  var frame = findElementByNamePart('ac_framePopup', this.container);
  if(frame != null)
  {
		frame.style.left = -500; 
  }
}

ArgusCalendar.prototype.acceptSelectedDates = function()
{ 
if (this.ValidateDateObject(this.views[0].date, true))
{
  	this.views[0].notifyDateChanged();
}
  if (this.ValidateDateObject(this.views[1].date, true))
  	this.views[1].notifyDateChanged();
//  this.views[0].notifyDateChanged();
//  this.views[1].notifyDateChanged();
  //var d1 = this.ParseDate(this.views[0].dateInput.value);
  //var d2 = this.ParseDate(this.views[1].dateInput.value);
  /*alert(d1 + '|' + d2);
  if(d2 < d1)
  {
		alert(this.views[1].dateInputStore.value + '|' + this.views[1].dateInput.value + '|' + this.views[0].dateInput.value);
  		var tmpVal = this.views[1].dateInput.value;
		this.views[1].dateInputStore.value = this.views[1].dateInput.value = this.views[0].dateInput.value;
		this.views[0].dateInputStore.value = this.views[0].dateInput.value = tmpVal;
		alert(this.views[1].dateInputStore.value + '|' + this.views[1].dateInput.value + '|' + this.views[0].dateInput.value);
  }*/
}


ArgusCalendar.prototype.showClearButton = function()
{
	var clearVisible = 0;
	
	if(this.views[0] == null || this.views[1] == null)
		return;
  
    if ( this.views[0].NeedClearButton() || (this.allowRangeSelection && this.views[1].NeedClearButton()))
		clearVisible = 1;
	
	visible(findElementByNamePart('ac_clear', this.container).id, clearVisible);
}

ArgusCalendar.prototype.FormatDate = function(date)
{
	var d = date.getDate();
  if (d < 10)
	 d = '0' + d;
	
	if (this.dateSelectionType == ArgusCalendar.DayMonthYear)
		return d + '-' + ArgusCalendar.ShortMonthNames[date.getMonth()] + '-' + date.getFullYear();
	else 
		return ArgusCalendar.ShortMonthNames[date.getMonth()] + '-' + date.getFullYear();
}

ArgusCalendar.prototype.FormatFullMonthDate = function(date)
{
	var d = date.getDate();
  if (d < 10)
	 d = '0' + d;
	 
	if (this.dateSelectionType == ArgusCalendar.DayMonthYear)
		return d + '-' + ArgusCalendar.MonthNames[date.getMonth()] + '-' + date.getFullYear();
	else 
		return ArgusCalendar.MonthNames[date.getMonth()] + '-' + date.getFullYear();
}

ArgusCalendar.prototype.ValidateDatesInInputs = function(supressAlerts)
{
	return this.ValidateDates(this.views[0].dateInput.value, this.views[1].dateInput.value, supressAlerts);
}

ArgusCalendar.prototype.ValidateDatesInPopup = function(supressAlerts)
{
	return this.ValidateDates(this.FormatDate(this.views[0].date), this.FormatDate(this.views[1].date), supressAlerts);
}

ArgusCalendar.prototype.ValidateDates = function(date1, date2, supressAlerts)
{
	var result = true;
	if (this.allowRangeSelection)
	{
		if(!(this.ValidateDate(date1, supressAlerts) && this.ValidateDate(date2, supressAlerts)))
		{
			result = false;
		}
	}
	else
	{
		result = this.ValidateDate(date1, supressAlerts);
	}
	return result;	
}

ArgusCalendar.prototype.ValidateDate = function(date, supressAlerts)
{
	if (this.allowEmptyDate && date == '')
		return true;
		
  var y;
	var m = -1;
	var d;
	
	var result = true;
	var newDate;
	
	var tmp = date.split('-');
	var mName = '';
	if (this.dateSelectionType == ArgusCalendar.DayMonthYear)
	{
		if (tmp.length == 3)
		{
			y = tmp[2];
			mName = tmp[1].toLowerCase();
			d = tmp[0];
		}
		else
		{
			result = false;
		}
	}
	else
	{
		if (tmp.length == 2)
		{
			y = tmp[1];
			mName = tmp[0].toLowerCase();
			d = 1;
		}
		else
		{
			result = false;
		}
	}
	
	if (result)
	{
	  if (!isNaN(Number(mName)))
	  {
			m	= Number(mName) - 1;
	  }
	  else
	  {
			for (var i = 0; i < ArgusCalendar.ShortMonthNames.length; i++)
			{
				if (ArgusCalendar.ShortMonthNames[i].toLowerCase() == mName)
				{
					m = i;
					break;
				}
			}
		}
		result = (m > -1);
	}
	
	{
		newDate = new Date(y, m, d);
		if (newDate.getFullYear() != y || newDate.getMonth() != m || newDate.getDate() != d)
		{
			result = false;
		}
	}
	
		
	if (!result)
	{
		if (!supressAlerts)
			ArgusCalendar.ShowInvalidDateMessage();
		return false;
	}
	
	return this.ValidateDateObject(newDate, supressAlerts);
	
}

ArgusCalendar.prototype.ValidateDateObject = function(date, supressAlerts)
{
	if (this.availableRange == ArgusCalendar.AvailableRangeRestrictToRange)
	{
		if (date < this.restrictRangeStartDate || date > this.restrictRangeEndDate)
		{
			if (!supressAlerts)
				alert(ArgusCalendar.DateSelDateIsNotInRange);
			return false;
		}
	}
	
	if (this.availableRange == ArgusCalendar.AvailableRangeRestrictToDates)
	{
		var isFound = false;
		for (var i = 0; i < this.restrictRangeDates.length; i++)
		{
			var d = this.restrictRangeDates[i];
			if (ArgusCalendar.CompareDates(date, this.restrictRangeDates[i]))
			{
				isFound = true;
				break;
			}
		}

		if (!isFound)
		{
			if (!supressAlerts)
				alert(ArgusCalendar.DateSelDateIsNotInRange);
			return false;
		}
	}
	
	if (!this.allowWeekendSelect && this.availableRange != ArgusCalendar.AvailableRangeRestrictToDates)
	{
		var dayOfWeek = date.getDay();
		if (dayOfWeek == 0 || dayOfWeek == 6)
		{
			if (!supressAlerts)
				alert(ArgusCalendar.DateSelDateIsNotInRange);
			return false;
		}
	}
	
	return true;
}

ArgusCalendar.prototype.ParseDate = function(date)
{
  var y = (new Date()).getFullYear();
	var m = (new Date()).getMonth();
	var d = (this.dateSelectionType == ArgusCalendar.DayMonthYear) ? (new Date()).getDate() : 1;
		
	var mName = '';
	var tmp = date.split('-');
	
	if (this.dateSelectionType == ArgusCalendar.DayMonthYear && tmp.length == 3)
	{
		y = tmp[2];
		mName = tmp[1].toLowerCase();
		d = tmp[0];
	}
	else if (tmp.length == 2)
	{
		y = tmp[1];
		mName = tmp[0].toLowerCase();
	}
	
	if (mName != '' && !isNaN(Number(mName)))
	{
		m	= Number(mName) - 1;
	}
	else
	{
		for (var i = 0; i < ArgusCalendar.ShortMonthNames.length; i++)
		{
			if (ArgusCalendar.ShortMonthNames[i].toLowerCase() == mName)
			{
				m = i;
				break;
			}
		}
	}
	
	return new Date(y, m, d);
}


ArgusCalendar.ShowInvalidDateMessage = function()
{
	alert(ArgusCalendar.DateSelDateIsNotValid);
}


ArgusCalendar.CompareDates = function(date1, date2)
{
	return date1.getFullYear() == date2.getFullYear() && date1.getMonth() == date2.getMonth() && date1.getDate() == date2.getDate();
}

ArgusCalendar.ClientValidate = function(source, arguments)
{
	arguments.IsValid = true;
  //arguments.IsValid = 
	//	ArgusCalendarStorage.FindCalendarByTopContainer(ArgusCalendarView.findTopContainer(source).id).ValidateDatesInInputs(true);
}

ArgusCalendar.MaxDaysInMonth = function(year, month)
{
 return (new Date(parseInt(year), parseInt(month) + 1, 0)).getDate();
}

ArgusCalendar.MaxDaysInMonthByDate = function(date)
{
 return ArgusCalendar.MaxDaysInMonth(date.getFullYear(), date.getMonth());
}

ArgusCalendar.ShowCalendar = function(ev)
{
	var calV = ArgusCalendarView.getCalendarFromEvent(ev);
	var prefx = calV.container.id.substring(0, calV.container.id.indexOf("_ac_top_cal"));
	try
	{
		var str2Eval = eval(prefx + 'ClientOnShow');
		eval('str2Eval = ' + str2Eval);
	}
	catch(ex)
	{
	}
	calV.showPopupCalendar();
	return false;
}

ArgusCalendar.HideCalendar = function(ev)
{
	var calV = ArgusCalendarView.getCalendarFromEvent(ev);
	var prefx = calV.container.id.substring(0, calV.container.id.indexOf("_ac_top_cal"));
	try{var str2Eval = eval(prefx + 'ClientOnHide');
	eval(str2Eval);}
	catch(ex){}
	calV.hidePopupCalendar();
	return false;
}

ArgusCalendar.DisableEvent = function(e)
{
	// to be compatible with all browser types
	try { e.returnValue = false; } catch(ex) {}
	try { e.cancelBubble = true; } catch(ex){}
	try { e.stopPropagation(); } catch(ex) {}
	try { e.preventDefault(); } catch(ex) {}
} 

ArgusCalendar.ClearButtonClicked = function(ev)
{
	var cal = ArgusCalendarView.getCalendarFromEvent(ev);
	cal.views[0].dateInputStore.value = '';
	cal.views[0].dateInput.value = 'Select date';
	cal.views[1].dateInputStore.value = '';
	cal.views[1].dateInput.value = 'Select date';
	
	cal.showClearButton();
}

ArgusCalendar.OkButtonClicked = function(ev)
{
	var cal = ArgusCalendarView.getCalendarFromEvent(ev);
	var prefx = cal.container.id.substring(0, cal.container.id.indexOf("_ac_top_cal"));
	try{var str2Eval = eval(prefx + 'ClientOnHide');
	eval(str2Eval);}
	catch(ex){}
	//if (cal.ValidateDatesInPopup())
	//{
		cal.acceptSelectedDates();
		cal.hidePopupCalendar();
		
		if (!cal.submitFormOnOk)
		{
			DisableEvent(ev);
			return false;
		}
		return true;
	//}
	DisableEvent(ev);
	return false;
}

ArgusCalendar.SortDates = function(arDates)
{
	var tmp;
	for (i = arDates.length -1; i >= 0; i--)
	{
		for (j = 0; j <= i -1; j++)
		{
			if (arDates[j] > arDates[j + 1])
			{
				tmp = arDates[j];
				arDates[j] = arDates[j + 1];
				arDates[j + 1] = tmp;
			}
		}
	}
}

ArgusCalendar.prototype.InitGlobalVariables = function()
{
	if(window.MaxZIndex_for_ArgusCalendar == null)
	{
		window.MaxZIndex_for_ArgusCalendar = 1;			
	}
	if(window.Count_of_VisibleArgusCalendar == null)
	{
		window.Count_of_VisibleArgusCalendar = 0;			
	}
		
	window.Count_of_VisibleArgusCalendar++;
};

ArgusCalendar.prototype.UpdateZIndexes = function(isShow)
{
	var div = findElementByNamePart('ac_popup', this.container);
	var frame = findElementByNamePart('ac_framePopup', this.container);
	
	if(div == null || frame == null){ return; }
	if(isShow)
	{
		Count_of_VisibleArgusCalendar++;
		window.MaxZIndex_for_ArgusCalendar += 3;							
	}
	else
	{
		Count_of_VisibleArgusCalendar--;
		if(frame.style.zIndex == window.MaxZIndex_for_ArgusCalendar && frame.style.zIndex > 3)
		{
			window.MaxZIndex_for_ArgusCalendar -= 3;
		}	
	}
		
	if(Count_of_VisibleArgusCalendar == 0)
	{
		window.MaxZIndex_for_ArgusCalendar = 1;
	}
		
	frame.style.zIndex = window.MaxZIndex_for_ArgusCalendar;
	div.style.zIndex = window.MaxZIndex_for_ArgusCalendar + 1;
};

ArgusCalendar.prototype.AddNewRestrictRangeDates = function(newRange) {
    this.AcceptRestrictRangeDates(newRange);
    this.views[0].printDays();
}

ArgusCalendar.prototype.AcceptRestrictRangeDates = function(newRange) {

    if (this.restrictRangeDates.length == 0) {
        this.restrictRangeDates = newRange;
        return;
    }

    var curYear = 0;
    var skipYear = false;
    var startInsertInx = -1;
    var startFetchInx = 0;
    var lastInsertIndex = 0;

    for (var i = 0; i < newRange.length; i++) {
        if (newRange[i].getFullYear() != curYear) {
            curYear = newRange[i].getFullYear();
            skipYear = false;
            if (startInsertInx > -1)
                lastInsertIndex = startInsertInx + i - startFetchInx;
            startInsertInx = -1;
        }

        if (skipYear) continue;

        if (startInsertInx == -1) {
            for (var j = lastInsertIndex; j < this.restrictRangeDates.length; j++) {
                if (this.restrictRangeDates[j].getFullYear() == curYear) {
                    //skip this year range, because it already exists
                    skipYear = true;
                    break;
                }

                if (this.restrictRangeDates[j].getFullYear() > curYear) {
                    //skip this year range, because it already exists
                    startInsertInx = j;
                    startFetchInx = i;
                    break;
                }
            }

            if (startInsertInx == -1) {
                //if no place found, add range to the end
                this.restrictRangeDates = this.restrictRangeDates.concat(newRange);
                return;
            }
        }

        this.restrictRangeDates.splice(startInsertInx + i - startFetchInx, 0, newRange[i]);

    }
}

ArgusCalendar.prototype.HasRestrictedRangeForYear = function(year) {

    for (var j = 0; j < this.restrictRangeDates.length; j++) {
       if (this.restrictRangeDates[j].getFullYear() == year) 
                    return true;
    }
    return false;

}