var verifyIBFButtonEnabled = true;

var ResourceID8676 = "You cannot perform this action in Preview Mode";
//----------------------------------------------------------------
//  Author:			Matt Kelsey
//  Procedure Name:	GetCountField
//  Description:	Gets the hidden Count Field that is laid down for Multi Select Checkboxes and Radio Buttons
//  Arguments:		field   	- field
//  Return Value:	Hidden Field
//  Comments:		(none)
//----------------------------------------------------------------
function GetCountField(Field)
{
	var CountField = Field.id;
	var tempIndex = CountField.lastIndexOf("_");
	CountField = CountField.substring(0,tempIndex);
	var CountFieldHiddenField = CountField + "__Count";
	return document.getElementById(CountFieldHiddenField);
}
//----------------------------------------------------------------
//  Author:			Matt Kelsey
//  Procedure Name:	VerifyOneChecked
//  Description:	Verifies that at least one checkbox or radio button is checked
//  Arguments:		CountField   	- Hidden Count Field
//  Return Value:	Bool indicating whether at least one option has been selected
//  Comments:		(none)
//----------------------------------------------------------------
function VerifyOneChecked(CountField)
{
	var Checked = false;
	var tempIndex = CountField.id.lastIndexOf("_");
	FieldToVerify = CountField.id.substring(0,tempIndex);

	for (var x=0;x<CountField.value;x++)
	{
		var tempField = FieldToVerify + x;
		if(document.getElementById(tempField).checked)
			Checked = true;								
	}							

	return Checked;
}
//----------------------------------------------------------------
//  Author:			Matt Kelsey
//  Procedure Name:	ValidateFormat
//  Description:	Validates the format of Date/Time/Number Text boxes for InboundForms
//  Arguments:		(none)
//  Return Value:	
//  Comments:		(none)
//----------------------------------------------------------------
function ValidateFormat()
{
	var blnValid = false;
	for (var FieldCounter=0; FieldCounter < document.forms[0].length; FieldCounter++) 
	{
		var formField = document.forms[0].elements[FieldCounter];
		if (IsElementVisible(formField))
		{
			if (formField.name && formField.name.substring(0,5) == "field")
			{
				//Only Text And Text Areas can have format
				if(formField.name.search('ROWYYY')<0)
				{
					if((formField.type == "text") || (formField.type == "textarea"))
					{
						switch(formField.subtype)
						{
							case "atDateOnly":
								blnValid = Date_Validate(formField);
								break;
							case "atTimeOnly":
								blnValid = Time_Validate(formField);
								break;
							case "dtSingleDouble":
								blnValid = Number_Validate(formField);
								break;		
							case "Email":
								blnValid = Email_Validate(formField);
								break;	
							case "atNone":
								blnValid = true;
								break;
							default:
								blnValid = true;
								break;
						}
						if(!blnValid)
						{
							return false;
						}
					}
				}
			}
		}
	}
	return true;
}
function Email_Validate(formField)
{ 
	var emailFormatVal = formField.format;

	if (formField.value.length > 0) 
	{
		if (emailFormatVal.length > 0)
		{
			var jw = new jsWS('ccsubmission.ashx', 'ValidateEmail');
			jw.SetSync();
			jw.addArg('EmailAddress', formField.value);
			jw.send();
			if (jw.responseText == "true")
				return (true);
			else
			{
				popMessage(ResourceID541,formField);
				return (false);
			}
		}
		else
		{
			var expSyn = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;
			if ( expSyn.exec(formField.value) != null)
			{
				return (true)
			}
			else
			{
				popMessage(ResourceID541,formField);
				return (false)
			}
		}
	}
	return (true)
}

function IsElementVisible(elm)
{	
	var isVis = true;
	if (elm.style.display == "none")
		isVis = false;
	else if (elm.style.visibility != "visible" && elm.style.visibility != "")
		isVis = false;
	else if (elm.type == "hidden")
		isVis = false;
	else
	{
		try
		{
			elm.focus();
		}
		catch (e)
		{
			isVis = false;
		}
		
		if (isVis)
		{
			var blockDivElm;
			var prntElm = GetParentElement(elm);
			while (prntElm != null && blockDivElm == null)
			{
				// Not the best way to identify this....but it's the best we can do for now....
				if (prntElm.className == "publishedContentBlock")
					blockDivElm = prntElm;
				prntElm = GetParentElement(prntElm);
			}
			if (blockDivElm != null && (blockDivElm.style.display == "none" || (blockDivElm.style.visibility != "visible" && elm.style.visibility != "")))
				isVis = false;
		}
	}
	
	return isVis;
}

function GetParentElement(currentElm)
{
	if (currentElm.parentElement)
		return currentElm.parentElement;
	else
		return currentElm.parentNode;
}

//----------------------------------------------------------------
//  Author:			Matt Kelsey
//  Procedure Name:	ValidateRequired
//  Description:	Validates the Required fields
//  Arguments:		(none)
//  Return Value:	
//  Comments:		(none)
//----------------------------------------------------------------
function ValidateRequired()
{
	var CountField;
	var blnOneChecked = false;
	
	for (var i=0; i < document.forms[0].length; i++) 
		{
			
			var formField = document.forms[0].elements[i];
			if (IsElementVisible(formField))
			{
				if(formField.validity != null)
				{
					if(!formField.validity.valid)
					{
						document.forms[0].elements[i].required = null;
					}
				}
				
				if (formField.name && formField.name.substring(0,5) == "field") 
				{
					var temp = "req" + formField.name;
					
					try{
					if(eval("typeof(" + temp + ")") != "undefined")
						{
							if(formField.name.search('ROWYYY')<0)
							{
								if((formField.type == "text" && trim(formField.value) == "") || 
								(formField.type == "textarea" && trim(formField.value) == "") ||
								(formField.type == "select-one" && formField.length == 0)||
								(formField.type == "select-one" && formField.options[formField.selectedIndex].value == "") ||
								(formField.type == "select-multiple" && formField.selectedIndex == "-1"))
								{
									sMsg = ResourceID520;
									popMessage(sMsg,formField);
									return false;
								}
								else if(formField.type == "radio")
								{
									CountField = GetCountField(formField);
									
									if(eval(CountField)!=null)
										blnOneChecked = VerifyOneChecked(CountField);
										
									if(!blnOneChecked)
									{
										sMsg = ResourceID520;
										popMessage(sMsg,formField);
										return false;
									}
										
								}
								else if(formField.type == "checkbox")
								{
									
									CountField = GetCountField(formField);
							
									if(eval(CountField) != null)//Could be MultiSelect, Checkbox
									{
										blnOneChecked = VerifyOneChecked(CountField);	
										if(!blnOneChecked)
										{
											sMsg = ResourceID520;
											popMessage(sMsg,formField);
											return false;
										}
									}		
									else
									{
										if(!formField.checked)
										{
											sMsg = ResourceID520;
											popMessage(sMsg,formField);
											return false;
										}						
									}									
								}
							}
						}
					}
					catch (err) {	
					}			
				}
			}
		}
		
		return true;
}

//-----------------------------------------------------------------------------------------------------------
//  Author:			Sally Xu
//  Procedure Name:	unformatfield
//  Description:	Unformats a given HTML form field
//  Arguments:		fieldname - the name of the form field to be unformatted
//  Return Value:	(none)
//  Comments:		This function assumes that the form field in question has
//					populated format, unformat and subtype attributes
//-----------------------------------------------------------------------------------------------------------
function unformatfield(fieldname) {
	var sInput = "";
	var format = "";
	var unformat = "";
	var subtype = "";

	//Read in the field value, format, unformat and subtype strings
	sInput = fieldname.value;
	format = fieldname.format;
	unformat = fieldname.unformat;
	subtype = fieldname.subtype;
	switch(subtype)
	{
		case "atDateOnly":
			fieldname.value = eval("Date_Unformat(sInput, format)");
			break;
		case "dtSingleDouble":
			fieldname.value = eval("Number_Unformat(sInput, format)");
			break;			
	}
	//Call the appropriate unformat function based on the field type
	

}


//-----------------------------------------------------------------------------------------------------------
//  Author:			Sally Xu
//  Procedure Name:	unformatform
//  Description:	Unformats the data in an HTML form
//  Arguments:		formname - the name of the form to be unformatted
//  Return Value:	(none)
//  Comments:		This function will unformat any form field that is populated 
//					and has a specified format attribute.  This function assumes
//					that any form field that has a populated format attribute will
//					also have populated unformat and subtype attributes.
//-----------------------------------------------------------------------------------------------------------
function unformatform(formname) {
	//Loop through the form elements and unformat those that have specified formats
	for (var z=0; z < document.forms[0].length; z++) 
	{
		var field = document.forms[0].elements[z];
		if ((field.value != "") && (field.format)) 
		{
			if (field.format != "")
			{
				unformatfield(field);
			}
		}
		else if ((field.getAttribute("DataType")) && (field.getAttribute("FormatType") == "atDateOnly")) 
		{
			unformatfield(field);
		}
	}

}

//Used to validate inbound form pages
function validateIBFpage(SimpleBrowser)
{
	var required;
	var format;
	if(SimpleBrowser)
	{
	    required = ValidateRequired();
	    if(!required)
			return false;
		format = ValidateFormat();
		if(!format)
			return false
		
		if(required || format)
		{
			unformatform(document.forms[0]);
			return true;
		}
		else
		{
			return false;
		}
	}
	else
	{
		return true;
	}
}

// VerifyForwardToAFriend
//
// Created By: Paul Burrous
//
// This function is used to verify that the friend name and the friend 
// email are both filled in.  
function VerifyForwardToAFriend(source, arguments) 
{
  RowNum = source.getAttribute("RowNum");  
	NameControl = document.getElementById("fieldFriendName_jsID_" + RowNum);
	EMailControl = document.getElementById("fieldFriendEMail_jsID_" + RowNum);	
	if ((NameControl.value.length > 0) ^ (EMailControl.value.length > 0)) 
		arguments.IsValid = false;
	else
	  arguments.IsValid = true;	
}

// Verifies the inbound form
function verifyIBF(simpleBrowser, buttonGroupID, contentBlockID)
{
	if (!IsMicrositePreview())
	{
		if (verifyIBFButtonEnabled)
		{
			verifyIBFButtonEnabled = false;
			if (validateIBFpage(simpleBrowser)==true && Page_ClientValidate()==true)
			{
				if (contentBlockID)
				{
					var contentBlkElm = document.getElementById("fieldcontentBlockId");
					contentBlkElm.value = contentBlockID;
				}

				if (buttonGroupID)
				{
					var btngrpElm = document.getElementById("fieldbtnGroupId");
					btngrpElm.value = buttonGroupID;
				}
				document.forms[0].action = document.URL;
				document.forms[0].submit();
			}
			else
				verifyIBFButtonEnabled = true;
		}
	}
	else
		alert(ResourceID8676);
}

function cancelIBF(cancelUrl)
{
	if (!IsMicrositePreview())
	{
		alert('You have not updated this Form.  Return to this page at your convenience.');
		document.location = cancelUrl;
	}
	else
		alert(ResourceID8676);
}

function resetIBF()
{
	document.forms[0].reset();
}

function RegisterEventForControl(elem, functionName, eventName)
{
	var allowEditEventName = true;
	var evtName = "onblur";
	if (typeof(eventName) != "undefined")
	{
		evtName = eventName;
		allowEditEventName = false;
	}
	
		
	var elm;
	if (typeof(elem) != "object")
		elm = document.getElementById(elem);
	else
		elm = elem;
		
	if (elm)
	{
		if (allowEditEventName)
		{
			var typeVal = "";
			if (elm.getAttribute("type"))
				typeVal = elm.getAttribute("type").toLowerCase();
			
			if (elm.tagName.toLowerCase() == "select" && allowEditEventName) 
				evtName = "onchange";		
			else if (elm.tagName.toLowerCase() == "input" && (typeVal.toLowerCase() == "checkbox" || typeVal.toLowerCase() == "radio"))
				evtName = "onclick";
		}
			
		if (elm.addEventListener)
		{
			if (evtName.indexOf("on") == 0)
				evtName = evtName.substring(2);
							
			elm.addEventListener(evtName, eval(functionName), false); 
		} 
		else if (elm.attachEvent)
		{
			elm.attachEvent(evtName, eval(functionName));
		}
	}
}

RegisterEventForControl(window, "FalseReturner", "onload");
RegisterEventForControl(window, "HandleRequiredAttrForFirefox", "onload");

function FalseReturner()
{
	var anchors = document.getElementsByTagName("a");
	if (anchors)
	{
		for (var i = 0; i < anchors.length; i++)
		{
			var aTag = anchors[i];
			var aTagOnClk = aTag.onclick + "";
			if (aTagOnClk && aTagOnClk.indexOf("verifyIBF") >= 0)
			{
				RegisterEventForControl(aTag, "FalseReturn", "onclick");
			}
		}
	}
}

function HandleRequiredAttrForFirefox()
{
	if (document.getElementById("fieldbtnGroupId"))
	{
		RemoveRequiredForTag("input");
		RemoveRequiredForTag("textarea");
		RemoveRequiredForTag("select");
	}
}

function RemoveRequiredForTag(tagName)
{
	var inputElms = document.getElementsByTagName(tagName);
	if (inputElms)
	{
		for (var i = 0; i < inputElms.length; i++)
		{
			var inputTag = inputElms[i];
			
			var reqVal;
			var reqAttr = inputTag.getAttribute("required");
			if (!reqAttr)
				reqVal = inputTag.required;
			else
				reqVal = reqAttr;
				
			inputTag.setAttribute("tgReq", reqVal);
			inputTag.removeAttribute("required");
		}
	}
}

function FalseReturn()
{
	return false;
}

function IsMicrositePreview()
{
	if (typeof(msPreviewPage) == "undefined" || msPreviewPage == false)
		return false;
	else
		return true;
}

function FireEvent(elementName, eventName)
{
	var elm = document.getElementById(elementName);
	if (elm)
	{
		if (elm.fireEvent)
		{
			elm.fireEvent(eventName);	
		}
		else if (document.createEvent)
		{
			var evt = document.createEvent('HTMLEvents');
			if (evt.initEvent)
			{
				var tmpEvtName = eventName.substring(2);				
				evt.initEvent(tmpEvtName, false, false);
			}
			if (elm.dispatchEvent)
			{
				elm.dispatchEvent(evt);
			}
		}
	}
}