/*
 * Por: Alan Lucian M.T.
 * E-mail: alanlucian@gmail.com
 * 03 fev. 2009
 * Versão 1.3b
 * Empresa: Dobra Digital
 * 
 * Objetivo: Validar inputs do tipo TEXT|PASSWORD|RADIO, objetos DROPDOWN e TextArea 
 * 
 * Uso: deve ser passado como parâmetro um identificador do formulário, id ou name
 * os campos a serem validados pela função deve conter a seguinte estrutura básica dentro
 * do atributo class do objeto: {fn[]} onde dentro de fn[] será passada as funçoes de validação 
 * separadas por vírgula  ex: {fn[validacao1,validacao1]}, estas funções serão externas a este arquivo, este
 * documento NÃO possui nenhuma função de validação complexa, verifica apenas se possui ou não texto e se foi
 * selecionado algum item do comboBox. 
 */


/* CONFIG:  
 * classeErro: classe CSS que será adicionada ao objeto padrão é 'error' quando houver erro
 * 		Ex:se classe padrão for 'textoColorido') com o erro padrão  ficaria 'textoColorido error'
 * 
 * classShow: classe CSS que será adicionada ao objeto para exibição no html
 * 
 * classHidden: classe CSS que será adicionada ao objeto para oculta-lo no html
 * 
 * */


var classeErro = 'erro11';
var classShow = 'show';
var classHidden = 'hidden';


/* FIM CONFIG  
 *
 * #####################################################################
 * ####		Após este bloco altere o código por sua conta e risco	####
 * #####################################################################
 */



function validaForm(formIdent) 
{ 
	var form_valido = true;
  var arrayForId = new Array();
  var form, elements, i, elm; 
  form = document.getElementById(formIdent) 
    ? document.getElementById(formIdent) 
    : document.forms[formIdent]; 
	
	if (document.getElementsByTagName)
	{
		
		elements = form.getElementsByTagName('input');
		
		for( i=0, elm; elm=elements.item(i++); )
		{
			
			if (elm.getAttribute('type') == "text" || elm.getAttribute('type') == "password")
			{
				
				rtValidacao = validaObj(elm,"input");
				arrayForId[rtValidacao.target] = rtValidacao;				
			}else if(elm.getAttribute('type') == 'radio'){
				rtValidacao = validaObj(elm,"radio");
				arrayForId[elm.name] = rtValidacao;	
			}
		}
		
		elements = form.getElementsByTagName('select');
		for( i=0, elm; elm=elements.item(i++); )
		{
			
			rtValidacao = validaObj(elm,"select");
			arrayForId[rtValidacao.target] = rtValidacao;				
	
		}
		
		elements = form.getElementsByTagName('textarea');
		for( i=0, elm; elm=elements.item(i++); )
		{
			
			rtValidacao = validaObj(elm,"textarea");
			arrayForId[rtValidacao.target] = rtValidacao;	
		}
		
		//alert(arrayForId.length);
		
		elements = form.getElementsByTagName('label');
		for( i=0, elm; elm=elements.item(i++); )
		{
			// se cair no case é pq nenhum objeto de validação fex referência a um label.
			try{
				var JSONObject = {};
				if(navigator.appName.indexOf("Microsoft")>=0){
					// IE
					JSONObject = arrayForId[elm.getAttribute('htmlFor')];
				}else{
					// outros
					JSONObject = arrayForId[elm.getAttribute('for')];
				}		
				valido = ( isset(JSONObject.valido )? JSONObject.valido:true);
				
				if(valido){
					removeClass(elm,classeErro);
					
					//swapClass(JSONObject.msg,classShow,classHidden); 
				}else{
					//setErrorClass(elm);
					form_valido = false; 
					addClass(elm,classeErro);
					//swapClass(JSONObject.msg,classHidden,classShow);
				}
			}catch(e){}
		}		
	}
	return form_valido;
}

function isset(  ) {
    // http://kevin.vanzonneveld.net
    // +   original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +   improved by: FremyCompany
    // +   improved by: Onno Marsman
    // *     example 1: isset( undefined, true);
    // *     returns 1: false
    // *     example 2: isset( 'Kevin van Zonneveld' );
    // *     returns 2: true
    
    var a=arguments; var l=a.length; var i=0;
    
    if (l==0) { 
        throw new Error('Empty isset'); 
    }
    
    while (i!=l) {
        if (typeof(a[i])=='undefined' || a[i]===null) { 
            return false; 
        } else { 
            i++; 
        }
    }
    return true;
}


function validaObj(elm,tipo){
	//var obrigatorio = predominateObrigatorio;
	var arrFunctions = new Array();
	
	var JSONObject = {};
	
	//verifico se o ob.className pode ser usado  
	if (elm.className) {
		var classe = new String(elm.className);	
			
		//  pego o conteúdo XXX dentro de fn[XXX] para gerar array de funções validadoras
		/*var cropStart = new Number(classe.indexOf("fn[")+3);
		var tmpStrFn = new String(classe = classe.substr(cropStart,classe.length-cropStart ));
		tmpStrFn = tmpStrFn.substr(0,tmpStrFn.indexOf("]") );*/
		
		var cropStart = new Number(classe.indexOf("{"));
		var tmpStrFn = new String(classe = classe.substr(cropStart,classe.length-cropStart ));
		tmpStrFn = tmpStrFn.substr(0,tmpStrFn.indexOf("}")+1 );
			
		var indexObr = tmpStrFn.indexOf("[obr]");
		
		// verifico se há a flag obrigatório ou a não obrigatório	
		obrigatorio = (indexObr>=0)?true:false;
		//removo o [obr] da string para formar um objeto Json
		tmpStrFn = "{"+tmpStrFn.substr(indexObr+5,tmpStrFn.length);	
		var rtTarget = elm.id;
		
		if (tmpStrFn.length > 3) {
			try {
				JSONObject = eval("(" + tmpStrFn + ")");
				rtTarget = (JSONObject.target!=undefined ? JSONObject.target : elm.id);
				//alert('JSONObject.target '+JSONObject.target);
			} 
			catch (e) {
				//alert(e + elm.name);'
				
			}
			arrFunctions = (JSONObject.validaFn)?JSONObject.validaFn:'';
				
		}	
		
	}
	//alert(rtTarget+' -- '+ elm.name );
	var valida = false;
	var rtValido = false;
	
	if(obrigatorio==true &&  tipo=='radio' ){
		
		var arrRad = document.getElementsByName(elm.name);
		for(i = 0 ; i<arrRad.length; i++ ){
			if(arrRad[i].checked==true){
				rtValido = true;
			}
		}
		
		/*return {
			valido: rtValido,
			target: rtTarget
		};*/
		JSONObject.valido = rtValido;
		JSONObject.target = rtTarget;
		return JSONObject; 
	}
	
	var rtValido = true;
	if(obrigatorio==true || ( tipo != 'select' && elm.value.length > 0 )){
		
		if(arrFunctions.length>0){
			for (var i = 0; i < arrFunctions.length; i++) {
				rtValido = eval(arrFunctions[i])(elm.value,elm);
			}
		}else{
			if (tipo != 'select') {
				rtValido = elm.value.length < 1 ? false : true;
			}else{
				rtValido = elm.selectedIndex==0?false:true;
			}
		}	
		
	}
	
	JSONObject.valido = rtValido;
	JSONObject.target = rtTarget;
	return JSONObject; 
		
	/*return {
		valido: rtValido,
		target:rtTarget 
	};*/
}
/*
function swapClass(obj,strClassOld,strClassNew){
	alert(strClassOld+strClassNew)
	if(typeof(obj) == 'object'){
		var obj = obj;
	}else{
		var obj = document.getElementById(obj);
	}
	obj.className =  obj.className.replace(strClassOld,strClassNew);
	
}*/
function addClass(obj,strClass){
	if(typeof(obj) == 'object'){
		var obj = obj;
	}else{
		var obj = document.getElementById(obj);
	}
	
	var add = (obj.className.indexOf(strClass)>=0)?false:true;
	if(add){
		obj.className = obj.className+ " " + strClass; 
	}
	
}

function removeClass(obj,strClass){
	if(typeof(obj) == 'object'){
		var obj = obj;
	}else{
		var obj = document.getElementById(obj);
	}
	
	var rem = (obj.className.indexOf(strClass)>=0)?true:false;
	
	if(rem){
		var indexRmClass = obj.className.indexOf(strClass);
		
		var tmpClassStr = obj.className.substr(0,indexRmClass);
		tmpClassStr+= obj.className.substr(indexRmClass+strClass.length+1,obj.className.length);
		obj.className = tmpClassStr;
	}	
}
/*
function unsetErrorClass(idObject){
	if(typeof(idObject) == 'object'){
		var obj = idObject;
	}else{
		var obj = document.getElementById(idObject);
	}
	
	var indexError = obj.className.indexOf(classeErro)
	//alert(indexError );
	if(indexError>=0){
		
		obj.className = obj.className.substring(0,indexError); 
	}
	//alert('!!!---UNSET ERROR \n'+obj.id+'\n'+obj.className);
}
function setErrorClass(idObject){
	
	if(typeof(idObject) == 'object'){
		var obj = idObject;
	}else{
		var obj = document.getElementById(idObject);
	}
	
	var indexError = obj.className.indexOf(" "+classeErro)
	if (indexError < 0) {
		obj.className = obj.className + " "+classeErro;
	}
	//alert('---SET ERROR \n'+obj.id+'\n'+obj.className);
	
}*/