package com.megatim.fdxcommons.tools.database.queries.validation;

import com.megatim.fdxcommons.model.enumeration.TypeDonnee;
import com.megatim.fdxcommons.model.integration.ColumnDefinition;
import com.megatim.fdxcommons.tools.database.exceptions.LocalDateTimeValueParseError;
import com.megatim.fdxcommons.tools.database.queries.metadata.InsertionLocalDateTimeValue;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.apache.commons.validator.GenericValidator;

/**
 *
 * @author Gabuntu
 */
public class TableDataValidationError {

    private final ArrayList<String> errors = new ArrayList<>();

    private final Map<String, ColumnDefinition> columnNameToColumnDefinition;
    private final List<ColumnDefinition> columnDefinitions;
    private final List<LinkedHashMap<String, Object>> data;
    private final boolean withOptionalColumn;

    public TableDataValidationError(List<LinkedHashMap<String, Object>> data, List<ColumnDefinition> columnDefinitions) {
        this(data, columnDefinitions, false);
    }

    public TableDataValidationError(List<LinkedHashMap<String, Object>> data, List<ColumnDefinition> columnDefinitions, boolean withOptionalColumn) {
        this.data = data;
        this.withOptionalColumn = withOptionalColumn;
        this.columnDefinitions = columnDefinitions;
        this.columnNameToColumnDefinition = columnDefinitions.stream().collect(Collectors.toMap(c -> c.getName().trim().toLowerCase(), c -> c));
    }

    public String validationError() {
        if (errors.isEmpty()) {
            int index = 1;
            for (Map<String, Object> dataItem : data) {
                processDataItem(dataItem, index++);
            }
        }
        return error();
    }

    private String error() {
        StringBuilder stringBuilder = new StringBuilder("");
        errors.forEach(e -> {
            if (e != null && !e.isEmpty()) {
                stringBuilder.append(e).append("\n");
            }
        }
        );
        return stringBuilder.toString();
    }

    private void processDataItem(Map<String, Object> dataItem, int index) {

        for (Map.Entry<String, Object> dataItemEntry : dataItem.entrySet()) {

            String columnName = dataItemEntry.getKey();
            Object columnValue = dataItemEntry.getValue();

            ColumnDefinition columnDefinition = columnNameToColumnDefinition.get(columnName.trim().toLowerCase());
            if (columnDefinition == null) {
                errors.add("La colonne " + columnName + " n'existe pas pour ce fichier. " + lineNumberString(index));
                return;
            }

            String error = columnValueError(columnValue, columnDefinition);
            if (error != null && !error.isEmpty()) {
                errors.add(error + " " + lineNumberString(index));
            }

        }

        if (!withOptionalColumn) {
            addErrorForNotFoundColumn(dataItem, index);
        }
    }

    private void addErrorForNotFoundColumn(Map<String, Object> dataItem, int index) {
        columnDefinitions.forEach(columnDefinition -> {
            String columnDefinitionName = columnDefinition.getName().toLowerCase();
            if (!columnNameExist(dataItem, columnDefinitionName)) {
                errors.add("La colonne " + columnDefinitionName + " est manquante dans la requête. " + lineNumberString(index));
            }
        });
    }

    private String columnValueError(Object columnValue, ColumnDefinition columnDefinition) {
        String columnType = columnDefinition.getTypeDonnee();

        if (columnType.equals(TypeDonnee.ALPHANUMERIQUE.toString())) {

            if (!isAlphaNumericColumn(columnValue)) {
                return "La colonne " + columnDefinition.getName() + " doit être alpha numérique";
            } else if (!lengthLowerOrEquals((String) columnValue, columnDefinition.getTaille())) {
                return "La taille de la colonne " + columnDefinition.getName() + " doit être inférieure ou égale à" + columnDefinition.getTaille();
            }

        } else if (columnType.equals(TypeDonnee.DECIMAL.toString())) {

            if (columnValue != null) {

                String stringValue = columnValue.toString();
                if (!GenericValidator.isDouble(stringValue)) {
                    return "La colonne " + columnDefinition.getName() + " doit être décimale";
                } else if (!lengthLowerOrEquals(stringValue, columnDefinition.getTaille())) {
                    return "La taille de la colonne " + columnDefinition.getName() + " doit être inférieure ou égale à " + columnDefinition.getTaille();
                }

            }

        } else if (columnType.equals(TypeDonnee.NUMERIQUE.toString())) {

            if (columnValue != null) {

                String stringValue = columnValue.toString();
                if (!GenericValidator.isLong(stringValue)) {
                    return "La colonne " + columnDefinition.getName() + " doit être numérique";
                } else if (!lengthLowerOrEquals(stringValue, columnDefinition.getTaille())) {
                    return "La taille de la colonne " + columnDefinition.getName() + " doit être inférieure ou égale à " + columnDefinition.getTaille();
                }

            }

        } else if (columnType.equals(TypeDonnee.DATE.toString())) {

            if (columnValue != null) {

                String stringValue = columnValue.toString();
                if (!GenericValidator.isDate(stringValue, columnDefinition.getFormatDate(), true)) {
                    return "La colonne " + columnDefinition.getName() + " doit être une date";
                } else if (!lengthEquals(stringValue, columnDefinition.getTaille())) {
                    return "La taille de la colonne " + columnDefinition.getName() + " doit être égale à " + columnDefinition.getTaille();
                }

                try {
                    new InsertionLocalDateTimeValue(columnDefinition.getFormatDate(), columnValue).value();
                } catch (LocalDateTimeValueParseError ex) {
                    return "Impossible de parser la valeur " + stringValue + " au format " + columnDefinition.getFormatDate() + " pour la colonne " + columnDefinition.getName();
                }

            }

        }

        return null;
    }

    private boolean isAlphaNumericColumn(Object columnValue) {
        return (columnValue == null || columnValue instanceof String);
    }

    private boolean lengthEquals(String value, int columnMaxLength) {
        return value.trim().length() == columnMaxLength;
    }

    private boolean lengthLowerOrEquals(String value, int columnMaxLength) {
        return value.trim().length() <= columnMaxLength;
    }

    private String lineNumberString(int index) {
        return "Ligne " + index;
    }

    private boolean columnNameExist(Map<String, Object> dataItem, String columnDefinitionName) {
        return dataItem.entrySet().stream().map(e -> e.getKey()).filter(key -> key.trim().toLowerCase().equals(columnDefinitionName)).findAny().isPresent();
    }

}