/**
 * Document: formvalidation.js
 * Version:  0.1
 *
 * Generic formvalidation framework with validator-plugins
 * 
 * History: Version 0.1 - First Version for DOM-browsers (Mozilla/Firefox/IE)
 *
 * Author: Wolfgang Schröder
 * Date:   08.11.2006
 *
 * Copyright by BaseCMP - Professional Web Solutions
 * All rights reserved
 *
 */


/**
 * JavaScript-"Interface" for Validator-Objects used by
 * gloabel function <code>validate(formobj)</code>
 */
function IValidator() {
  
 /**
  * Executes a single value validation on the given formelement.
  *
  * @signature 
  *   boolean validate(Object formelement)
  *
  * @param formelement
  *   A JavaScript formelement-object which is to be validated
  *
  * @returns
  *   Returns 'true' if the validation succeeded, otherwise false
  *
  */
  this.validate = null;

 /**
  * Executes a group value validation on the given formelement.
  *
  * @signature 
  *   boolean validate(Object formelement)
  *
  * @param formelement
  *   A JavaScript formelement-object which is to be validated
  *
  * @returns
  *   Returns 'true' if the validation succeeded, otherwise false
  *
  */
  this.validateGroup = null;

 /**
  * Delivers an error-message corresponding to the validation-method.
  * The message should be expanded by the given parameters 'displayname'
  * and/or 'validatedvalue' at runtime.
  *
  * @signature
  *   String  getErrorMsg(String displayname, String validatedFormvalue)
  *
  * @param displayname
  *   The name of the field which was validated
  *
  * @param validatedFormvalue
  *   The value which was validated (and failed validation)
  *
  * @returns
  *   The error message, eventually expandede by the given params.
  *
  */
  this.getErrorMsg = null;

 /**
  * Delivers an error-message corresponding to the validation-method.
  * The message should be expanded by the given parameters 'displayname'
  * and/or 'validatedvalue' at runtime.
  *
  * @signature
  *   String  getGroupErrorMsg(String displayname, String validatedFormvalue)
  *
  * @param displayname
  *   The name of the field which was validated
  *
  * @param validatedFormvalue
  *   The value which was validated (and failed validation)
  *
  * @returns
  *   The error message, eventually expandede by the given params.
  *
  */
  this.getGroupErrorMsg = null;
  
 /**
  * Public boolean field, indicating if this implementation of IValidator
  * is able to validate the simple formvalue of the elementtypes 'text',
  * 'textarea', 'hidden', 'password' and 'file'. Default is true!
  *
  * The global function 'validate()' will call the validators validate-function
  * if this field is set true for one of the above elemnttypes!
  */
  this.canValidateSingleValues = true;

 /**
  * Public boolean field, indicating if this implementation of IValidator
  * is able to validate the simple formvalue of the elementtypes 'select' or
  * 'radio'. Default is false!
  *
  * The global function 'validate()' will call the validators validate-function
  * if this field is set true for one of the above elemnttypes!
  */
  this.canValidateGroupValues = false;
  
}



/**
 * Global formvalidation method.
 * To be use in a form-tag with onsubmit="validate(this)".
 */
function validate(formobj) {
  
  for(var i = 0; i < formobj.elements.length; ++i) {
    
    var element = formobj.elements[i];
    var validations = element.getAttribute("validate");
    if(validations) {

      var validation = validations.split(",");
      for(j=0; j < validation.length; j++) {

        var fieldname = (element.getAttribute("displayname") || element.name);
        var validatorname = trim(validation[j]);
        if(validators[validatorname]) {

          switch(element.type) {
            case "textarea":
            case "password":
            case "text":
            case "file":
            case "hidden":
            case "select-one":
              if(validators[validatorname].canValidateSingleValues && !validators[validatorname].validate(element)) {
                alert(validators[validatorname].getErrorMsg(fieldname, element));
                if(element.type != "hidden")
                  element.focus();
                return false;
              }
              break;
            default:
              if(validators[validatorname].canValidateGroupValues && !validators[validatorname].validateGroup(formobj[element.name])) {
                alert(validators[validatorname].getGroupErrorMsg(fieldname, element));
                element.focus();
                return false;
              } else if(!validators[validatorname].canValidateGroupValues) {
                alert("Programming-Error: The validator " + validatorname + " is not able to validate group-values");
                return false;
              } else if(!validators[validatorname].canValidateSingleValues) {
                alert("Programming-Error: The validator " + validatorname + " is not able to validate at all!");
                return false;
              }
          }

        } else {

          alert("Programming-Error: Undefined validator for field '" + fieldname + "': " + validatorname);
          element.focus();
          return false;

        }
        
      }

    }

  }
  return true;

}



/**
 * Removes leading and trailing whitespace from the input-string.
 *
 */
function trim(inputstring) {

  var regex = /^(\s*)$/;

  // check if whitespace only
  if(regex.test(inputstring)) {
    inputstring = inputstring.replace(regex, '');
    if(inputstring.length == 0)
      return inputstring;
  }
    
  // check for leading & trailing whitespace
  regex = /^(\s*)([\W\w]*)(\b\s*$)/;
  if(regex.test(inputstring)) {
    //remove leading and trailing whitespace characters
    inputstring = inputstring.replace(regex, '$2');
  }
  return inputstring;

}



//
// Defining specific validators in a hash-array
// - required
// - integer
// - float
// - minvalue
// - maxvalue
// - minbindings
//

var validators = new Object();



/**
 * Required-Validator implementing "interface" IValidator.
 *
 * Returns true, if the validationvalue is defined by at least
 * one non-whitespace character, otherwise false.
 *
 */
validators["required"] = new IValidator();

validators["required"].validate = function(element) {
  return(element.value && trim(element.value).length > 0);
}

validators["required"].canValidateGroupValues = true;

validators["required"].validateGroup = function(element) {
  for(i=0; i < element.length; i++) {
    switch(element[i].type) {
      case "radio":
        if(element[i].checked)
          return true;
    }
  }
  return false;
}

validators["required"].getErrorMsg = function(displayname, element) {
  var msg = "Bitte geben Sie einen Wert im Feld \'#fieldname#\' an!";
  return msg.replace(/#fieldname#/, displayname);
}

validators["required"].getGroupErrorMsg = function(displayname, element) {
  var msg = "Bitte wählen Sie einen Wert für \'#fieldname#\' aus!";
  return msg.replace(/#fieldname#/, displayname);
}



/**
 * Integer-Validator implementing "interface" IValidator.
 *
 * Returns true, if the validationvalue is an integer number, otherwise false.
 *
 */
validators["integer"] = new IValidator();

validators["integer"].validate = function(element) {
  var regex  = /(^-?\d\d*$)/;
  var fieldlength = trim(element.value).length;
  return (fieldlength == 0 || (element.value && fieldlength > 0 && regex.test(element.value) ));
}

validators["integer"].getErrorMsg = function(displayname, element) {
  var msg = "Im Feld \'#fieldname#\' sind nur ganzzahlige Werte zulässig!\nAktueller Wert: \'#fieldvalue#\'";
  return msg.replace(/#fieldname#/, displayname).replace(/#fieldvalue#/, element.value);
}



/**
 * Float-Validator implementing "interface" IValidator.
 *
 * Returns true, if the validationvalue is a float or an integer number, otherwise false.
 *
 */
validators["float"] = new IValidator();

validators["float"].validate = function(element) {
  var regex  = /(^-?\d\d*(\.|,)?\d*$)/;
  var fieldlength = trim(element.value).length;
  return (fieldlength == 0 || (element.value && fieldlength > 0 && regex.test(element.value) ));
}

validators["float"].getErrorMsg = function(displayname, element) {
  var msg = "Im Feld \'#fieldname#' sind nur reale Zahlenwerte zulässig!\nAktueller Wert: \'#fieldvalue#\'";
  return msg.replace(/#fieldname#/, displayname).replace(/#fieldvalue#/, element.value);
}



/**
 * Min-Value-Validator implementing "interface" IValidator.
 *
 * Returns true, if the validationvalue is a number is at least as big as the attribute 'minvalue' of the formelement, otherwise false.
 *
 */
validators["minvalue"] = new IValidator();

validators["minvalue"].validate = function(element) {
  var regex  = /(^-?\d\d*\.?\d*$)/;
  var fieldlength = trim(element.value).length;
  return (fieldlength == 0 || (element.value && fieldlength > 0 && regex.test(element.value) && (element.value >= element.getAttribute('minvalue')) ));
}

validators["minvalue"].getErrorMsg = function(displayname, element) {
  var msg = "Der Mindestwert im Feld \'#fieldname#\' ist unterschritten! \nMindestwert: \'#minvalue#\'\nAktueller Wert: \'#fieldvalue#\'";
  return msg.replace(/#fieldname#/, displayname).replace(/#fieldvalue#/, element.value).replace(/#minvalue#/, element.getAttribute('minvalue'));
}



/**
 * Max-Value-Validator implementing "interface" IValidator.
 *
 * Returns true, if the validationvalue is a number and is not bigger as the attribute 'maxvalue' of the formelement, otherwise false.
 *
 */
validators["maxvalue"] = new IValidator();

validators["maxvalue"].validate = function(element) {
  var regex  = /(^-?\d\d*\.?\d*$)/;
  var fieldlength = trim(element.value).length;
  return (fieldlength == 0 || (element.value && fieldlength > 0 && regex.test(element.value) && (element.value <= element.getAttribute('maxvalue')) ));
}

validators["maxvalue"].getErrorMsg = function(displayname, element) {
  var msg = "Der Maximalwert im Feld \'#fieldname#\' ist überschritten! \nMaximalwert: \'#maxvalue#\'\nAktueller Wert: \'#fieldvalue#\'";
  return msg.replace(/#fieldname#/, displayname).replace(/#fieldvalue#/, element.value).replace(/#minvalue#/, element.getAttribute('maxvalue'));
}



/**
 * Min-Bindings-Validator derived from minvalue with different errormessage.
 *
 */
validators["minbindings"] = new IValidator();

validators["minbindings"].validate = validators["minvalue"].validate;

validators["minbindings"].getErrorMsg = function(displayname, element) {
  var msg;
  if(element.getAttribute('minvalue') == 1)
    msg = "Es muss mindestens 1 Verknüpfung des Typs \'#fieldname#\' erstellt werden!";
  else
    msg = "Es müssen mindestens #minvalue# Verknüpfungen des Typs \'#fieldname#\' erstellt werden!";
  return msg.replace(/#fieldname#/, displayname).replace(/#fieldvalue#/, element.value).replace(/#minvalue#/, element.getAttribute('minvalue'));
}


validators["fckeditorrequired"] = new IValidator();

validators["fckeditorrequired"].validate = function(element) {
  for ( i = 0; i < parent.frames.length; ++i )
    if ( parent.frames[i].FCK )
      parent.frames[i].FCK.UpdateLinkedField();
  
  var fckEd = getFCKeditorInstance(element.name);
  var content = fckEd.GetHTML();
  return(content && trim(content).length > 0);
}

validators["fckeditorrequired"].getErrorMsg = function(displayname, element) {
  var msg = "Bitte wählen Sie einen Wert für \'#fieldname#\' aus!";
  return msg.replace(/#fieldname#/, displayname);
}



validators["date_de"] = new IValidator();

validators["date_de"].validate = function(element) {
  var regex  = /^(0[1-9]|[12][0-9]|3[01])([.])(0[1-9]|1[012])\2(199[6-9]|200[0-9])$/;
  var fieldlength = trim(element.value).length;
  return (fieldlength == 0 || (element.value && fieldlength > 0 && regex.test(element.value) ));
}

validators["date_de"].getErrorMsg = function(displayname, element) {
  var msg = "Fehlerhaftes Datumsformat im Feld \'#fieldname#\'!\nBitte geben Sie ein Datum mit dem Format tt.mm.jjjj  an!";
  return msg.replace(/#fieldname#/, displayname);
}



validators["datetime_de"] = new IValidator();

validators["datetime_de"].validate = function(element) {
  var regex  = /^(0[1-9]|[12][0-9]|3[01])([.])(0[1-9]|1[012])\2(199[6-9]|200[0-9]) ([01][0-9]|2[0-3]):([0-5][0-9])$/;
  var fieldlength = trim(element.value).length;
  return (fieldlength == 0 || (element.value && fieldlength > 0 && regex.test(element.value) ));
}

validators["datetime_de"].getErrorMsg = function(displayname, element) {
  var msg = "Fehlerhaftes Datumsformat im Feld \'#fieldname#\'!\nBitte geben Sie ein Datum mit dem Format tt.mm.jjjj hh:mm an!";
  return msg.replace(/#fieldname#/, displayname);
}