// Globalne konstanty
///////////////////////
var ERROR_FIELD_CLASS_NAME = "err";
var SELECTED_FIELD_CLASS_NAME = "sel";

// Globalne premenne
/////////////////////////////////////////// 
var checked_fields = new Array();

var is_init_messages = false;
var question_answer_md5;
var form_no_exist;
var field_no_number;
var field_bad_value;
var field_bad_date;
var field_no_value;
var field_no_exist;
var field_upload_bad_ext;
var field_bad_answer;

var original_field_class_name;

var previous_error_field_name = "";
var previous_selected_field_name = "";

// Incializacia zoznamu kontrolovanych poli a ich parametrov
////////////////////////////////////////////////////////////////
function initCheckedFields() {	
	var args = initCheckedFields.arguments;
	for(i = 0; i < args.length; i++) {
		checked_fields[i] = args[i];
	}
}

// Inicializacia chybovych hlasok ku kontrolam
///////////////////////////////////////////////////////////
function initMessages(questionAnswerMD5, formNoExist, fieldNoNumber, fieldBadValue, fieldBadDate,
	fieldNoValue, fieldNoExist, fieldUploadBadExt, fieldBadAnswer) {  
  // Inicializacia premennych pre formulare
  question_answer_md5 = questionAnswerMD5;
  form_no_exist = formNoExist;
  field_no_number = fieldNoNumber;
  field_bad_value = fieldBadValue;
  field_bad_date = fieldBadDate;
  field_no_value = fieldNoValue;  
  field_no_exist = fieldNoExist;
  field_upload_bad_ext = fieldUploadBadExt;
  field_bad_answer = fieldBadAnswer;
  
  // Priznak incializacie
  is_init_messages = true;
}

// Kontrola formulara a jeho poli
/////////////////////////////////////////////
function isValidForm(form) {  
  // lokalne konstanty
	var VALID_EMAIL = /^[a-z0-9._-]+@[a-z0-9äöüÄÖÜ.-]+\.[a-z]{2,4}$/i;// regularny vyraz pre kontrolu emailu
  var VALID_URL = /^(((http(s?)))\:\/\/)?(www.|[a-zA-Z].)[a-zA-Z0-9\-\.]+\.([a-zA-Z0-9\-\.]+)(\:[0-9]+)*(\/($|[a-zA-Z0-9\.\,\;\?\'\\\+&%\$#\=~_\-]+))*$/;// regularny vyraz pre kontrolu URL
	// lokalne premenne
	var formID = form.id;
  var errorMsg = "";
  var field, fieldName, fieldTitle, fieldType, fieldMinLength, fieldParams, fieldObj, val, cnt, nr, i, j;
  var format, d, day, month, year;
  var result = true;
  
  // Ak bol stlaceny reset_button preskoc kontrolu  
  //if(document.pressed == 'withoutValidation') return true;
  
	// kontrola inicializacie
  if(!is_init_messages) {
		alert("ERROR: Nebola vykonaná inicializácia - initMessages()!");
		return false;
  }
  
  if(document.forms[formID]) {		
    for(i = 0; i < checked_fields.length; i++) {
      field = checked_fields[i].split(":");
      // rozparsovanie parametrov kontrolovanych policok
      fieldName = _trim(field[0]);
      fieldTitle = _trim(field[1]);    
			fieldType = _trim(field[2].toLowerCase());
			fieldMinLength = _trim(field[3]);
			
			// ak je typ 'upload', ocakava sa dalsi parameter
			if(fieldType == 'upload') {
        fieldParams = _trim(field[4]);
      }
      
			// uzavretie titulku do uvodzoviek 
      if(fieldTitle.indexOf("\'") == -1) {
        //fieldTitle = '\'' + fieldTitle + '\'';
      }
      
			// ak nie je uvedeny titulok, tak sa pouzije meno
      if(!fieldTitle) { 
        fieldTitle = fieldName;
      }
            
      fieldObj = document.forms[formID].elements[fieldName];
						
      if(fieldObj) {
      	// odpamatanie povodnej farby ramika
      	if(original_field_class_name == null) {
					original_field_class_name = fieldObj.className;
				}
								      	        
        filedValue = _trim(fieldObj.value);
        
        // kontroly hodnoty podla typu pola
        if(filedValue != "") { 
					// kontrola na cislo       	
          if(fieldType == "number") {
            filedValue = filedValue.replace(",", ".");
            if(isNaN(filedValue)) { //TODO
              errorMsg = sprintf(field_no_number, fieldTitle);
              showFieldErrorMsg(fieldObj.name, errorMsg);
              return false;
            }
          } 
          // kontrola emailu
          else if(fieldType == "mail" && filedValue.search(VALID_EMAIL) == -1) { 
            errorMsg = sprintf(field_bad_value, fieldTitle);
            showFieldErrorMsg(fieldObj.name, errorMsg);
            return false;              
          }
          // kontrola URL adresy
          else if(fieldType == "url" && filedValue.search(VALID_URL) == -1) { 
            errorMsg = sprintf(field_bad_value, fieldTitle);
            showFieldErrorMsg(fieldObj.name, errorMsg);
            return false;              
          }
          // kontrola datumu
          else if(fieldType.indexOf("date") != -1) {
            if(fieldType.indexOf("(") != -1) {
              format = fieldType.substr(fieldType.indexOf("("));
            } else {
              format = "(dmy)";
            }
            d = filedValue;

            for(j = 1; j < format.length - 1; j++) {
              cnt = d.search(/[^0-9]/);
              if(cnt == -1) cnt = d.length;

              nr = d.substr(0, cnt);
              nr = parseInt(nr.replace(/^0/, ''));

              switch(format.charAt(j)) {
                case "d": day = nr; d = d.substr(cnt + 1); break;
                case "m": month = nr; d = d.substr(cnt + 1); break;
                case "y": year = nr; d = d.substr(cnt + 1); break;
              }
            }
            if(!_isDate(year, month, day)) { 
              errorMsg = sprintf(field_bad_date, fieldTitle);
              showFieldErrorMsg(fieldObj.name, errorMsg);
              return false;              
            }
          }
         // kontrola spravnej odpovede 
         else if(fieldType == "answer") {         		
         		if(filedValue.md5() != question_answer_md5) {				          	
	            errorMsg = sprintf(field_bad_answer, fieldTitle);
	            showFieldErrorMsg(fieldObj.name, errorMsg);
	            return false;
            }
          }
        }
        // kontrola minimalnej dlzky
        if(fieldMinLength) {
          if(fieldObj.length) {
            if(fieldObj.options) {
              for(j = cnt = 0; j < fieldObj.options.length; j++) {
                if(fieldObj.options[j].selected && fieldObj.options[j].value != "") cnt++;
              }
            }
            else { 
              for(j = cnt = 0; j < fieldObj.length; j++) {
                if(fieldObj[j].checked) cnt++;
              }
            }
          } else {
            if(fieldObj.type == "checkbox") {
              cnt = fieldObj.checked ? 1 : 0;
            } else {
              cnt = filedValue.length;
            }
            if(cnt < fieldMinLength) {              
              errorMsg = sprintf(field_no_value, fieldTitle);
              showFieldErrorMsg(fieldObj.name, errorMsg);
              return false;              
            }
          }
        }
        // kontrola pripony suboru pri uploade
        if(fieldType == "upload") { //Test upload file extension
          if(!checkFileType(fieldObj, fieldParams)) {
              errorMsg = sprintf(field_upload_bad_ext, fieldTitle, fieldParams);
              showFieldErrorMsg(fieldObj.name, errorMsg);              
              return false;
          }          
        }        
      } else {
      	// neexistujuce pole formulara
        errorMsg = sprintf(field_no_exist, fieldTitle);
				showFieldErrorMsg(fieldObj.name, errorMsg);
        return false;              
      }
    }    
  }
  else {
  	// neexistujuci formular
    alert(sprintf(form_no_exist, formID));
    return false;
  }

  return true;
}
// Funkcia na zobrazenie chybovej hlasky k policku
/////////////////////////////////////////////////////////////////////
function showFieldErrorMsg(elemName, errorMsg) {
	// vratenie povodnej farby ramiku predoslemu chybovemu policku 
	if (previous_error_field_name != "") {
		var prevObj = document.getElementById(previous_error_field_name);
		prevObj.className = original_field_class_name;
	}
	
	// nastavenie farby ramiku aktualnemu chybovemu policku
	var actObj = document.getElementById(elemName);
	actObj.className = ERROR_FIELD_CLASS_NAME;
	previous_error_field_name = elemName;
	
	// zobrazenie chybovej spravy
	alert(errorMsg);
	
	// fokus na chybove policko
	actObj.focus();
	actObj.select();
}   

// Trimovanie retazca
/////////////////////////////////////
function _trim(str) {
  if(str) {
    str = str.replace(/^\s+/, "");
    str = str.replace(/\s+$/, "");
  }
  return str;
}

// Kontrola datumu
/////////////////////////////////////
function _isDate(year, month, day) {
  month--;
  if(year < 100) year += 2000;
  var d = new Date(year, month, day);
  return ((day == d.getDate()) && (month == d.getMonth()) && (year == d.getFullYear()));
}

// Kontrola typu suboru
//////////////////////////////////////////////
function checkFileType(fieldObj, params) {
  var ext = fieldObj.value;
  if(ext.length == 0) {
    return true;
  }  
  ext = ext.substring(ext.length-3, ext.length);  
  ext = ext.toLowerCase();    
  var arr = params.split(",");
  
  for(i = 0; i < arr.length; i++) {          
    fieldType = _trim(arr[i]);
    fieldType = fieldType.toLowerCase();    
    if(ext == fieldType) {
      return true;
    }  
  }
  return false;
}

// Zobrazeie spravy a presmerovanie na zadanu URL
/////////////////////////////////////////////////////
function showMessageAndRedirectURL(infoMsg, errorMsg, redirect_url) {	
  // zobrazenie chyby ak je
	if(errorMsg != '') {     
    alert(errorMsg);
  }
  // zobrazenie informacie ak je
	if(infoMsg != '') {     
    alert(infoMsg);
  }
 	// presmerovanie ak je kam
  if(redirect_url != '') {  	
   	window.location = redirect_url;
  }
}

// Sofistikovane formatovanie retazcov
//////////////////////////////////////
function sprintf( ) {
    // http://kevin.vanzonneveld.net
    // +   original by: Ash Searle (http://hexmen.com/blog/)
    // + namespaced by: Michael White (http://getsprink.com)
    // +    tweaked by: Jack
    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // *     example 1: sprintf("%01.2f", 123.1);
    // *     returns 1: 123.10
 
    var regex = /%%|%(\d+\$)?([-+#0 ]*)(\*\d+\$|\*|\d+)?(\.(\*\d+\$|\*|\d+))?([scboxXuidfegEG])/g;
    var a = arguments, i = 0, format = a[i++];
 
    // pad()
    var pad = function(str, len, chr, leftJustify) {
        var padding = (str.length >= len) ? '' : Array(1 + len - str.length >>> 0).join(chr);
        return leftJustify ? str + padding : padding + str;
    };
 
    // justify()
    var justify = function(value, prefix, leftJustify, minWidth, zeroPad) {
        var diff = minWidth - value.length;
        if (diff > 0) {
            if (leftJustify || !zeroPad) {
                value = pad(value, minWidth, ' ', leftJustify);
            } else {
                value = value.slice(0, prefix.length) + pad('', diff, '0', true) + value.slice(prefix.length);
            }
        }
        return value;
    };
 
    // formatBaseX()
    var formatBaseX = function(value, base, prefix, leftJustify, minWidth, precision, zeroPad) {
        // Note: casts negative numbers to positive ones
        var number = value >>> 0;
        prefix = prefix && number && {'2': '0b', '8': '0', '16': '0x'}[base] || '';
        value = prefix + pad(number.toString(base), precision || 0, '0', false);
        return justify(value, prefix, leftJustify, minWidth, zeroPad);
    };
 
    // formatString()
    var formatString = function(value, leftJustify, minWidth, precision, zeroPad) {
        if (precision != null) {
            value = value.slice(0, precision);
        }
        return justify(value, '', leftJustify, minWidth, zeroPad);
    };
 
    // finalFormat()
    var doFormat = function(substring, valueIndex, flags, minWidth, _, precision, type) {
        if (substring == '%%') return '%';
 
        // parse flags
        var leftJustify = false, positivePrefix = '', zeroPad = false, prefixBaseX = false;
        var flagsl = flags.length;
        for (var j = 0; flags && j < flagsl; j++) switch (flags.charAt(j)) {
            case ' ': positivePrefix = ' '; break;
            case '+': positivePrefix = '+'; break;
            case '-': leftJustify = true; break;
            case '0': zeroPad = true; break;
            case '#': prefixBaseX = true; break;
        }
 
        // parameters may be null, undefined, empty-string or real valued
        // we want to ignore null, undefined and empty-string values
        if (!minWidth) {
            minWidth = 0;
        } else if (minWidth == '*') {
            minWidth = +a[i++];
        } else if (minWidth.charAt(0) == '*') {
            minWidth = +a[minWidth.slice(1, -1)];
        } else {
            minWidth = +minWidth;
        }
 
        // Note: undocumented perl feature:
        if (minWidth < 0) {
            minWidth = -minWidth;
            leftJustify = true;
        }
 
        if (!isFinite(minWidth)) {
            throw new Error('sprintf: (minimum-)width must be finite');
        }
 
        if (!precision) {
            precision = 'fFeE'.indexOf(type) > -1 ? 6 : (type == 'd') ? 0 : void(0);
        } else if (precision == '*') {
            precision = +a[i++];
        } else if (precision.charAt(0) == '*') {
            precision = +a[precision.slice(1, -1)];
        } else {
            precision = +precision;
        }
 
        // grab value using valueIndex if required?
        var value = valueIndex ? a[valueIndex.slice(0, -1)] : a[i++];
 
        switch (type) {
            case 's': return formatString(String(value), leftJustify, minWidth, precision, zeroPad);
            case 'c': return formatString(String.fromCharCode(+value), leftJustify, minWidth, precision, zeroPad);
            case 'b': return formatBaseX(value, 2, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
            case 'o': return formatBaseX(value, 8, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
            case 'x': return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
            case 'X': return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad).toUpperCase();
            case 'u': return formatBaseX(value, 10, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
            case 'i':
            case 'd': {
                        var number = parseInt(+value);
                        var prefix = number < 0 ? '-' : positivePrefix;
                        value = prefix + pad(String(Math.abs(number)), precision, '0', false);
                        return justify(value, prefix, leftJustify, minWidth, zeroPad);
                    }
            case 'e':
            case 'E':
            case 'f':
            case 'F':
            case 'g':
            case 'G':
                        {
                        var number = +value;
                        var prefix = number < 0 ? '-' : positivePrefix;
                        var method = ['toExponential', 'toFixed', 'toPrecision']['efg'.indexOf(type.toLowerCase())];
                        var textTransform = ['toString', 'toUpperCase']['eEfFgG'.indexOf(type) % 2];
                        value = prefix + Math.abs(number)[method](precision);
                        return justify(value, prefix, leftJustify, minWidth, zeroPad)[textTransform]();
                    }
            default: return substring;
        }
    };
 
    return format.replace(regex, doFormat);
}

// Stylovanie policka pri ziskani fokusu
/////////////////////////////////////
function setFocusStyle(fieldName) {
	// obnovenie povodnej farby ramika na fokusovanom policku, ak toto policko nie je chybne
	if (previous_selected_field_name != "" && previous_selected_field_name != previous_error_field_name) { 
		document.getElementById(previous_selected_field_name).className = original_field_class_name;
	}
	// nastavenie farby ramika policka pri ziskani fokusu, ak toto policko nie je chybne
	if (previous_error_field_name != fieldName) {
		var objField = document.getElementById(fieldName);
		// odpamatanie povodnej farby ramika policka pred jeho zmenou 
		original_field_class_name = objField.className;
		objField.className = SELECTED_FIELD_CLASS_NAME;
		// odpamatanie nazvu fokusovaneho policka
		previous_selected_field_name = fieldName;
	}	
}

// Vymazanie formulara
////////////////////////////////////////////////////////////////
function resetForm(form) {
	// obnovenie povodnej farby ramika na chybnom policku
	if (previous_error_field_name != "") {
		document.getElementById(previous_error_field_name).className = original_field_class_name;
	}
	// obnovenie povodnej farby ramika na fokusovanom policku
	if (previous_selected_field_name != "") {
		document.getElementById(previous_selected_field_name).className = original_field_class_name;
	}
	// reset poloziek formulara
  for(i = 0; i < checked_fields.length; i++) {
    field = checked_fields[i].split(":");
    // rozparsovanie parametrov kontrolovanych policok
    fieldName = _trim(field[0]);
		fieldType = _trim(field[2].toLowerCase());
		fieldObj = document.getElementById(fieldName);
		
    switch(fieldType) {
      case "mail": fieldObj.value = "@"; break;
      case "checkbox": fieldObj.checked = 0; break;
      default: fieldObj.value = ""; break;
    }		
  }
	return false;
}