//////////////////////////////////////////////////////////////////////////////////////
//
// validacja 1.0.1
//
// modyfikacje:
//   kiedys tam [wgr]: pierwa wersja
//   14.09.05 [tno]:   + nowy sposób konstruowania komunikatu o błędzie
//                     + obsługa minimalnej długoœci podawanego hasła
// 
// TODO:
//   - dorobic obsluge wielu formularzy
//   - obsluga bledow date i datefuture
//
//
////////////////////////////////////////////////////////////////////////////////////

var Params = new Array();

// parametry walidacji
Params.errorBG = "#FDA835"; // kolor tla blednego pola
Params.clearBG = "#FFFFFF"; // kolor tla poprawnego pola
Params.passwordLenght = 6;

// komunikaty
Params.defaultErrorMessage = "W formularzu wystąpiły błędy w polach zaznaczonych kolorem:\n";
Params.notEmptyErrorMessage = "\n- Wymagane pole nie zostało wypełnione";
Params.mustCheckedErrorMessage = "\n- Wymagane pole nie zostało zaznaczone";
Params.mustOneCheckedErrorMessage = "\n- Jedno z grupy wymaganych pól nie zostało zaznaczone";
Params.passwordLenghtErrorMessage = "\n- Hasło powinno mieć co najmniej "+Params.passwordLenght+" znaków";
Params.passwordRepeatErrorMessage = "\n- Hasło i powtórzone hasło nie zgadzają się lub któreś z nich nie zostało podane.";
Params.floatErrorMessage = "\n- Wpisana wartość nie jest liczbą";
Params.emailErrorMessage = "\n- Podany adres nie jest prawidłowym adresem E-Mail";
Params.regonErrorMessage = "\n- Podany REGON jest nieprawidłowy";
Params.nipErrorMessage = "\n- Podany NIP jest nieprawidłowy";
Params.zipErrorMessage = "\n- Podany kod pocztowy jest nieprawidłowy";
Params.dateErrorMessage = "\n- Wpisana data jest nieprawidłowa. Poprawny format daty to np. 2004-11-26";
Params.dateFutureErrorMessage = "\n- Wpisana data jest wcześniejsza niż wymagana";

var correct;             
var errorMessage;
var errorArray = {};

//var valArray = new Array();

// sprawdza wersje przegladarki
function checkBrowser()
{
	if(document.layers)
	{
		return "NN4";
	}
	if(document.all)
	{
		return "IE";
	}
	if(!document.all && document.getElementById)
	{
		return "NN6";
	}
}


function GetLayer(layer)
{
	var ReturnLayer = null;
	if(navigator.appName == 'Netscape')
	{	  
		if(parseInt(navigator.appVersion) == 5)
			ReturnLayer = document.getElementById(layer);
		else
			eval('ReturnLayer = document.' + layer + ';');
	}
	else
	{
		eval('ReturnLayer = document.all.' + layer + ';');
	}
	return ReturnLayer; 
}


function validate(formName)
{
	var element;
	var params;
	var groupChecked = false;
	var lastGroupName = "";
	var currentGroupName = "";
	var mustOneCheck = false;

	errorArray["NotEmpty"]=false;
	errorArray["MustChecked"]=false;
	errorArray["MustOneChecked"]=false;
	errorArray["PasswordRepeat"]=false;
	errorArray["PasswordLenght"]=false;
	errorArray["Float"]=false;
	errorArray["EMail"]=false;
	errorArray["REGON"]=false;
	errorArray["NIP"]=false;
	errorArray["ZIP"]=false;
	errorArray["Date"]=false;
	errorArray["DateFuture"]=false;

   correct = true;             
	errorMessage = Params.defaultErrorMessage;

	formElements = document.forms[formName].elements.length;

	for (k=0; k<formElements; k++)
	{
		element = document.forms[formName].elements[k]; 
		strValParams = "";
		if(typeof(element.attributes["val"]) == "object")
		{
			strValParams = element.attributes["val"].value; 
		}

		params=null;
		if(strValParams!="")
		{
			// valType = element.id; 
			data = strValParams.split(";")
			valType = data[0]; 
			if(data.length>1) params = data[1].split(":");
		}
		else valType = strValParams; 
      
		//alert(valType);
      
		fieldValue = element.value;
		fieldFlag = element.flag;
		
		if (typeof(fieldFlag)=='undefined')
		{
			fieldFlag=1;    	
		}

		// znalazlem zadanie wywolania zewnetrznej funkcji validujacej
		if(params && params[0] == "@F")
		{
		   
			evalStr = "extFuncResult = " + params[1] + "();";
			eval(evalStr);
         
			if(typeof(extFuncResult) == "undefined")
				extFuncResult = false;
		   
			if(extFuncResult == false)
			{
				valType = "NotValidate";
				correct = false;
				markField(element);
			}
			else
			{
				unmarkField(element);
			}
		}
		
    	switch(valType)
    	{
    		case "EMail":
				bool=false;
				bool = checkMail(fieldValue, fieldFlag);
				tmp = correct;
				correct = (tmp && bool);
				if (bool==false)
				{
					markField(element);
					errorArray["EMail"]=true;
				}
				else
					unmarkField(element);
				
            break;
         case "MustChecked":
            if(params.length!=null)
            {
               bool=element.checked;
               tmp = correct;
               correct = (tmp && bool);
               if(bool==false)
					{
                  GetLayer(params[0]).style.background=Params.errorBG;
						errorArray["MustChecked"]=true;
					}
               else
                  GetLayer(params[0]).style.background='none';
            }
            break;
         case "MustOneChecked":
            if(params.length!=null)
            {
			      mustOneCheck = true;
               // sprawdze czy sa elementy z tej grupy
               currentGroupName = params[0];
               if(lastGroupName != currentGroupName)
               {
                  lastGroupName = currentGroupName
                  groupChecked = false;
               }
               groupChecked = (element.checked | groupChecked);
               tmp = correct;
               if(groupChecked)
                  GetLayer(params[0]).style.background='none';
               else
					{
                  GetLayer(params[0]).style.background=Params.errorBG;
						errorArray["MustOneChecked"]=true;
					}
            }
            break;
    	   case "NotEmpty":
    	  	   bool=false;
    	  	   bool = checkFilled(fieldValue);   
	         tmp = correct;
	         correct = (tmp && bool);
	         if (bool==false)
				{
	            markField(element);
					errorArray["NotEmpty"]=true;
				}
	         else
	            unmarkField(element);
	         break;  
	      case "Date":
	      	bool="";
				var check;
            if(fieldValue!="") 
               check = true;
				else
				{
					if(params!=null && params[0]=="notrequired") check=false;
					else check=true;
				}
				if(check==true)
				{
					bool = checkDate(fieldValue, fieldFlag);
    	  			tmp = correct;
    	  			correct = (tmp && bool); 
    	  			if (bool==false)
               {
    	  				markField(element);
					   errorArray["Date"]=true;
               }
	    	  		else
  						unmarkField(element);
				}
  			   break;
			case "DateFuture":
	      	bool="";
				var check;
				if(fieldValue!="") check = true;
				else
				{
					if(params!=null && params[0]=="notrequired") check=false;
					else check=true;
				}
				if(check==true)
				{
               isDate = checkDate(fieldValue, fieldFlag);
               isFuture = isFromFuture(fieldValue);
               bool = isDate && isFuture;
    	  			tmp = correct;
    	  			correct = (tmp && bool); 
    	  			if (bool==false)
               {
    	  				markField(element);
					   if(!isDate) errorArray["Date"]=true;
					   if(isDate && !isFuture) errorArray["DateFuture"]=true;
               }
	    	  		else
  						unmarkField(element);
				}
  			   break;
			case "REGON":
				var check;
				if(fieldValue!="") check = true;
				else
				{
					if(params!=null && params[0]=="notrequired") check=false;
					else check=true;
				}
				if(check==true)
				{
					bool = checkREGON(fieldValue, fieldFlag);
					tmp = correct;
					correct = (tmp && bool);
					if (bool==false)
					{
						markField(element);
						errorArray["REGON"]=true;
					}
					else
						unmarkField(element);
				}
				break;
			case "NIP":
				var check;
				if(fieldValue!="") check = true;
				else
				{
					if(params!=null && params[0]=="notrequired") check=false;
					else check=true;
				}
				if(check==true)
				{
					bool = checkNIP(fieldValue, fieldFlag);
					tmp = correct;
					correct = (tmp && bool);
					if (bool==false)
               {
						markField(element);
						errorArray["NIP"]=true;
               }
					else
						unmarkField(element);
				}
				break;
			case "Float":
				var check;
				if(fieldValue!="") check = true;
				else
				{
					if(params!=null && params[0]=="notrequired") check=false;
					else check=true;
				}
				if(check==true)
				{
					bool = checkFloat(fieldValue, fieldFlag);
					tmp = correct;
					correct = (tmp && bool);
					if (bool==false)
					{
						markField(element);
						errorArray["Float"]=true;
					}
				   else
						unmarkField(element);
				}	 
				break;
			case "ZIP":
				bool = checkZIP(fieldValue, fieldFlag);
				tmp = correct;
				correct = (tmp && bool);
				if (bool==false)
            {  
					markField(element);
					errorArray["ZIP"]=true;
            }
				else
					unmarkField(element);
				break;
			case "Password":
				// tu trzeba troszke zamieszac i pobrac od razu wartos drugiego pola
				Pass = fieldValue;
				rePass = document.forms[formName].elements[k+1].value;
				
				bool = checkPass(Pass, rePass ,fieldFlag);
				tmp = correct;
				correct = (tmp && bool);
				if (bool==false)
				{
					markField(element);
               markField(document.forms[formName].elements[k+1]);
				}
				else
				{
					unmarkField(element);
               unmarkField(document.forms[formName].elements[k+1]);
				}
				break;
    	}
   }
    
   if ((correct==true) && (!mustOneCheck || (mustOneCheck && groupChecked)) )
   {
      document.forms[formName].submit();
	   return true;
   }	
   else
   {
		if(errorArray["NotEmpty"]==true) errorMessage += Params.notEmptyErrorMessage;
		if(errorArray["MustChecked"]==true) errorMessage += Params.mustCheckedErrorMessage;
		if(errorArray["MustOneChecked"]==true) errorMessage += Params.mustOneCheckedErrorMessage;
		if(errorArray["PasswordRepeat"]==true) errorMessage += Params.passwordRepeatErrorMessage;
		if(errorArray["PasswordLenght"]==true) errorMessage += Params.passwordLenghtErrorMessage;
		if(errorArray["Float"]==true) errorMessage += Params.floatErrorMessage;
		if(errorArray["EMail"]==true) errorMessage += Params.emailErrorMessage;
		if(errorArray["REGON"]==true) errorMessage += Params.regonErrorMessage;
		if(errorArray["NIP"]==true) errorMessage += Params.nipErrorMessage;
		if(errorArray["ZIP"]==true) errorMessage += Params.zipErrorMessage;
		if(errorArray["Date"]==true) errorMessage += Params.dateErrorMessage;
		if(errorArray["DateFuture"]==true) errorMessage += Params.dateFutureErrorMessage;
	   alert (errorMessage);
	   return false;
   }	
}
  
 
//////////////////////////////////////////////////////////////////////  
function checkMail(str, flag)
{
   if (flag==1 || str!="")
   {
	   var email=/^[A-Za-z0-9]+([_\.-][A-Za-z0-9]+)*@[A-Za-z0-9]+([_\.-][A-Za-z0-9]+)*\.([A-Za-z]){2,4}$/i;
		return (email.test(str));	 	
	}
	else
	{
			return true;
  	}
}
  
function checkZIP(str, flag)
{
   if (flag==1 || str!="")
   {
	   var ZIP=/^[0-9]{2}[-]{1}[0-9]{3}$/i;
		return (ZIP.test(str));	 	
	}
	else
	{
	   return true;
  	}
}
   
  
function checkFilled(str)
{
   var num = /\s/;
   while(num.test(str))
   {
      str = str.replace(num, "");
   }   
   if (str=="")
   {
      //errorMessage += "nie\n";
      return false;
   }
   else
   {
	   return true;      
   }
}

function isFromFuture(strDate)
{
   // dane wejsciowe
   strSeparator = "-";
   arrDate = strDate.split(strSeparator);
    
   intChkYear   = parseInt(arrDate[0]*1);
   intChkMonth  = parseInt(arrDate[1]*1);
   intChkDay    = parseInt(arrDate[2]*1);
        
   // dzisiejsze dane
   objNow = new Date();
   intNowDay    = parseInt(objNow.getDate());
   intNowMonth  = parseInt(objNow.getMonth())+1;
   intNowYear   = parseInt(objNow.getFullYear());                                  

   //alert(intNowDay + "." + intNowMonth+ "." +intNowYear);
	//alert(intChkDay + "." + intChkMonth+ "." +intChkYear);
   if(intChkYear > intNowYear)
   {
      return true;
   } 
   else if(intChkYear < intNowYear)
   {
      return false;
   }  
   else	 if(intChkMonth > intNowMonth)
   {
      return true;
   } 
   else if(intChkMonth < intNowMonth)
   {
      return false;
   }
   else  if(intChkDay >= intNowDay)
   {
      return true;
   }
   return false;
 }
 
 
// format daty: yyyy-mm-dd
function checkDate(str, flag)
{
   daysInNormYear = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
   daysInLeapYear = new Array(31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
   if (flag==1 || str!="")
   {
      var dateStr=/^([0-9]){4}-([0-9]){2}-([0-9]){2}$/;
		if(dateStr.test(str)==true)
		{
		   year = str.substring(0,4);
			month = str.substring(5,7);
			day=str.substring(8,10);
			isLeapYear = !(year%4);

			if (month<=12 && month>0)
			{
			   if(isLeapYear)
 				   return (day>0 && day<=daysInLeapYear[(month-1)]);
			  	else
					return (day>0 && day<=daysInNormYear[(month-1)]);
         }    	
			else 
			   return false;			  
		}
		else
		   return false;
   }
   else
      return true;
}

function checkNIP(str, flag)
{
   if (flag==1 || str!="")
   {
      weights = new Array(6, 5, 7, 2, 3, 4, 5, 6, 7);
      cLength  = 10;
      cModulo  = 11;    
      // zamieniam string na cyferki same
      var num = /-/;
      while(num.test(str))
      {
         str = str.replace(num, "");
      }   
      // sprawdzam czy tylko cyfry
      var bla = /\D/;
      isDigit = true;
      while(bla.test(str))
      {
         str = str.replace(bla, "");
         //errorMessage +="Nieporwny numer NIP\n";
         return false;
      } 
      if (str.length == cLength)
      {
         sum = 0;
         for(i=0; i<weights.length; i++)
         {
            sum += (str.substring(i, (i+1)) * weights[i]);
         }
         lSign = (sum % cModulo);
         rSign = str.substring(9,10);
         return (lSign == rSign)
      }
      else
      {
         return false;
      }  
    }  
    else
    {
         return true;
    }
}

 
function checkREGON(str, flag)
{
   if (flag==1 || str!="")
   {
      weights = new Array(8, 9, 2, 3, 4, 5, 6, 7);
	   cLength  = 9;
	   cModulo  = 11;    

	   // zamieniam string na cyferki same
	   var num = /-/;
	   while(num.test(str))
	   {
	      str = str.replace(num, "");
	   }   
	   // sprawdzam czy tylko cyfry
	   var bla = /\D/;
	   isDigit = true;
	   while(bla.test(str))
	   {
	      str = str.replace(bla, "");
	      //errorMessage +="Nieporwny numer NIP\n";
	      return false;
	   } 
	   if (str.length == cLength)
	   {
	      sum = 0;
	      for(i=0; i<weights.length; i++)
	      {
	         sum += (str.substring(i, (i+1)) * weights[i]);
	      }
	      lSign = (sum % cModulo);
	      rSign = str.substring(8,9);
	      return (lSign == rSign)
	   }
	   else
	   {
	      return false;
	   }  
   }  
	else
	{
	   return true;
	}
}


// sprawdza liczby zmienno przecinkowe i zwykle tez :)
function checkFloat(str, flag)
{
   if (flag==1 || str!="")
   {
      var floatStr=/^([0-9])+([\.]){0,1}([0-9])*$/;
		return (floatStr.test(str));
   }
   else
   {
      return true;
   } 
}

function checkPass(Pass, rePass, flag)
{
   if (flag==1 || str!="")
   {
		if(Pass=="" || Pass!=rePass) errorArray["PasswordRepeat"]=true;
		if(Pass.length < Params.passwordLenght) errorArray["PasswordLenght"]=true;
      return (Pass!="" && (Pass==rePass) && Pass.length >= Params.passwordLenght);
   }
   else
      return true;
}  
   
function markField(field)
{
   field.style.background=Params.errorBG;
}
  
function markPassField(fieldNo)
{
   alert("aaa");
}
  
function unmarkField(field)
{
   field.style.background=Params.clearBG;
}

// dziekuje