package com.megatim.fdxcommons.core.impl.db.validators;

import static com.megatim.fdxcommons.model.enumeration.Operateur.*;
import com.megatim.fdxcommons.model.enumeration.TypeDonnee;
import com.megatim.fdxcommons.model.integration.ColumnDefinition;
import com.megatim.fdxcommons.model.pojo.BetweenOperatorValues;
import com.megatim.fdxcommons.model.pojo.CriteriaEntity;
import com.megatim.fdxcommons.tools.exceptions.CommonApplicationValidationException;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.time.LocalDateTime;
import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.enterprise.context.Dependent;
import com.megatim.fdxcommons.core.ifaces.db.validators.CriteriaQueryValidator;

/**
 *
 * @author lenovo
 */
@Dependent
public class CriteriaQueryValidatorImpl implements CriteriaQueryValidator {

    @Override
    public List<String> validate(CriteriaEntity criterion, Map<String, ColumnDefinition> columnDefinitionsMap) {
        List<String> errors = new ArrayList<>();
//        int index = 1;
//        String numeroElt = " : Elément numéro " + index;
        TypeDonnee typeDonnee = null;

        if (criterion != null && isNotEmptyCriteria(criterion)) {
            if (criterion.getSubCriterias().isEmpty()) {
                if (!validateCriteriaNomColonne(columnDefinitionsMap, criterion)) {
                    errors.add("Colonne '" + criterion.getNomColonne() + "' des critères de sélection est introuvable");

                } else if ((typeDonnee = TypeDonnee.fromValeur(columnDefinitionsMap.get(criterion.getNomColonne().toLowerCase()).getTypeDonnee())) == null) {
                    errors.add("Le type de la colonne '" + criterion.getNomColonne() + "est introuvable");

                } else if (!validateCriteriaEntityValue(criterion, typeDonnee)) {
                    errors.add("Type de données de la colonne " + criterion.getNomColonne() + " incorrect");
                }
            } else {
                if (criterion.getCriteriaLogicConnector() == null) {
                    errors.add("Le connecteur logique est absent");
                }
                for (CriteriaEntity c : criterion.getSubCriterias()) {
                    errors.addAll(validate(c, columnDefinitionsMap));
                }
            }
        }
        return errors;
    }

    private boolean validateCriteriaNomColonne(Map<String, ColumnDefinition> columnDefinitionsMap, CriteriaEntity c) {
        return c.getNomColonne() != null
                && !c.getNomColonne().isEmpty()
                && columnDefinitionsMap.containsKey(c.getNomColonne().toLowerCase());
    }

    private boolean validateCriteriaEntityValue(CriteriaEntity criteriaEntity, TypeDonnee typeDonnee) {
        switch (criteriaEntity.getOperateur()) {
            case LIKE:
                return (criteriaEntity.getCriteriaValue() instanceof String) && columTypeIsString(typeDonnee);
            case IN:
            case NOT_IN:
                return (criteriaEntity.getCriteriaValue() instanceof List<?>) && elementsOfList((List) criteriaEntity.getCriteriaValue(), typeDonnee);
            case LOWER_OR_EQUALS_THAN:
            case LOWER_THAN:
            case GREATER_OR_EQUALS_THAN:
            case GREATER_THAN:
            case EQUALS:
            case NOT_EQUALS:
                return (criteriaEntity.getCriteriaValue() instanceof Comparable<?>) && criteriaValueHasCorrectType(criteriaEntity.getCriteriaValue(), typeDonnee);
            case BETWEEN:
            case NOT_BETWEEN:
                BetweenOperatorValues betweenOperatorValues = getBetweenOperatorValues(criteriaEntity.getCriteriaValue());
                criteriaEntity.setCriteriaValue(betweenOperatorValues);

                return betweenOperatorValues != null
                        && criteriaValueHasCorrectType(betweenOperatorValues.getLowerBound(), typeDonnee)
                        && criteriaValueHasCorrectType(betweenOperatorValues.getUpperBound(), typeDonnee)
                        && betweenOperatorValuesAreCorrect(betweenOperatorValues, typeDonnee);
            case IS_NULL:
            case IS_NOT_NULL:
                return criteriaEntity.getCriteriaValue() == null;
        }
        return false;
    }

    @Override
    public BetweenOperatorValues getBetweenOperatorValues(Object value) {
        BetweenOperatorValues betweenOperatorValues = null;
        if (!(value instanceof LinkedHashMap)) {
            throw new CommonApplicationValidationException("LinkedHashMap est attendu");
        }
        LinkedHashMap<String, String> map = (LinkedHashMap) value;
        String lowerBound = null;
        String upperBound = null;

        for (String key : map.keySet()) {
            if (key.equalsIgnoreCase("lowerBound")) {
                lowerBound = map.get(key);
            }
            if (key.equalsIgnoreCase("upperBound")) {
                upperBound = map.get(key);
            }
        }
        StringBuilder message = new StringBuilder("");

        if (lowerBound == null) {
            message.append("Borne inférieure absente\n");
        }
        if (upperBound == null) {
            message.append("Borne supérieure absente");
        }
        if (message.length() > 0) {
            throw new CommonApplicationValidationException(message.toString());
        }
        betweenOperatorValues = new BetweenOperatorValues(lowerBound, upperBound);

        return betweenOperatorValues;
    }

    /**
     * Vérifier que le borne inférieure est bel et bien inférieure à la borne
     * supérieure
     *
     * @param betweenOperatorValues
     * @param columnType
     * @return
     */
    private boolean betweenOperatorValuesAreCorrect(BetweenOperatorValues betweenOperatorValues, TypeDonnee typeDonnee) {
        boolean result = false;
        switch (typeDonnee) {

            case NUMERIQUE:
                try {
                Long lowerBound = Long.valueOf(betweenOperatorValues.getLowerBound().toString());
                Long upperBound = Long.valueOf(betweenOperatorValues.getUpperBound().toString());

                result = lowerBound <= upperBound;
                if (!result) {
                    throw new CommonApplicationValidationException("La borne inférieure ne peut être supérieure à la borne supérieure");
                }
            } catch (NumberFormatException ex) {
            }
            break;

            case DECIMAL:
                try {
                BigDecimal lowerBound = new BigDecimal(betweenOperatorValues.getLowerBound().toString());
                BigDecimal upperBound = new BigDecimal(betweenOperatorValues.getUpperBound().toString());

                result = lowerBound.compareTo(upperBound) <= 0;
                if (!result) {
                    throw new CommonApplicationValidationException("La borne inférieure ne peut être supérieure à la borne supérieure");
                }
            } catch (NumberFormatException ex) {
            }
            break;

            case DATE:
                try {
                Timestamp lowerBound = Timestamp.valueOf(LocalDateTime.parse(betweenOperatorValues.getLowerBound().toString()));
                Timestamp upperBound = Timestamp.valueOf(LocalDateTime.parse(betweenOperatorValues.getUpperBound().toString()));

                result = lowerBound.before(upperBound);
                if (!result) {
                    throw new CommonApplicationValidationException("La borne inférieure ne peut être supérieure à la borne supérieure");
                }
            } catch (DateTimeParseException ex) {
            }
            break;

            default:
                throw new CommonApplicationValidationException("L'opérarateur 'BETWEEN' n'est pas valable pour ce type de données " + typeDonnee);

        }
        return result;
    }

    private boolean elementsOfList(List<?> elements, TypeDonnee typeDonnee) {
        boolean result = true;

        for (Object elt : elements) {
            result = criteriaValueHasCorrectType(elt, typeDonnee);

            if (!result) {
                break;
            }
        }
        return result;
    }

    private boolean criteriaValueHasCorrectType(Object value, TypeDonnee typeDonnee) {
        boolean result = false;

        switch (typeDonnee) {
            case NUMERIQUE:
                try {
                Long.valueOf(value.toString());
                result = true;
            } catch (NumberFormatException ex) {
            }
            break;

            case DECIMAL:
                 try {
                new BigDecimal(value.toString());
                result = true;
            } catch (Exception ex) {
            }
            break;

            case DATE:
                try {
                Timestamp.valueOf(LocalDateTime.parse(value.toString()));
                result = true;
            } catch (IllegalArgumentException ex) {
            }
            break;

            case ALPHANUMERIQUE:
                result = value instanceof String;
                break;

            default:
                throw new CommonApplicationValidationException("Type de données inconnu");
        }
        return result;
    }

    private boolean columTypeIsString(TypeDonnee typeDonnee) {
        return typeDonnee.equals(TypeDonnee.ALPHANUMERIQUE);
    }

    private boolean isNotEmptyCriteria(CriteriaEntity c) {
        return c.getNomColonne() != null && !c.getNomColonne().isEmpty() && c.getOperateur() != null
                || c.getSubCriterias() != null && !c.getSubCriterias().isEmpty();
    }
}