///////////////////////////////////////////////////////////////////////////
///// Script         : Form Validation Library      ///////////////////////
///// Developed By   : Aditya Raj                   ///////////////////////
///// Developed For  : http://www.TradeIndia.com   ///////////////////////
///// Date of Start  : 17th September 2004          ///////////////////////
///// Date Completed : 23rd September 2004          ///////////////////////
///// Date Updated   : 23th October   2004          ///////////////////////
/////                                               ///////////////////////
///////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////
//// If you make the below var 1 than it will show data flow, it works perfectly as a debuger
var debug=0;
var max_error=20;
///////////////////////////////////////////////////////////////////////////////////////////////


var show_error=new Array();
var i,z,err,pat,er;
var error=0;
var send='';
var field_val,form_name;
var back_m=0;
var hi=new Array();
var temp_hi=new Array();
var tfname;
var tkname=new Array();
var process=1;

////////////////////////////////////////////////////////////
/// These are updated features to help avoid writing ///////
/// of initial lines now just make a call to these   ///////
/// functions instead.........                       ///////
////////////////////////////////////////////////////////////
														 ///
function start(obj)										 ///
{														 ///
show_error[0]='Please make note of following things :\n';///
form_name=obj.name;										 ///
return;													 ///
}														 ///
														 ///
function finish()										 ///
{														 ///
error_counter('1');										 ///
if(back_m==1){disable();back_m=0;return true;}			 ///
else{error_counter('2');error_counter('0');return false;}///
}														 ///
////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////
//////////// Text field validation code //////////////
//////////////////////////////////////////////////////

if(debug==1)alert("Validation In Testing Mode...\nPlease dont report bug for this\nFor Details : aditya@tradeindia.com");

function validate_text(field_id,field_name,field_type,min,max)
{	

	if(debug==1)alert("in validate text for " + field_id);
	var result=1;
	var message_x;
	////////////////////////////////////////////////////////////////////
	//////// Following pattern for a value to be upper char     ////////
	////////////////////////////////////////////////////////////////////
	var field_val=eval('document.'+form_name+'.'+field_id+'.value');
	if(field_type=='char_up')
	{
		//alert("Char type testing");//temp line
		//The regular expression mentioned below will look for any other value than a to z and - or _
		pat=/^[A-Z_-]+$/
			message_x=' should consist only of characters in upper case A - Z'
			if(field_val.match(pat)){result=0;}
			else{result=1;}

	}



	////////////////////////////////////////////////////////////////////
	//////// Following pattern for a value to be lower char     ////////
	////////////////////////////////////////////////////////////////////

	if(field_type=='char_low')
	{//alert("Char type testing");//temp line
		//The regular expression mentioned below will look for any other value than a to z and - or _
		pat=/^[a-z_-]+$/
			if(field_val.match(pat)){result=0;}
			else{result=1;}
			message_x=' should consist only of characters in lower case a - z'

	}

	////////////////////////////////////////////////////////////////////
	//////// Following pattern for value to be mixtur low and up char //
	////////////////////////////////////////////////////////////////////

	if(field_type=='char')
	{//alert("Char type testing");//temp line
		//The regular expression mentioned below will look for any other value than a to z and - or _
		pat=/^[a-zA-Z\.]+$/
			if(field_val.match(pat)){result=0;}
			else{result=1;}
			message_x=' should consist only of characters only a - z or A - Z'

	}

	////////////////////////////////////////////////////////////////////
	//////// Following pattern for value without symbols              //
	////////////////////////////////////////////////////////////////////

	if(field_type=='no_symbols')
	{//alert("Char type testing");//temp line
		//The regular expression mentioned below will look for any other value than a to z and - or _
		pat=/^[a-zA-Z0-9. -]+$/
			if(field_val.match(pat)){result=0;}
			else{result=1;}
			message_x=' should not consist of any non character values'

	}

	////////////////////////////////////////////////////////////////////
	//////// Following pattern for value to be a valid user id    //////
	////////////////////////////////////////////////////////////////////

	if(field_type=='user_id')
	{//alert("Char type testing");//temp line
		//The regular expression mentioned below will look for any other value than a to z and - or _
		pat=/^[a-z0-9A-Z\_\.\&\-]+$/
			if(field_val.match(pat)){result=0;}
			else{result=1;}
			message_x=' should consist only of characters(upper or lower),numbers (0-9),-,&,. or _ only.'

	}

	////////////////////////////////////////////////////////////////////
	//////// Following pattern for value to be a valid password   //////
	////////////////////////////////////////////////////////////////////

	if(field_type=='password')
	{

		//alert("password type testing");//temp line
		//The regular expression mentioned below will look for any other value than a to z and - or _
		pat=/^[a-z-0-9_]+$/
			if(field_val.match(pat)){result=0;}
			else{result=1;}
			message_x=' should consist only of characters in lower case or numbers 0 - 9'

	}
	////////////////////////////////////////////////////////////////////
	//////// Following pattern for value to be a valid phone number ////
	////////////////////////////////////////////////////////////////////

	if(field_type=='phone')
	{
		//alert("Char type testing");//temp line
		//The regular expression mentioned below will look for any other value than a to z and - or _
		pat=/^[0-9 \/ -]+$/
			if(field_val.match(pat)){result=0;}
			else{result=1;}
			message_x=' should consist only of numbers 0-9, separate multiple numbers by /'
	}

	////////////////////////////////////////////////////////////////////
	//////// Following pattern for value to be a valid phone number ////
	////////////////////////////////////////////////////////////////////

	if(field_type=='mobile')
	{
		//alert("Char type testing");//temp line
		//The regular expression mentioned below will look for any other value than a to z and - or _
		pat=/^[0-9+]+$/
			if(field_val.match(pat)){result=0;}
			else{result=1;}
			message_x=' should consist only of characters 0-9 and +'
	}

	if(field_type=='mob_in')
	{
		//alert("Char type testing");//temp line
		//The regular expression mentioned below will look for any other value than a to z and - or _
		pat=/^\+91[0-9+]{10,10}$/
			if(field_val.match(pat)){result=0;}
			else{result=1;}
			message_x=' should begin with +91 and\nconsist only of characters 0-9 for Indian mobiles'
	}


	if(field_type=='num_coma')
	{
			pat=/^[0-9,]+$/
			if(field_val.match(pat)){result=0;}
			else{result=1;}
			message_x=' should consist only of numericals 0 - 9 and comma'

	}

	if(field_type=='float')
	{
			pat=/^[0-9.]+$/
			if(field_val.match(pat)){result=0;}
			else{result=1;}
			message_x=' should consist only of 0 - 9 and .'

	}

	if(field_type=='nonzero')
	{
			pat=/^[0-9]+$/
			if(field_val.match(pat) && field_val > 0 ){result=0;}
			else{result=1;}
			message_x=' should be a number greater than zero '

	}


	////////////////////////////////////////////////////////////////////
	//////// Following pattern for a value to be integer type   ////////
	////////////////////////////////////////////////////////////////////

	if(field_type=='int')
	{//alert("int type testing");//temp line
		//The regular expression mentioned below will look for any other value than 0 to 9 and - or _
		pat=/^[0-9]*$/
			if(field_val.match(pat)){result=0;}
			else{result=1;}
			message_x=' should consist only of numbers 0 - 9'

	}

	////////////////////////////////////////////////////////////////////
	//////// Following pattern for a value to be char or int    ////////
	////////////////////////////////////////////////////////////////////

	if(field_type=='char_int')
	{//alert("Char and int type testing");//temp line
		//The regular expression mentioned will look for any other value than a to z, 0 to 9 and -or_
		//Specially for validating user id
		pat=/^[a-z0-9]+$/
			if(field_val.match(pat)){result=0;}
			else{result=1;}
			message_x=' should consist only of characters in lower case a - z or numericals 0 - 9'

	}

	////////////////////////////////////////////////////////////////////
	//////// Following pattern for a value to be string          ////////
	////////////////////////////////////////////////////////////////////

	/////////
	// Note : Improve this pattern further
	/////////

	if(field_type=='string')
	{
		if(debug==1)alert("in string pat init");//temp line
		var pat=/^[\s_.=]*$/
			if(field_val.match(pat)){result=1;}
			else{result=0;}
			message_x=' should not be left blank or should consist of some valid values'

	}


	////////////////////////////////////////////////////////////////////
	//////// Following pattern for a value to be email          ////////
	////////////////////////////////////////////////////////////////////


/* old version 
	if(field_type=='email')
	{
	if(debug==1)alert("in email pat init");//temp line
	var pat=/^[a-zA-Z][\w\.-_]*[a-zA-Z0-9]@[a-zA-Z0-9][\w\.-]*[a-zA-Z0-9]\.[a-zA-Z][a-zA-Z\.]*[a-zA-Z]$/
		

			if(field_val.match(pat)){result=0;
			
			}
			else{result=1;}
			message_x=' should contain a valid email address '

	}

	*/

	/* new version is below */


	if(field_type=='email')
	{
	if(debug==1)alert("in email pat init");//temp line
		

	if(emailCheck(field_val) == true){
					result=0;
	}
	else{
					result=1;
	}
			message_x=' should contain a valid email address '
	}


	////////////////////////////////////////////////////////////////////
	//////// Following code validates value after inheriting pattern ///
	////////////////////////////////////////////////////////////////////
	if(debug==1) alert('field empty validation started');
	var len=field_val.length;
	if(debug==1) alert('length is =' + len);
	if (len == 0 && min!=0) {
		send = "Please specify your "+field_name;
		hi[hi.length]=field_id;
		error_process(send);
	  return false;
	}

	if(debug==1) alert('field pattern validation started');
	if (result == 1 ) {
	if (min==0 && len==0){}else{
		send = field_name + message_x ;
		hi[hi.length]=field_id;
		error_process(send);
		return false;}
	}


	if(debug==1) alert('field max min validation started');
	// just test if max was defined or not
	if (max > 0 && ( (len < min) || (len > max) )  ) {
		// max is present
		send= 'Length of ' + field_name +' should be between '+min+ ' and ' + max  ;
		hi[hi.length]=field_id;
		error_process(send);
		return false;
	} else if (len < min )  {
		if(debug==1) alert('field min validation started');
		send= 'Length of ' + field_name +' should be more than '+min  ;
		hi[hi.length]=field_id;
		error_process(send);
		return false;
	}
	if(debug==1)alert('field validation ended');

	send='';
return true;
}



function validate_radio(radio_var,radio_name)
{
				if(debug==1)alert("validate radio called for " + radio_var);
				var rOpt = -1;


				// see if anything is checked by default  return true if so
				// without any further chekcing.

				var defchecked;
				
				defchecked = eval('document.'+form_name+'.'+radio_var+'.defaultChecked');

				if ( defchecked ) {

						return true;

				}

				for (var i=0; i < eval('document.'+form_name+'.'+radio_var+'.length'); i++) 
				{
								if (eval('document.'+form_name+'.'+radio_var+'['+i+'].checked') )
								{
												rOpt=i;
												if(debug==1)alert("found one radio selected hence increasing counter");
								}
				}

				if (rOpt==-1) 
				{	if(debug==1)alert('counter was not increased during validation process hence no radio selected');
								send="Please select one option for field "+radio_name;
								if(debug==1)alert("now sending error : "+send);
								error_process(send); 
								if(debug==1)alert("now returning radio valid false");
								return false
				}
				else
				{	if(debug==1)alert("counter was increased means that radio was selected hence return radio true");
								return (true);
				}
				if(debug==1)alert("exit radio validate");
}


function validate_dd(field_id,field_name)
{
	var str =  'document.'+form_name + '.' + field_id +'.options.selectedIndex'; 
	if(eval(str)==0)
	{
	  hi[hi.length]=field_id;
		send="Please select a option in dropdown for field "+field_name;
		error_process(send);
	}
}


function validate_list(field_id,field_name,min)
{
	var inc=0;	
	for(i=0;i<eval('document.'+form_name+'.'+field_id+'.options.length');i++)
	{
		if(eval('document.'+form_name+'.'+field_id+'.options['+i+'].selected')){
			inc++;if(inc==min){break;}
		}
	}


	if(inc<min)
	{
		hi[hi.length]=field_id;
		send="Please select at least "+min+" option in list "+field_name;
		error_process(send);
	}


}



function validate_checkBox(arr,disc,typ,min)
{
	var x=0;
	eval("var newAr=new Array("+arr+");");
	for(var px=0;px<eval('newAr.length');px++)
	{
		if(eval('document.'+form_name+'.'+newAr[px]+'.checked')==true)
		{
			x++;
		}

	}
	if(x<min)
	{

		if((x<min)&&(typ=='single'))
		{
			for(var w=0;w<newAr.length;w++)
			{
			hi[hi.length]=newAr[w];
			}
			send="You Must check "+disc+" Checkbox to submit this form";
			error_process(send);
		}

		if((x<min)&&(typ=='group'))
		{
			send="Please select at least " + min + " checkbox" + ( (min > 1) ? "es" : "" ) + " from " + disc;
			error_process(send);
		}

	}
}

function validate_confirm(field1,field2,disc)
{
	var field1_val=eval('document.'+form_name+'.'+field1+'.value');
	var field2_val=eval('document.'+form_name+'.'+field2+'.value');
	if(field1_val!=field2_val)
	{
		send="The value for field "+disc+" is not confirmed";
		hi[hi.length]=field1;hi[hi.length]=field2;
		error_process(send);
	}
}
///////////////////////////////////////////////////////////////////////////////////
//////// This function takes the two dates in the form of YYYY,MM,DD formate
///////// And compare it.
//////////////////////////////////////////////////////////////////////////////////
function validate_dates(start_year, start_mm, start_day,end_year, end_mm, end_day)
{
	var start_date = new Date(start_year, start_mm, start_day);
	var end_date = new Date(end_year, end_mm, end_day);
	if(end_date < start_date )
	{
		send="End date should be after or equal to the start date";
		error_process(send);
	}
}






////////////////////////////////////////////////////////////////////////////////////////////////
////////// This function must be called from main page with a intial line of alert /////////////
////////// like : Error Occured or Please make a note of following things or ..... /////////////
////////// This function is used to create a list of validation failures on a page /////////////
////////////////////////////////////////////////////////////////////////////////////////////////

function error_process(error_msg)
{
				if(process==1){
								if (error >= max_error) {

												return;

								}
								show_error[show_error.length] = '-- ' +  error_msg;
								error_counter('+');
				}
				if(process==0) {filter=1;}
}

function process_status(what)
{
				if(what=='start')				{
								process=1;
				}
				if(what=='stop'){
								process=0;
				}
				return;
}


//This function must be called from main page before starting validation process with 0 para
function error_counter(z)
{
	switch (z)
	{
		case '0'://alert("counter set 0");
			//Empty all the array variables and variables used for re-validation
			hi=new Array();
			error=0;
			break;

		case '1':
			if(error>0)
			{
					back_m=0;
			}
			else
			{
				back_m=1;
			}
			break;

		case '+':
			error++;
			break;

		case '2':
			if(error>0)
			{
				show_error[0] = 'Please re-enter the following field(s) again:\n';
				show_error[show_error.length]='\nPlease correct the above problems and submit again.';
				thi=hi;

				tkname=thi;tfname=form_name;
				alert(show_error.join('\n'));
				hi=new Array();
				field_id='';
				field_name='';
				field_type='';
				min=0;
				field_val='';temp_hi=hi;
				show_error=new Array();
				break;
			}
			else
			{
				field_id='';
				field_name='';
				field_type='';
				min=0;
				field_val='';
				show_error=new Array();
				back_m=1;
				break;
			}
	}
}


////////////////////////////////////////////////////
///////////////Control disabling ///////////////////
////////////////////////////////////////////////////
// Note : execute only if validation achieved///////
////////////////////////////////////////////////////



function disable()
{

	return true;

	if(debug==1)alert('Disabling process started');
	if (document.all||document.getElementById)
	{
		//screen thru every element in the form, and hunt down "submit" and "reset"
		for (i=0;i<eval('document.'+form_name+'.length');i++)
		{
			var tempobj=eval('document.'+form_name+'.elements[i]');
			if(tempobj.type.toLowerCase()=="submit"||tempobj.type.toLowerCase()=="reset")
			{
				tempobj.disabled=true;
				if(tempobj.type.toLowerCase()=="submit")
				{
					tempobj.value='Please wait ..';
				}
			}


		}
	}
}

function high_light_clear()
{
	for(var k=0;k<tkname.length;k++)
	{	if(eval('document.'+tfname+'.'+tkname[k]+'.type')!='radio'&&'button'&&'hidden')
		{
			eval("document."+tfname+"."+tkname[k]+".style.backgroundColor=''");
		}
	}

}

function high_light()
{
	tkname=hi;
	tfname=form_name;

	high_light_clear();

	high_light_clear();
	for(var l=0;l<hi.length;l++)
	{
		if(eval('document.'+form_name+'.'+hi[l]+'.type')!='radio'&&'button'&&'hidden'){
			eval('document.'+form_name+'.'+hi[l]+".style.backgroundColor='fff79e'");}
	}
}

var bbg=0;var thi=new Array();
function blink_bg(bbg)
{
	if(bbg==0)
	{
		for(var l=0;l<thi.length;l++)
		{
			if(eval('document.'+form_name+'.'+thi[l]+'.type')!='radio'&&'button'&&'hidden'){
				eval('document.'+form_name+'.'+thi[l]+".style.backgroundColor='fff79e'");}
		}

		bbg=1;
	}
	else
	{
		for(var k=0;k<tkname.length;k++)
		{	if(eval('document.'+tfname+'.'+tkname[k]+'.type')!='radio'&&'button'&&'hidden')
			{
				eval("document."+tfname+"."+tkname[k]+".style.backgroundColor=''");
			}
		}

		bbg=0;

	}
}

///////////////////////////////////////////////////////////////
////// Email validation Adopted from another website //////////
///////////////////////////////////////////////////////////////

function emailCheck(emailString) {

	var email_array = emailString.split(",");
	for (var loop=0;loop < email_array.length ;loop++)
	{
		var emailStr = email_array[loop];

		/* The following pattern is used to check if the entered e-mail address
			 fits the user@domain format.  It also is used to separate the username
			 from the domain. */
		var emailPat=/^(.+)@(.+)$/
			/* The following string represents the pattern for matching all special
				 characters.  We don't want to allow special characters in the address. 
				 These characters include ( ) < > @ , ; : \ " . [ ]    */
			var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]"
			/* The following string represents the range of characters allowed in a 
				 username or domainname.  It really states which chars aren't allowed. */
			var validChars="\[^\\s" + specialChars + "\]"
			/* The following pattern applies if the "user" is a quoted string (in
				 which case, there are no rules about which characters are allowed
				 and which aren't; anything goes).  E.g. "jiminy cricket"@disney.com
				 is a legal e-mail address. */
			var quotedUser="(\"[^\"]*\")"
			/* The following pattern applies for domains that are IP addresses,
				 rather than symbolic names.  E.g. joe@[123.124.233.4] is a legal
				 e-mail address. NOTE: The square brackets are required. */
			var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/
			/* The following string represents an atom (basically a series of
				 non-special characters.) */
			var atom=validChars + '+'
			/* The following string represents one word in the typical username.
				 For example, in john.doe@somewhere.com, john and doe are words.
				 Basically, a word is either an atom or quoted string. */
			var word="(" + atom + "|" + quotedUser + ")"
			// The following pattern describes the structure of the user
			var userPat=new RegExp("^" + word + "(\\." + word + ")*$")
			/* The following pattern describes the structure of a normal symbolic
				 domain, as opposed to ipDomainPat, shown above. */
			var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$")


			/* Finally, let's start trying to figure out if the supplied address is
				 valid. */

			/* Begin with the coarse pattern to simply break up user@domain into
				 different pieces that are easy to analyze. */
			var matchArray=emailStr.match(emailPat)
			if (matchArray==null) {
				/* Too many/few @'s or something; basically, this address doesn't
					 even fit the general mould of a valid e-mail address. */
				//alert("Your Email address doesn't seems to be in proper format \""  +emailStr+ '" .')
				return false
			}
		var user=matchArray[1]
			var domain=matchArray[2]

			// See if "user" is valid 
			if (user.match(userPat)==null) {
				// user is not valid
				//alert("The username doesn't seem to be valid. \""  +emailStr+ '"')
				return false
			}

		/* if the e-mail address is at an IP address (as opposed to a symbolic
			 host name) make sure the IP address is valid. */
		var IPArray=domain.match(ipDomainPat)
			if (IPArray!=null) {
				// this is an IP address
				for (var i=1;i<=4;i++) {
					if (IPArray[i]>255) {
						//alert("Destination IP address is invalid! \""  +emailStr+ '"')
						return false
					}
				}
				return true
			}

		// Domain is symbolic name
		var domainArray=domain.match(domainPat)
			if (domainArray==null) {
				//alert("The domain name doesn't seem to be valid. \""  +emailStr+ '"')
				return false
			}

		/* domain name seems valid, but now make sure that it ends in a
			 three-letter word (like com, edu, gov) or a two-letter word,
			 representing country (uk, nl), and that there's a hostname preceding 
			 the domain or country. */

		/* Now we need to break up the domain to get a count of how many atoms
			 it consists of. */
		var atomPat=new RegExp(atom,"g")
			var domArr=domain.match(atomPat)
			var len=domArr.length
			if (domArr[domArr.length-1].length<2 || 
					domArr[domArr.length-1].length>4) {
				// the address must end in a two letter or three letter word.
				//alert("The address must end in a maximum of four-letter domain, or two letter country. \""  +emailStr+ '"')
				return false
			}

		// Make sure there's a host name preceding the domain.
		if (len<2) {
			var errStr="This address is missing a hostname! \""  +emailStr+ '"'
				//alert(errStr)
				return false
		}
	}
	// If we've gotten this far, everything's valid!
	return true;
}