/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
 */
package com.megatim.fdxcommons.tools.database.queries.validation;

import com.megatim.fdxcommons.model.enumeration.TypeDonnee;
import com.megatim.fdxcommons.model.integration.json.JsonStructure;
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.Optional;
import org.apache.commons.validator.GenericValidator;

/**
 *
 * @author ASUS
 */
public class JsonDataValidationError {

    private final ArrayList<String> errors = new ArrayList<>();
    private final List<LinkedHashMap<String, Object>> data;
    private final JsonStructure jsonStructure;

    public JsonDataValidationError(List<LinkedHashMap<String, Object>> data, JsonStructure jsonStructure) {
        this.data = data;
        this.jsonStructure = jsonStructure;
    }

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

                if (error != null && !error.trim().isEmpty()) {
                    errors.add(elementNumberString(index++) + " : " + error);
                }
            }
        }
        return error();
    }

    private String processDataItem(Map<String, Object> dataItem, JsonStructure jsonStruct) {
        StringBuilder lineError = new StringBuilder("");

        //Vérifie si une colonne obligatoire est absente
        lineError.append(addErrorForNotFoundColumn(dataItem, jsonStruct.getFields()));

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

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

            Optional<JsonStructure> optField = jsonStruct.getFields().stream().filter(f -> f.getName().equalsIgnoreCase(columnName)).findFirst();

            if (!optField.isPresent()) {
                lineError.append("La colonne ").append(columnName).append(" n'existe pas pour ce fichier;");
                continue;
            }
            JsonStructure field = optField.get();

            if (field.isCollection() || field.getTypeDonnee().equals(TypeDonnee.OBJET)) {
                if (field.getTypeDonnee().equals(TypeDonnee.OBJET)) {

                    if (field.isCollection()) {
                        if (columnValue instanceof List) {
                            List liste = (List) columnValue;
                            int i = 1;

                            for (Object obj : liste) {
                                if (obj instanceof Map) {
                                    lineError.append(processDataItem((Map<String, Object>) obj, field));
                                } else {
                                    lineError.append("L'élément No ").append(i++).append(" de la colonne '").append(columnName).append("' doit être un objet;");
                                }
                            }
                        } else {
                            lineError.append(" La donnée de la colonne '").append(columnName).append("' doit être une liste;");
                        }
                    } else {
                        if (columnValue instanceof Map) {
                            lineError.append(processDataItem((Map<String, Object>) columnValue, field));
                        } else {
                            lineError.append(" La donnée de la colonne '").append(columnName).append("' doit être un objet;");
                        }
                    }
                } else {
                    if (columnValue instanceof List) {
                        simpleListValueError(columnValue, field);
                    } else {
                        lineError.append(" La donnée de la colonne '").append(columnName).append("' doit être une liste;");
                    }
                }
            } else {
                columnValueError(lineError, field, columnValue);
            }
        }
        return lineError.toString();
    }

    private String simpleListValueError(Object columnValue, JsonStructure field) {
        List liste = (List) columnValue;
        StringBuilder arrayError = new StringBuilder("");
        int i = 1;

        for (Object obj : liste) {
            arrayError.append(columnValueError(obj, field, i++));
        }
        return arrayError.toString().trim();
    }

    private void columnValueError(StringBuilder lineError, JsonStructure field, Object columnValue) {
        String error = columnValueError(columnValue, field);
        if (error != null && !error.trim().isEmpty()) {
            lineError.append(error.trim());
        }
    }

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

    private String addErrorForNotFoundColumn(Map<String, Object> dataItem, List<JsonStructure> fields) {
        StringBuilder message = new StringBuilder("");

        fields.forEach(f -> {
            String error = addErrorForNotFoundColumn(dataItem, f);
            if (!error.isEmpty()) {
                message.append("\n").append(error);
            }
        });
        return message.toString();
    }

    private String addErrorForNotFoundColumn(Map<String, Object> dataItem, JsonStructure jsonStruct) {
        String fieldName = jsonStruct.getName().toLowerCase();
        if (jsonStruct.isRequired() && !columnNameExist(dataItem, fieldName)) {
            return "La colonne " + fieldName + " est manquante. ";
        }
        return "";
    }

    private String columnValueError(Object columnValue, JsonStructure jsonStruct, int i) {
        TypeDonnee typeDonnee = jsonStruct.getTypeDonnee();

        switch (typeDonnee) {
            case ALPHANUMERIQUE:
                if (!isAlphaNumericColumn(columnValue)) {
                    return "L'élément No " + i + " doit être alphanumérique";
                } else if (!lengthLowerOrEquals((String) columnValue, jsonStruct.getLengthh())) {
                    return "La taille de l'élément No " + i + " doit être inférieure ou égale à" + jsonStruct.getLengthh() + ";";
                }
                break;
            case DECIMAL:
                if (columnValue != null) {

                    String stringValue = columnValue.toString();
                    if (!GenericValidator.isDouble(stringValue)) {
                        return "L'élément No " + i + " doit être décimale";
                    } else if (!lengthLowerOrEquals(stringValue, jsonStruct.getLengthh())) {
                        return "La taille de l'élément No " + i + " doit être inférieure ou égale à " + jsonStruct.getLengthh() + ";";
                    }

                }
                break;
            case NUMERIQUE:
                if (columnValue != null) {

                    String stringValue = columnValue.toString();
                    if (!GenericValidator.isLong(stringValue)) {
                        return "L'élément No " + i + " doit être numérique;";
                    } else if (!lengthLowerOrEquals(stringValue, jsonStruct.getLengthh())) {
                        return "La taille de l'élément No " + i + " doit être inférieure ou égale à " + jsonStruct.getLengthh() + ";";
                    }

                }
                break;
            case DATE:
                if (columnValue != null) {

                    String stringValue = columnValue.toString();
                    if (!GenericValidator.isDate(stringValue, jsonStruct.getFormatDate(), true)) {
                        return "L'élément No " + i + " doit être une date";
                    } else if (!lengthEquals(stringValue, jsonStruct.getLengthh())) {
                        return "La taille de l'élément No " + i + " doit être égale à " + jsonStruct.getLengthh() + ";";
                    }

                    try {
                        new InsertionLocalDateTimeValue(jsonStruct.getFormatDate(), columnValue).value();
                    } catch (LocalDateTimeValueParseError ex) {
                        return "Impossible de parser la valeur " + stringValue + " au format " + jsonStruct.getFormatDate() + " pour l'élément No " + i + ";";
                    }

                }
                break;
            default:
                break;
        }

        return "";
    }

    private String columnValueError(Object columnValue, JsonStructure jsonStruct) {
        TypeDonnee typeDonnee = jsonStruct.getTypeDonnee();

        switch (typeDonnee) {
            case ALPHANUMERIQUE:
                if (!isAlphaNumericColumn(columnValue)) {
                    return "La colonne " + jsonStruct.getName() + " doit être alphanumérique;";
                } else if (!lengthLowerOrEquals((String) columnValue, jsonStruct.getLengthh())) {
                    return "La taille de la colonne " + jsonStruct.getName() + " doit être inférieure ou égale à" + jsonStruct.getLengthh() + ";";
                }
                break;
            case DECIMAL:
                if (columnValue != null) {

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

                }
                break;
            case NUMERIQUE:
                if (columnValue != null) {

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

                }
                break;
            case DATE:
                if (columnValue != null) {

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

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

                }
                break;
            default:
                break;
        }

        return "";
    }

    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 elementNumberString(int index) {
        return "Elément No" + index;
    }

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