package es.dalocar.software.validator;

import org.apache.commons.validator.Field;
import org.apache.commons.validator.GenericTypeValidator;
import org.apache.commons.validator.GenericValidator;
import org.apache.commons.validator.Validator;
import org.apache.commons.validator.ValidatorException;
import org.apache.commons.validator.util.ValidatorUtils;


/**
 * Contains validation methods for different basic validations.
 */
public class BasicValidator {

    /**
     * Throws a runtime exception if the value of the argument is "RUNTIME", an
     * exception if the value of the argument is "CHECKED", and a
     * ValidatorException otherwise.
     * 
     * @param bean
     *            the bean to validate
     * @param field
     *            the bean field to take
     * 
     * @return
     * @throws RuntimeException
     *             with "RUNTIME-EXCEPTION as message" if value is "RUNTIME"
     * @throws Exception
     *             with "CHECKED-EXCEPTION" as message if value is "CHECKED"
     * @throws ValidatorException
     *             with "VALIDATOR-EXCEPTION" as message otherwise
     */
    public static boolean validateRaiseException(final Object bean,
            final Field field) throws Exception {

        final String value = ValidatorUtils.getValueAsString(bean, field
                .getProperty());

        if ("RUNTIME".equals(value)) {
            throw new RuntimeException("RUNTIME-EXCEPTION");

        } else if ("CHECKED".equals(value)) {
            throw new Exception("CHECKED-EXCEPTION");

        } else {
            throw new ValidatorException("VALIDATOR-EXCEPTION");
        }
    }

    /**
     * Checks if the field is required.
     * 
     * @param bean
     * @param field
     *            The field validation is being performed on
     * 
     * @return boolean If the field isn't <code>null</code> and has a length
     *         greater than zero, <code>true</code> is returned. Otherwise
     *         <code>false</code>.
     */
    public static boolean validateRequired(Object bean, Field field) {
        String value = ValidatorUtils.getValueAsString(bean, field
                .getProperty());

        return !GenericValidator.isBlankOrNull(value);
    }

    /**
     * Checks if the field can be successfully converted to a <code>byte</code>.
     * 
     * @param bean
     *            the bean to validate
     * @param field
     *            The field validation is being performed on.
     * @return boolean If the field can be successfully converted to a
     *         <code>byte</code> <code>true</code> is returned. Otherwise
     *         <code>false</code>.
     */
    public static boolean validateByte(Object bean, Field field) {
        String value = ValidatorUtils.getValueAsString(bean, field
                .getProperty());

        return GenericValidator.isByte(value);
    }

    /**
     * Checks if the field can be successfully converted to a <code>short</code>.
     * 
     * @param bean
     *            The bean to validate
     * @param field
     *            The field validation is being performed on.
     * @return boolean If the field can be successfully converted to a
     *         <code>short</code> <code>true</code> is returned. Otherwise
     *         <code>false</code>.
     */
    public static boolean validateShort(Object bean, Field field) {
        String value = ValidatorUtils.getValueAsString(bean, field
                .getProperty());

        return GenericValidator.isShort(value);
    }

    /**
     * Checks if the field can be successfully converted to a <code>int</code>.
     * 
     * @param bean
     *            The bean to validate
     * @param field
     *            The field validation is being performed on.
     * @return boolean If the field can be successfully converted to a
     *         <code>int</code> <code>true</code> is returned. Otherwise
     *         <code>false</code>.
     */
    public static boolean validateInteger(Object bean, Field field) {
        String value = ValidatorUtils.getValueAsString(bean, field
                .getProperty());

        return GenericValidator.isInt(value);
    }

    /**
     * Checks if field is positive assuming it is an integer
     * 
     * @param bean
     *            The bean to validate
     * @param field
     *            Description of the field to be evaluated
     * @return boolean If the integer field is greater than zero, returns true,
     *         otherwise returns false.
     */
    public static boolean validatePositive(Object bean, Field field) {
        String value = ValidatorUtils.getValueAsString(bean, field
                .getProperty());

        return GenericTypeValidator.formatInt(value).intValue() > 0;
    }

    /**
     * Checks if the field can be successfully converted to a <code>long</code>.
     * 
     * @param bean
     *            The bean to validate
     * @param field
     *            The field validation is being performed on.
     * @return boolean If the field can be successfully converted to a
     *         <code>long</code> <code>true</code> is returned. Otherwise
     *         <code>false</code>.
     */
    public static boolean validateLong(Object bean, Field field) {
        String value = ValidatorUtils.getValueAsString(bean, field
                .getProperty());

        return GenericValidator.isLong(value);
    }

    /**
     * Checks if the field can be successfully converted to a <code>float</code>.
     * 
     * @param bean
     *            The bean to validate
     * @param field
     *            The field validation is being performed on.
     * @return boolean If the field can be successfully converted to a
     *         <code>float</code> <code>true</code> is returned. Otherwise
     *         <code>false</code>.
     */
    public static boolean validateFloat(Object bean, Field field) {
        String value = ValidatorUtils.getValueAsString(bean, field
                .getProperty());

        return GenericValidator.isFloat(value);
    }

    /**
     * Checks if the field can be successfully converted to a
     * <code>double</code>.
     * 
     * @param bean
     *            The bean to validate
     * @param field
     *            The field validation is being performed on.
     * @return boolean If the field can be successfully converted to a
     *         <code>double</code> <code>true</code> is returned. Otherwise
     *         <code>false</code>.
     */
    public static boolean validateDouble(Object bean, Field field) {
        String value = ValidatorUtils.getValueAsString(bean, field
                .getProperty());

        return GenericValidator.isDouble(value);
    }

    /**
     * Checks if the field is an e-mail address.
     * 
     * @param bean
     *            The bean to validate
     * @param field
     *            The field validation is being performed on.
     * @return boolean If the field is an e-mail address <code>true</code> is
     *         returned. Otherwise <code>false</code>.
     */
    public static boolean validateEmail(Object bean, Field field) {
        String value = ValidatorUtils.getValueAsString(bean, field
                .getProperty());

        return GenericValidator.isEmail(value);
    }

    /**
     * Checks if the field is an e-mail address.
     * 
     * @param bean
     *            The bean to validate
     * @param field
     *            The field validation is being performed on.
     * @param validator
     * @return boolean If the field is an e-mail address <code>true</code> is
     *         returned. Otherwise <code>false</code>.
     */
    public static boolean validateRequiredIf(Object bean, Field field,
            Validator validator) {

        final String FIELD_TEST_NULL = "NULL";
        final String FIELD_TEST_NOTNULL = "NOTNULL";
        final String FIELD_TEST_EQUAL = "EQUAL";

        Object form = validator.getParameterValue(Validator.BEAN_PARAM);
        String value = null;
        boolean required = false;
        if (isString(bean)) {
            value = (String) bean;
        } else {
            value = ValidatorUtils.getValueAsString(bean, field.getProperty());
        }
        int i = 0;
        String fieldJoin = "AND";
        if (!GenericValidator.isBlankOrNull(field.getVarValue("fieldJoin"))) {
            fieldJoin = field.getVarValue("fieldJoin");
        }
        if (fieldJoin.equalsIgnoreCase("AND")) {
            required = true;
        }
        while (!GenericValidator.isBlankOrNull(field.getVarValue("field[" + i
                + "]"))) {
            String dependProp = field.getVarValue("field[" + i + "]");
            String dependTest = field.getVarValue("fieldTest[" + i + "]");
            String dependTestValue = field.getVarValue("fieldValue[" + i + "]");
            String dependIndexed = field.getVarValue("fieldIndexed[" + i + "]");
            if (dependIndexed == null)
                dependIndexed = "false";
            String dependVal = null;
            boolean this_required = false;
            if (field.isIndexed() && dependIndexed.equalsIgnoreCase("true")) {
                String key = field.getKey();
                if ((key.indexOf("[") > -1) && (key.indexOf("]") > -1)) {
                    String ind = key.substring(0, key.indexOf(".") + 1);
                    dependProp = ind + dependProp;
                }
            }
            dependVal = ValidatorUtils.getValueAsString(form, dependProp);
            if (dependTest.equals(FIELD_TEST_NULL)) {
                if ((dependVal != null) && (dependVal.length() > 0)) {
                    this_required = false;
                } else {
                    this_required = true;
                }
            }
            if (dependTest.equals(FIELD_TEST_NOTNULL)) {
                if ((dependVal != null) && (dependVal.length() > 0)) {
                    this_required = true;
                } else {
                    this_required = false;
                }
            }
            if (dependTest.equals(FIELD_TEST_EQUAL)) {
                this_required = dependTestValue.equalsIgnoreCase(dependVal);
            }
            if (fieldJoin.equalsIgnoreCase("AND")) {
                required = required && this_required;
            } else {
                required = required || this_required;
            }
            i++;
        }
        if (required) {
            if ((value != null) && (value.length() > 0)) {
                return true;
            } else {
                return false;
            }
        }
        return true;
    }

    /**
     * 
     * @param o
     * @return true if the object is a String
     */
    private static boolean isString(Object o) {
        Class stringClass = new String().getClass();
        if (o == null)
            return true;
        return (stringClass.isInstance(o));
    }


    /**
     * Valida la longitud minima de una cadena. Se deberá especificar la 
     * variable de longitud mínima:
     * <pre>
     * 		Ejemplo: var-name: minlength, var-value: 3
     * </pre>
     * @param bean
     * @param field
     * @return
     */
    public static boolean validateMinLength(Object bean, Field field) {
        String value = ValidatorUtils.getValueAsString(bean, field
                .getProperty());
        int minLength = Integer.parseInt(field.getVarValue("minlength"));
        
        return GenericValidator.minLength(value, minLength);
    }
    
    /**
     * Valida la longitud máxima de una cadena. Se deberá especificar la 
     * variable de longitud máxima:
     * <pre>
     * 		Ejemplo: var-name: maxlength, var-value: 3
     * </pre>
     * @param bean
     * @param field
     * @return
     */
    public static boolean validateMaxLength(Object bean, Field field) {
        String value = ValidatorUtils.getValueAsString(bean, field
                .getProperty());
        int maxLength = Integer.parseInt(field.getVarValue("maxlength"));
        
        return GenericValidator.maxLength(value, maxLength);
    }
    
    
}