/*******************************************
shall make use of a function which will return an array of the form
    (
    (field_name1, validation_type1, error_message1, param11='', param12=''),
    (field_name2, validation_type2, error_message2, param12='', param22='')...
    )

Allowed Validation_types:
    - validateIsEmpty
    - validateURL
    - validateMinLength
    - validateMaxLength
    - validateDateFormat
    - isDateValid
    - validateEmail
    - validateStartEndDate
    - compareTwoFields
    - validateCreditCard
    - validateForOneInMany
    - validateDependentField
    - validateIntIsLessThan
    - validateIntIsGreaterThan
    - validateIsEqualTo
    - validateIsNumber
    - validateIsInteger
    - validateAllRequired

Within the function:
    oRequired[x][0] - Gives the Field Name
    oRequired[x][1] - Gives the Validation Type
    oRequired[x][2] - Gives the Error message
    oRequired[x][3] - Gives:
                        - is_editor in case of validateIsEmpty, assumes that the editor is tinyMCE Editor
                        - length_limit in case of (validateMinLength or validateMaxLength)
                        - Date Format in case of (validateDateFormat or isDateValid)
                        - End date value in case of (validateStartEndDate)
                        - value of the second field in case of (compareTwoFields)
                        - empty string in case of (validateForOneInMany)
                        - value against which the current field value shall be validated in case of (validateIntIsLessThan, validateIntIsGreaterThan, validateIsEqualTo)
                        - value of the parent field on which the current field depends in case of (validateDependentField)
                            == NOTE that the current field will be validated only if the parent field has the value specified by this parameter,
                        - the validation method to use in case of validateAllRequired
    oRequired[x][4] - Gives:
                        - array of other field names which needs to be used for the comparison in case of (validateForOneInMany, validateAllRequired)
                        - the parent field name which shall be used for the comparison in case of (validateDependentField)
                        

*******************************************/


function getFieldValue(obj) {
    var field = obj;
    if (field == null)  {
        return '';
    }
    else    {
        var field_type = '';
        try {
            field_type =  field.type;
        }
        catch(e){ field_type =''}

        if(field_type == undefined) {
            field_type ='';
        }

        if ((field.length > 0) && (field_type == ''))   {
            field_type = field[0].type;
        }
        else    {
            field_type = field.type;
        }
        if (field_type == 'text' || field_type == 'textarea' ||
            field_type == 'file' || field_type == 'select-one' ||
            field_type == 'radio' || field_type == 'password' ||
            field_type == 'checkbox'|| field_type == 'hidden') {
                var value = '';
                if (field_type == "select-one") {
                    value = getSelectValue(field);
                    
                } 
                else if(field_type == "radio" || field_type == "checkbox")  {
                    try {
                        value = getRadioVal(field);
                    }catch(e) {
                        alert("Exception e2nreq : "+e);
                    }
                }
                else {
                    value = field.value;
                }
                if(value == null || value == undefined) {
                    return '';
                }
                else    {
                    return value;
                }
        }
    }
    return '';
}

function validateRequired(form,func_name)   {
    var isValid = true;
    var focusField = null;
    var ii = 0;
    var msg = "Please enter/select the following field(s)\n"
    var error_msgs = new Array();
    try {
        if (func_name!=null)    { 
            eval('oRequired = new '+func_name+'()');
        }
        else    { 
            oRequired = new required();
        }
    }                
    catch(e) { oRequired = new required(); }
    var field_type=""
    
    for (x in oRequired) {
        var field = form[oRequired[x][0]];
        var validation_type = oRequired[x][1];
        
        if (field == null)  {
            error_msgs[ii++] = oRequired[x][2];
            isValid = false;
        }
        else    {
            try {
                field_type =  field.type;
            }
            catch(e){ field_type =''}

            if(field_type == undefined) {
                field_type ='';
            }

            if ((field.length > 0) && (field_type == ''))   {
                field_type = field[0].type;
            }
            else    {
                field_type = field.type;
            }
            
            if (field_type == 'text' ||
                field_type == 'textarea' ||
                field_type == 'file' ||
                field_type == 'select-one' ||
                field_type == 'radio' ||
                field_type == 'password' ||
                field_type == 'checkbox'||
                field_type == 'hidden') {

                var value = '';
                if (field_type == "select-one") {
                    value = getSelectValue(field);
                } 
                else if(field_type == "radio" || field_type == "checkbox")  {
                    try {
                        value = getRadioVal(field);
                    }catch(e) {
                        alert("Exception e2nreq : "+e);
                    }
                }
                else if(field.length > 0)   {
                    for(each_field=0; each_field< field.length; each_field++)   {
                        value = field[each_field].value;
                        if(value != null && value != undefined) {
                            break;
                        }
                    }
                }
                else {
                    value = field.value;
                }
                
                if(value == null || value == undefined) {
                    if(focusField == null)  {
                        focusField = field;
                    }
                    error_msgs[ii++] = oRequired[x][2];
                    isValid = false;
                }
                //if(value != null && value != undefined) {
                else    {
                    value = trim(value);
                    var return_val = false;
                    switch(validation_type) {
                        case 'validateIsEmpty':
                            var is_editor = oRequired[x][3];
                            if(is_editor)   {
                                if(tinyMCE) {
                                    value = tinyMCE.getContent();
                                }
                            }
                            return_val = validateIsEmpty(value);
                            break;
                        case 'validateURL':
                            return_val = validateURL(value);
                            break;
                        case 'validateMinLength':
                            var l_limit = oRequired[x][3];
                            return_val = validateMinLength(value, l_limit);
                            break;
                        case 'validateMaxLength':
                            var l_limit = oRequired[x][3];
                            return_val = validateMaxLength(value, l_limit);
                            break;
                        case 'validateDateFormat':
                            var df = oRequired[x][3];
                            return_val = validateDateFormat(value, df);
                            break;
                        case 'isDateValid':
                            var df = oRequired[x][3];
                            return_val = isDateValid(value, df);
                            break;
                        case 'validateEmail':
                            return_val = validateEmail(value);
                            break;
                        case 'validateStartEndDate':
                            var ed = oRequired[x][3];
                            return_val = validateStartEndDate(value, ed);
                            break;
                        case 'compareTwoFields':
                            var sf = oRequired[x][3];
                            return_val = compareTwoFields(value, sf);
                            break;
                        case 'validateCreditCard':
                            return_val = validateCreditCard(value);
                            break;
                        case 'validateNotEqualTo':
                            var comp_val = oRequired[x][3];
                            return_val = validateNotEqualTo(value, comp_val);
                            break;
                        case 'validateDependentField':
                            var p_val = oRequired[x][3];
                            if (getFieldValue(form[oRequired[x][4]]) == p_val)    {
                                return_val = validateIsEmpty(value);
                            }
                            else    {
                                return_val = true;
                            }
                            break;
                        case 'validateForOneInMany':
                            var o_fields = oRequired[x][4];
                            return_val = false;
                            var o_return_val = validateIsEmpty(value);
                            
                            if(o_return_val == false) {
                                if(focusField == null)  {
                                focusField = field;
                                }
                            }
                            return_val = return_val || o_return_val;
                            for(field_index=0; field_index< o_fields.length; field_index++) {
                                o_field = form[o_fields[field_index]];
                                o_value = getFieldValue(o_field);
                                o_return_val = validateIsEmpty(o_value);
                                if(o_return_val == false) {
                                    if(focusField == null)  {
                                        focusField = o_field;
                                    }
                                }
                                return_val = return_val || o_return_val;
                                
                            }
                            break;
                        case 'validateIntIsGreaterThan':
                            var mv = oRequired[x][3];
                            return_val = validateIntIsGreaterThan(value, mv);
                            break;
                        case 'validateIntIsLessThan':
                            var mv = oRequired[x][3];
                            return_val = validateIntIsLessThan(value, mv);
                            break;
                        case 'validateIsEqualTo':
                            var pv = oRequired[x][3];
                            return_val = validateIsEqualTo(value, pv);
                            break;
                        case 'validateIsNumber':
                            return_val = validateIsNumber(value);
                            break;
                        case 'validateIsInteger':
                            return_val = validateIsInteger(value);
                            break;
                        case 'validateAllRequired':
                            var valid_method = oRequired[x][3];
                            return_val = validateAllRequired(oRequired[x][0], valid_method);
                            break;
                        default:
                            return_val = validateIsEmpty(value);
                            break;
                    }
                    if(return_val == false) {
                        if(focusField == null)  {
                            focusField = field;
                        }
                        error_msgs[ii++] = oRequired[x][2];
                        isValid = false;
                    }
                }
            }
        }
    } // End of For Loop
                
    if (error_msgs.length > 0) {
        var errorMessage = error_msgs.join('\n');
        
        alert(msg+errorMessage);
        if((focusField!=null) && (focusField.type != "undefined"))  {  
            try {
                focusField.focus();                 
            }
            catch(err){}
        }
        return false;
    }
    return isValid;
}

function setSelectValue(sobj,val)   {
    for (var i=0;i<=sobj.length -1;i++) {
        if (sobj.options[i].value == val)   {
            sobj.options[i].selected = true;
            return ;
        }       
    }     
}

function getSelectValue(sobj)    {
    var si = sobj.selectedIndex;
    if (si >= 0) {
        return sobj.options[si].value;
    }
    if(sobj.value != '')    {
        return sobj.value;
    }
    return '';
}

function getSelectIndex(sobj)    {
    var si = sobj.selectedIndex;
    if (si >= 0) {
        return si;
    }
    return -1;
}

function getRadioVal(robj)  {
    var value = '';
    if(robj.length>0) {
        for (var i=0;i<=robj.length -1;i++) {
            if (robj[i].checked) {
                value = robj[i].value;
                break;
            }
        }
    }
    else {
        if (robj.checked) {
            value = robj.value;
        }
    }
    return value;
}

function trim(s) {
    return s.replace( /^\s*/, "" ).replace( /\s*$/, "" );
}

function getNumber(val) {
    if(validateIsNumber(val))   {
        try {
            var new_val = parseInt(trim(String(val)))
            return new_val;
        }
        catch(e)    {
            return -1000;
        }
    }
    return -1000;
}

function validateIntIsLessThan(int_val, target_val) {
    if(trim(String(int_val)) != '') {
        int_val = getNumber(int_val);
        target_val = getNumber(target_val);
        return (int_val < target_val)
    }
    return true;
}

function validateIntIsGreaterThan(int_val, target_val) {
    if(trim(String(int_val)) != '') {
        int_val = getNumber(int_val);
        target_val = getNumber(target_val);
        return (int_val > target_val)
    }
    return true;
}

function validateIsEqualTo(val, target_val) {
    if(trim(val) != '') {
        return (val == target_val);
    }
    return true;
}
function validateIsNumber(val)  {
    if(trim(String(val)) != '') {
        return !(isNaN(val));
    }
    return true;
}

function validateIsEmpty(obj_val)   {
    if(obj_val == null || obj_val == undefined)  {
        return false;
    }
    if(trim(obj_val) == '') {
        return false;
    }
    return true;
}

function validateURL(obj_val)   {
    /***************
    Checks for urls of type 
        - http(s)://w.w.w
        - http(s)://w.w
    *******************/
    if(obj_val == '')   {
        return true;
    }
    var re = /^(http(s)?:+\/\/)(www.)?([a-zA-Z0-9_.-])+.(com|net|org|info|biz|tv|us|cc|name|bz|edu|de|be|co.nz|at|tk)(\/([a-zA-Z0-9_.-])+)?$/;
    
    return re.test(trim(obj_val));
}

function validateMinLength(obj_val, min_len)    {
    return ((trim(obj_val)).length >= min_len);
}

function validateMaxLength(obj_val, max_len)    {
    return ((trim(obj_val)).length <= max_len);
}

function validateEmail(obj_val) {
    /*************************
    checks for email ids of the form:
        abd@abc.abc
        abc.abc@abc.abc
        abc.abc...@abc.abc...
    allows the folloing special characters before the @ character:
        -, +, ., '
    *************************/
    if(obj_val == '')   {
        return true;
    }
    var re = /^\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/;
    return re.test(obj_val);
}

function validateStartEndDate(st_dt, end_dt)    {
    if(st_dt == '' && end_dt == '') {
        return true;
    }
    flg = compareDates(st_dt, 'dd/MM/yyyy HH:mm', end_dt, 'dd/MM/yyyy HH:mm');
    return_val = true;
    if(flg == 1)    {
        return_val = false;
    }
    else    {
        flg = compareDates(end_dt, 'dd/MM/yyyy HH:mm', st_dt, 'dd/MM/yyyy HH:mm');
        if(flg == 0)    {
            return_val = false;
        }
    }

    
    return return_val;
}

function compareTwoFields(obj_val1, obj_val2)   {
    return (trim(obj_val1) == trim(obj_val2));
}

function validateDateFormat(obj_val, format_val)    {
    /**************************
    Supported Date Formats:
        - DD/MM/YYYY
        - DD/MM/YY
        - MM/DD/YYYY
        - MM/DD/YY
    **************************/
    var re = '';
    switch(format_val)  {
        case 'DD/MM/YYYY':
        case 'MM/DD/YYYY':
            re = /^([0-9][0-9])(\/)([0-9][0-9])\2\d\d\d\d$/;
            break;
        case 'DD/MM/YY':
        case 'MM/DD/YY':
            re = /^([0-9][0-9])(\/)([0-9][0-9])\2\d\d$/;
            break;
        default:
            return false;
            break;
    }
    
    return re.test(obj_val);
}

function isDateValid(obj_val, format_val)   {
    /**************************
    Supported Date Formats:
        - DD/MM/YYYY
        - DD/MM/YY  - It is assumed that the year value is greater than 2000
        - MM/DD/YYYY
        - MM/DD/YY  - It is assumed that the year value is greater than 2000
    **************************/
    var re = '';
    var month_val = '';
    var day_val = '';
    var yr_val = '';
    var bool_val = false;
    var date_list = obj_val.split('/');
    switch(format_val)  {
        case 'DD/MM/YYYY':
            re = /^([012][0-9]|3[01])(\/)(0[1-9]|1[012])\2(19|20)\d\d$/;
            day_val = date_list[0];
            month_val = date_list[1];
            yr_val = date_list[2];
            break;
        case 'MM/DD/YYYY':
            re = /^(0[1-9]|1[012])(\/)([012][0-9]|3[01])\2(19|20)\d\d$/;
            day_val = date_list[1];
            month_val = date_list[0];
            yr_val = date_list[2];
            break;
        case 'DD/MM/YY':
            re = /^([012][0-9]|3[01])(\/)(0[1-9]|1[012])\2\d\d$/;
            day_val = date_list[0];
            month_val = date_list[1];
            yr_val = date_list[2] + 2000;
            break;
        case 'MM/DD/YY':
            re = /^(0[1-9]|1[012])(\/)([012][0-9]|3[01])\2\d\d$/;
            day_val = date_list[1];
            month_val = date_list[0];
            yr_val = date_list[2] + 2000;
            break;
        default:
            return false;
            break;
    }
    if(re.test(obj_val))    {
        if((day_val == 31) && (month_val==4 || month_val==6 || month_val==9 || month_val==11))  {
            return false;
        }
        else if(day_val > 29 && month_val == 2) {
            return false;
        }
        else if(day_val == 29 && month_val == 2 && !((yr_val % 4 == 0) && (yr_val % 100 !=0 || yr_val % 400 == 0))) {
            return false;
        }
        else    {
            return true;
        }
    }
    return false;
}

function validateAllRequired(field_name, valid_method)    {
    
    o_fields = document.getElementsByName(field_name);
        for(i=0;i<o_fields.length;i++)  {
            if(!(eval(valid_method + "('" + getFieldValue(o_fields[i]) + "')")))   {
                return false;
            }
        }
    return true;
}

function validateNotEqualTo(val1, val2) {
    return val1 != val2;
}

function validateIsInteger(val) {
    if (val.length > 0)   {
        if (!isAllDigits(val)) {
            return false;
        }
        else {
            var ival = parseInt(val);
            if (isNaN(ival) || !(ival >= -2147483648 && ival <= 2147483647)) {
                return false;
            }
        }
    }
    return true;
}

function isAllDigits(argvalue) {
    argvalue = argvalue.toString();
    var validChars = "0123456789";
    var startFrom = 0;
    if (argvalue.substring(0, 2) == "0x") {
       validChars = "0123456789abcdefABCDEF";
       startFrom = 2;
    } else if (argvalue.charAt(0) == "0") {
       validChars = "01234567";
       startFrom = 1;
    } else if (argvalue.charAt(0) == "-") {
        startFrom = 1;
    }

    for (var n = startFrom; n < argvalue.length; n++) {
        if (validChars.indexOf(argvalue.substring(n, n+1)) == -1) return false;
    }
    return true;
}

function validateCreditCard(obj_val) {
    return luhnCheck(obj_val);
}

/**
 * Reference: http://www.ling.nwu.edu/~sburke/pub/luhn_lib.pl
 */
function luhnCheck(cardNumber) {
    //alert("Card nubmer is : "+cardNumber);
    if (isLuhnNum(cardNumber)) {
        var no_digit = cardNumber.length;
        var oddoeven = no_digit & 1;
        var sum = 0;
        for (var count = 0; count < no_digit; count++) {
            var digit = parseInt(cardNumber.charAt(count));
            if (!((count & 1) ^ oddoeven)) {
                digit *= 2;
                if (digit > 9) digit -= 9;
            };
            sum += digit;
        };
        if (sum == 0) return false;
        if (sum % 10 == 0) return true;
    };
    return false;
}

function isLuhnNum(argvalue) {
    argvalue = argvalue.toString();
    if (argvalue.length == 0) {
        return false;
    }
    for (var n = 0; n < argvalue.length; n++) {
        if ((argvalue.substring(n, n+1) < "0") ||
            (argvalue.substring(n,n+1) > "9")) {
            return false;
        }
    }
    return true;
}