/**
 * Author: Eugene Churmanov <eugenechurmanov@soft-rose.com>
 * Company: Soft-Rose
 * File: formvalidator.js
 * Creation Date: 15.01.2010
 * Modifed: 19.01.2010 12:43
 * Note:
 * Form Validation singilton object for instant validation form based on Zend_Form.
 * !Warning!: Validated form not must contain elements whith id/name "submit" 
 * 
 */
FormValidator = function()
{
    /**
     * Associative list of Error messages
     * Temporale solution, until will be not usage Zend_Validator error message 
     * 
     */
    var messageList = {
        "isEmpty": "This field is required",
        "emptyValue": "This field is required",
        "emailAddressLengthExceeded": "E-mail exceeds the allowed length",
        "emailAddressInvalidFormat": "Wrong email addres format",
        "emailAddressInvalidHostname": "Hostname is not a valid for email address",
        "TOO_SHORT": "String is too short",
        "TOO_LONG": "String is too long",
        "notMatch": "Entries do not match",
        "weakPassword": "Password should be at least 8 characters long.",
        "emptyPassword": "Please enter password."
    };
    
    /**
     * Validator NewUserEmail
     * @param Object e - element for validation
     * @param array a - array of params for validator 
     * @return Object {valid: bool, code: string} - result of validation and error code (if need)
     */
    function NewUserEmail(e,a){
        var v = e.getValue();
        var res = NotEmpty(e,a);
        if (!res.valid){
            return res;
        }
        res = EmailAddress(e,a);
        return res;
    }
    /**
     * Validator UserPassword
     * @param Object e - element for validation
     * @param array a - array of params for validator 
     * @return Object {valid: bool, code: string} - result of validation and error code (if need)
     */
    function UserPassword(e,a){
        var v = e.getValue();
        return {
            valid: v.length != 0, 
            code: v.length == 0 ? "emptyPassword" : undefined
        };
    }
    /**
     * Validator NotEmpty
     * @param Object e - element for validation
     * @param array a - array of params for validator 
     * @return Object {valid: bool, code: string} - result of validation and error code (if need)
     */
    function NotEmpty(e,a)
    {
        var v = e.getValue();
        return {
            valid: v.length != 0, 
            code: v.length == 0 ? "isEmpty" : undefined
        };
    }
    /**
     * Validator EmailAddress
     * @param Object e - element for validation
     * @param array a - array of params for validator 
     * @return Object {valid: bool, code: string} - result of validation and error code (if need)
     */
    function EmailAddress(e,a){
        var v = e.getValue();
        if ( v.indexOf('@')>64 || v.length - v.indexOf('@') > 255){
            return {
                valid: false,
                code: "emailAddressLengthExceeded"
            };
        }
        if ( v.indexOf('@') < 1 || v.indexOf('@') != v.lastIndexOf('@') ){
            return {
                valid: false,
                code: "emailAddressInvalidFormat"
            };
        }
        if ( v.indexOf('.', v.indexOf('@')) == -1 || 
                v.lastIndexOf('.') == v.length-1 || 
                v.charAt(v.indexOf('@') + 1) == '.' ){
            return {
                valid: false,
                code: "emailAddressInvalidHostname"
            };
        }
        return {
            valid: true
        };
        
    }
    /**
     * Validator UserEmail
     * @param Object e - element for validation
     * @param array a - array of params for validator 
     * @return Object {valid: bool, code: string} - result of validation and error code (if need)
     */
    function UserEmail(e,a){
        var v = e.getValue();
        if (v.length == 0){
            return {
                valid: false,
                code: "emptyValue"
            };
        }
        
        if ( v.indexOf('@') < 1 ||
                v.indexOf('@') != v.lastIndexOf('@') ||
                v.indexOf('.', v.indexOf('@')) == -1 ||
                v.lastIndexOf('.') == v.length-1 || 
                v.charAt(v.indexOf('@') + 1) == '.'
            ){
            return {
                valid: false,
                code: "Invalid E-mail Format"
            };
        }
        return {
            valid: true
        };
    }
    /**
     * Validator StringLength
     * @param Object e - element for validation
     * @param array a - array of params for validator 
     * @return Object {valid: bool, code: string} - result of validation and error code (if need)
     */
    function StringLength(e,a)
    {
        var v = e.getValue();
        if (v.length <= a[0]) {
            return {
                valid: false, 
                code: "TOO_SHORT"
            };
        }
        if (v.length >= a[1]) {
            return {
                valid: false,
                code: "TOO_LONG"
            };
        }
        return {
            valid: true
        }
    }
    /**
     * Validator Passwords
     * @param Object e - element for validation
     * @param array a - array of params for validator 
     * @return Object {valid: bool, code: string} - result of validation and error code (if need)
     */
    function Passwords(e,a)
    {
        var v = e.getValue();
        if (a[0] == null) {
            var conf=FormValidator.configs;
            for (var i = 0; i < conf.length; i++){
                var val=conf[i].validators;
                for (var j=0; j < val.length; j++){
                    if (val[j].validator == "Passwords" && val[j].params[0] == e.id){
                        checkElementValid(Ext.get(FormValidator.elements[i].id));
                    }
                }
            }
            return {
                valid: v.length >= 8, 
                code: v.length < 8 ? "weakPassword" : undefined
            };
        }
        
        if (v == Ext.fly(a[0]).getValue()) {
            return {
                valid: true
            };
        } else {
            return {
                valid: false, 
                code: "notMatch"
            };
        }
    }
    /**
     * function checkElementValidOnEvent
     * Fire on validated element event
     * @param EventObject e 
     * @param HTMLElement t 
     */
    function checkElementValidOnEvent(e,t)
    {
        el = Ext.get(t);
        if (el && Ext.isObject(el)) {
            checkElementValid(el);
        }
    }
    /**
     * function checkElementValid
     * Check all validators of elemen
     * @param Object el - EventObject
     * @return bool - valid or not valid value of element
     */
    function checkElementValid(el){
        var result = true;
        var validator = FormValidator.configs[FormValidator.elements.indexOf(el)].validators;
        var ul = el.next("ul.errors");
        if (ul) {
            ul.remove();
            dd = el.parent();
            ulConfig = {
                tag: "ul",
                cls: "errors",
                html: ""
            };
            ul=dd.createChild(ulConfig);
            ul.insertAfter(el);
        }
        var validing = true;
        for (var i=0,v=validator[i]; i < validator.length && validing  ; i++,v = validator[i]) {
            try{
                var res = eval(v.validator)(el, v.params);
                if (!res.valid) {
                    /**
                     *    Temporale disable using message from server validators
                     *    replaced by JS messageList
                     *     
                     */
                    if (messageList[res.code]){
                        var message = messageList[res.code];
                    } else {
                        var message = res.code;
                    }
                    if (v.messages[res.code]){
                        var message = v.messages[res.code];
                    } else {
                        var message = v.messages;
                    }
                    
                    /**
                     *    //
                     */
                    liConfig = {
                        tag: "li",
                        cls: "",
                        html: message
                    };
                    result = false;
                    el.next("ul.errors").createChild(liConfig);
                }
            } catch(e) {
                result = true;
            }
            validing = (result || !v.validStop);
        }
        return result;
    }
    /**
     * validateForm
     * Validate all elements in cofiguration
     * @return bool - valid or not valid form
     */
    function validateForm()
    {
        var result = true;
        for (var y = 0, res; y < FormValidator.elements.length; y++) {
            res = checkElementValid(FormValidator.elements[y]);
            result = result && res;
        }
        return result;
    }
    /**
     * addElementValidation
     * Add configuretion of one element to singilton
     * @param Object config - object of element configuration
     * @return bool - return true if configureation is apply
     */
    function addElementValidation(config){
        if (Ext.isObject(config)) {
            if (config.type == "SUBMIT"){
                var sub = Ext.get(config.elementId);
                sub.on(
                    'click',
                    function (e,t) {
                        var res = validateForm();
                        if (!res){
                            e.preventDefault();
                        }
                        return res;
                    }
                );
                return true;
            }
            if (config.elementId && config.validators) {
                if (FormValidator.elements.indexOf(Ext.get(config.elementId)) >= 0){
                    return false;
                }
                var l = FormValidator.elements.length;
                var el = Ext.get(config.elementId);
                
                FormValidator.elements[l] = el;
                FormValidator.configs[l] = config;
                var ul=el.next("ul.errors");
                if (!ul){
                    dd = el.parent();
                    ulConfig = {
                        tag: "ul",
                        cls: "errors",
                        html: ""
                    };
                    ul=dd.createChild(ulConfig);
                    ul.insertAfter(el);
                }
                
                return true;
            }
        }
        return false;
    }
    /**
     * Public part of singilton 
     */
    return {
        /**
         * Array of elements and configs 
         */
        elements: [],
        configs: [],
        /**
         * configure
         * Public method for getting configuration
         * @param array configForm - array of element valid configuration 
         */
        configure: function(configForm)
        {
            if (configForm.length>0) {
                for (var i = 0; i < configForm.length; i++){
                    addElementValidation(configForm[i]);
                    
                }
            }
        },
        submit: function()
        {
            var res = validateForm();
            if (!res){
                return false;
            }
            el = Ext.get(this.elements[0]).parent('form');
            el.dom.submit();
        }
        
    };
}();