if (!window.console) {
    if (!window.console || !console.firebug) {
        var names = ["log", "debug", "info", "warn", "error", "assert", "dir", "dirxml",
        "group", "groupEnd", "time", "timeEnd", "count", "trace", "profile", "profileEnd"];

        window.console = {};
        for (var i = 0; i < names.length; ++i) {
            window.console[names[i]] = function() {};
        }
    }
}

Ajax.Responders.register({
    onCreate: function() {
        if(Ajax.activeRequestCount > 0) {
            $$('a', '.icon', 'div').each(function(element){
                element.style.cursor = 'wait';
            });
        }
    },
    onComplete: function() {
        if(Ajax.activeRequestCount <= 0){
            $$('a', '.icon', 'div').each(function(element){
                element.style.cursor = '';
            });
        }
    }
});

var App = {};
App.redirect = function(location) {
    window.location = location;
};

App.getId = function (element, prefix) {
    return $(element).id.substring(prefix.length);
};

App.trim = function(s) {
    return s.replace(/^\s+|\s+$/, '');
};

App.setBookmark = function bookmark(url,title){
    if((navigator.appName == "Microsoft Internet Explorer") && (parseInt(navigator.appVersion) >= 4)) {
        window.external.AddFavorite(url,title);
    }
    else if (navigator.appName == "Netscape") {
        window.sidebar.addPanel(title,url,"");
    }
    else {
        alert("Press CTRL-D (Netscape), CTRL-T (Opera) or CTRL-D (Safari) to bookmark this page.");
    }
};



App.Form = Class.create();
App.Form.prototype = {

    initialize: function(form_id, options) {
        
        this.form_id = form_id;
        this.form    = $(form_id);
        
        this.option = {
            linkSubmit:     false,
            normalSubmit:   true,
            validation:     false,
            type:           'normal'    // normal | inline
        };
        Object.extend(this.option, options || {});

        if(this.option.linkSubmit) {
            $(this.option.linkSubmit).href = 'javascript:void(0);';
            Event.observe(this.option.linkSubmit, "click", this.linkSubmit.bindAsEventListener(this));
        }
        else {
            Event.observe(this.form, "submit", this.onSubmit.bindAsEventListener(this));
        }
        
        if (this.option.validation == true) {
            this.validation = new App.Validate(this, this.option);
        }
    },
    
    linkSubmit: function(event) {
        
        if (this.option.validation == true) {
            if (this.validation.validate() == false) {
                return;
            }
        }
        
        if (this.option.normalSubmit == false)
            this.form.request({
                method: 'post',
                onSuccess:  function(response) {
                    var json = response.responseText.evalJSON();
                    for(var i in json) $(i).update(json[i]);
                }
            });
        else {
            this.form.submit();
        }
    },
    
    onSubmit: function(event) {
        Event.stop(event);
        
        if (this.option.validation == true) {
            if (this.validation.validate() == false) {
                return;
            }
        }
        
        this.form.submit();
    }
};

App.Validate = Class.create();
App.Validate.prototype = {

    initialize: function(self) {
        Object.extend(this, self);

        this.registerEventHandler();
    },
    
    _isSet: function(element) {
        
        var tag = element.tagName.toLowerCase();
        
        if (tag == 'textarea' || tag == 'select') {
            if (App.trim($F(element)).length > 0) {
                return true;
            }
            return false;
        } else if ('input') {
            switch (element.type) {
                case 'checkbox':
                    return element.checked;
                case 'radio':
                    if (this.form.getInputs('radio', element.name).find(function(radio) {return radio.checked;})) {
                        return true
                    }
                    return false;
                default:
                    if (App.trim($F(element)).length > 0) {
                        return true;
                    }
                    return false;
            }
        }
        
        return false;
    },
    
    _setFocus: function() {
        if (this.option.type == 'normal') {
            if ($$('.validation-advice')[0] != undefined) {
                $($$('.validation-advice')[0].id.replace('advice_', '')).focus();
            }
        } else {
            if ($$('.error input')[0] != undefined) {
                $$('.error input')[0].focus();
            }
        }
    },
    
    _setError: function(element) {
        
        element.up('p').addClassName('error');
    },
    
    _remError: function(element) {
        if (element.up('p') && element.up('p').hasClassName('error')) {
            element.up('p').removeClassName('error');
        }
    },
    
    _getAdvice: function(element, content) {
        var msg = new Element('span', {'class':'validation-advice'});
        
        if(element.id != undefined) {
            msg.id = 'advice_' + element.id.camelize();
        }
        else {
            element.identify();
            msg.id = 'advice_' + element.id.camelize();
        }
        msg.update(content);
        return msg;
    },
    
    _remAdvice: function(element) {
        if($('advice_'+element.id.camelize())) {
            $('advice_'+element.id.camelize()).remove();
        }
    },
    
    _hasAdvice: function(element) {
        if($('advice_'+element.id.camelize())) {
            return true;
        }
        return false;
    },
    
    registerEventHandler: function() {
        
        this.form.getElements().each(function(element) {
            
            if (element.type != 'submit' && element.type != 'reset' && element.disabled !== true
                && element.id != 'recaptcha_challenge_field') {
                
                element.observe('blur', this.onBlurHandler.bindAsEventListener(this));
            }
        }.bind(this));
    },
    
    onBlurHandler: function(event) {
        this.validate(event);
    },
    
    validate: function(event) {
        this.isValid = true;
        
        if (event == undefined) {
            this.form.getElements().each(function(element) {
                
                if (element.type != 'submit' && element.type != 'reset' && element.disabled !== true
                    && element.id != 'recaptcha_challenge_field') {
                    
                    this._validate(element);
                    
                    // set focus first error element
                    this._setFocus();
                }
            }.bind(this));
        } else {
            this._validate(Event.element(event));
        }
        
        if (this.isValid == true) {
            return true;
        }
        
        return false;
    },
    
    _requiredValidation: function(element) {
        
        if (element.hasClassName('required') == true) {
            return true;
        }
        
        // if element is not required but musst be validated
        if (this._isSet(element)) {
            return true;
        }
        
        return false;
    },
    
    _validate: function(element) {
        
        if (this.option.type == 'normal') {
            this._remAdvice(element);
        } else {
            this._remError(element);
        }
        
        // check required
        if(this._requiredValidation(element)) {
            if(!this._isSet(element)) {
                if(this.option.type == 'normal')
                    new Insertion.After(element, this._getAdvice(element, ' *required'));
                else
                    this._setError(element);
                this.isValid = false;
            }
        }
        
        // check login
        if(element.hasClassName('validate-login') == true && this._requiredValidation(element)) {
            if(App.trim($F(element)).length < 5) {
                if(this.option.type == 'normal')
                    new Insertion.After(element, this._getAdvice(element, ' *minlength 5 chars'));
                else
                    this._setError(element);
                this.isValid = false;
            }
        }
        
        // check password
        if(element.hasClassName('validate-password') == true && this._requiredValidation(element)) {
            if(App.trim($F(element)).length < 8) {
                if(this.option.type == 'normal')
                    new Insertion.After(element, this._getAdvice(element, ' *minlength 8 chars'));
                else
                    this._setError(element);
                this.isValid = false;
            }
        }
        
        // check uplinecode
        if(element.hasClassName('validate-uplinecode') == true && this._requiredValidation(element)) {
            if(App.trim($F(element)).length != 32 || /^[a-f0-9]+$/.test(App.trim($F(element))) == false) {
                if(this.option.type == 'normal')
                    new Insertion.After(element, this._getAdvice(element, ' *no valid code'));
                else
                    this._setError(element);
                this.isValid = false;
            }
        }
        
        // check verify
        if(element.hasClassName('validate-verify') == true && this._requiredValidation(element)) {
            var element_v = $(element.id.replace(/_verify/, ''));
            if(($F(element) != $F(element_v)) == true) {
                if(this.option.type == 'normal')
                    new Insertion.After(element, this._getAdvice(element, ' *verification failed'));
                else
                    this._setError(element);
                this.isValid = false;
            }
        }
        
        // check digits
        if(element.hasClassName('validate-digits') == true && this._requiredValidation(element)) {
            if(!/[^\d]/.test(App.trim($F(element))) == false) {
                if(this.option.type == 'normal')
                    new Insertion.After(element, this._getAdvice(element, ' *only digits'));
                else
                    this._setError(element);
                this.isValid = false;
            }
        }
        
        // check alpha
        if(element.hasClassName('validate-alpha') == true && this._requiredValidation(element)) {
            if(/^[a-zA-Z]+$/.test(App.trim($F(element))) == false) {
                if(this.option.type == 'normal')
                    new Insertion.After(element, this._getAdvice(element, ' *only alpha'));
                else
                    this._setError(element);
                this.isValid = false;
            }
        }
        
        // check alphanum
        if(element.hasClassName('validate-alphanum') == true && this._requiredValidation(element)) {
            if(/([a-zA-Z0-9]+)$/.test(App.trim($F(element))) == false) {
                if(this.option.type == 'normal')
                    new Insertion.After(element, this._getAdvice(element, ' *only alphanum'));
                else
                    this._setError(element);
                this.isValid = false;
            }
        }
        
        // check date
        if(element.hasClassName('validate-date') == true && this._requiredValidation(element)) {
            var regex = /^(\d{2}).*(\d{2}).*(\d{4})$/;
            if(!regex.test(App.trim($F(element)))) {
                if(this.option.type == 'normal')
                    new Insertion.After(element, this._getAdvice(element, ' *no valid date'));
                else
                    this._setError(element);
                this.isValid = false;
            }
            else {
                var strDate = App.trim($F(element)).replace(regex, '$3, $2, $1');
                var d = new Date(strDate);

                if(( parseInt(RegExp.$2, 10) == (1+d.getMonth()) ) &&
                    (parseInt(RegExp.$1, 10) == d.getDate()) &&
                    (parseInt(RegExp.$3, 10) == d.getFullYear() ) == false) {
                    if(this.option.type == 'normal')
                        new Insertion.After(element, this._getAdvice(element, ' *no valid date'));
                    else
                        this._setError(element);
                    this.isValid = false;
                }
            }
        }
        
        // check time
        if(element.hasClassName('validate-time') == true && this._requiredValidation(element)) {
            var regex = /^(\d{1,2}):(\d{2})(:(\d{2}))?$/;
            if(!regex.test(App.trim($F(element)))) {
                if(this.option.type == 'normal')
                    new Insertion.After(element, this._getAdvice(element, ' *no valid date'));
                else
                    this._setError(element);
                this.isValid = false;
            }
            else {
                var matchArray = $F(element).match(regex);
                if((matchArray[1] > 23 || matchArray[1] < 0) ||
                   (matchArray[2] > 59 || matchArray[2] < 0)) {
                    
                    if(this.option.type == 'normal')
                        new Insertion.After(element, this._getAdvice(element, ' *no valid date'));
                    else
                        this._setError(element);
                    this.isValid = false;
                }
            }
        }
        
        // check email
        if(element.hasClassName('validate-email') == true && this._requiredValidation(element)) {
            if(/^firstname\.surname/.test($F(element))) {
                if(this.option.type == 'normal')
                    new Insertion.After(element, this._getAdvice(element, ' *no valid email'));
                else
                    this._setError(element);
                this.isValid = false;
            }
            else if(/^[a-zA-Z0-9-_\.@]+$/.test($F(element)) == false) {
                if(this.option.type == 'normal')
                    new Insertion.After(element, this._getAdvice(element, ' *no valid email'));
                else
                    this._setError(element);
                this.isValid = false;
            }
            else if(/^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,4}))$/.test(App.trim($F(element))) == false) {
                if(this.option.type == 'normal')
                    new Insertion.After(element, this._getAdvice(element, ' *no valid email'));
                else
                    this._setError(element);
                this.isValid = false;
            }
        }

        // check phone number
        if(element.hasClassName('validate-phone-number') == true && this._requiredValidation(element)) {
        	if(/^[0-9\ \/\-]*$/.test($F(element)) == false) {
        		if(this.option.type == 'normal')
        			new Insertion.After(element, this._getAdvice(element, ' *no valid phone number'));
        		else
        			this._setError(element);
        		this.isValid = false;
        	}
        
        }
    
    }

};