/*
 * 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.dynamicjsonparser.extender;

import com.fasterxml.jackson.databind.JsonNode;
import com.megatim.dynamicjsonparser.pojo.CustomError;
import com.megatim.dynamicjsonparser.pojo.JsonField;
import com.megatim.dynamicjsonparser.pojo.JsonParsedData;
import com.megatim.dynamicjsonparser.pojo.Node;
import com.megatim.dynamicjsonparser.pojo.Indexe;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.apache.commons.validator.GenericValidator;
import org.burningwave.core.Virtual;
import org.burningwave.core.classes.Constructors;

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

    private final List<Node> nodes;
    private final Class classOfEntity;
    private final List<JsonField> jsonFields;
    private final String rootClass;

    private final JsonParsedData parsedData = new JsonParsedData();

    public JsonDataProcessor(List<Node> nodes, Class classOfEntity, List<JsonField> jsonFields, String rootClass) {
        this.nodes = nodes;
        this.classOfEntity = classOfEntity;
        this.jsonFields = jsonFields;
        this.rootClass = rootClass;
    }

    public JsonParsedData iterateThroughNodes() {
        for (Node node : nodes) {

            Virtual virtualObject = traverseNode(node.getNode(), classOfEntity, jsonFields, Arrays.asList(new Indexe(node.getIndex())),
                    rootClass);

            //Ajout de l'objet extrait dans la liste
            parsedData.getVirtuals().add(virtualObject);
        }
        return parsedData;
    }

    private JsonField retrieveField(List<JsonField> jsonFields, String fieldName) {
        Optional<JsonField> optJsonField = jsonFields.stream().filter(j -> j.getName().equalsIgnoreCase(fieldName)).findFirst();
        if (optJsonField.isPresent()) {
            return optJsonField.get();
        } else {
            return null;
        }
    }

    /**
     * Méthode permettant de parcourir recursivement les noeuds du fichier json
     *
     * @param node : noeud à parcourir
     * @param classOfEntity : classe Java du noeud à parcourir
     * @param map : map contenant tous champs de la classe Java à utiliser lors
     * de l'extraction
     * @param indexes : tableau contenant la hiérarchie des index, cad les index
     * permettant de déterminer la posotion précise du noeud dans le fichier
     * @return
     */
    private Virtual traverseNode(final JsonNode node, final Class classOfEntity, final List<JsonField> jsonFields, List<Indexe> indexes, String fullQualifiedNameOfField) {
        if (node != null && classOfEntity != null && jsonFields != null && !jsonFields.isEmpty()) {
            Iterator<Map.Entry<String, JsonNode>> nodeFields = node.fields();
            Virtual virtualObject = new Constructors().newInstanceOf(classOfEntity);
            Set<String> foundFields = new HashSet<>();//contient les champs rencontrés dans chaque noeud json

            Integer index = indexes.get(0).getPosition();

            while (nodeFields.hasNext()) {

                Map.Entry<String, JsonNode> entry = nodeFields.next();
                final JsonField dynamicField = retrieveField(jsonFields, entry.getKey());

                //Si c'est un attribut de l'objet en cours de traitement
                if (dynamicField != null) {
                    foundFields.add(entry.getKey());

                    if (entry.getValue().toString().equals("null")) {//si la valeur du noeud est à null
                        if (dynamicField.isRequired()) {
                            parsedData.getErrors().add(requiredErrorMessage(entry.getKey(), fullQualifiedNameOfField, indexes));
                        }
                    } else {
                        //Si la donnée que contient le noeud est un tableau
                        if (entry.getValue().isArray() && entry.getValue().size() > 0) {

                            JsonNode firstElement = entry.getValue().get(0);

                            //Si c'est un tableau d'objets
                            if (firstElement.isObject()) { //si c'est un tableau d'objets
                                traverseArrayOfObjectNodes(virtualObject, entry, dynamicField, indexes, fullQualifiedNameOfField);
                            } else {
                                traverseArrayOfTextualNodes(virtualObject, entry, dynamicField, indexes, fullQualifiedNameOfField);
                            }
                        } else if (entry.getValue().isObject()) {
                            traverseSingleObjectNode(virtualObject, entry, dynamicField, indexes, fullQualifiedNameOfField);
                        } else {
                            traverseSingleTextualNode(virtualObject, entry, dynamicField, indexes, fullQualifiedNameOfField);
                        }
                    }
                } else {
                    CustomError customError = constructErrorMessage(indexes);
                    customError.getMessage().append("Attribut ").append("\"").append(fullQualifiedNameOfField).append(".").append(entry.getKey()).append("\"")
                            .append(" inexistant dans la définition de l'entité ").append("\"")
                            .append(jsonFields.get(0).getClassName())
                            .append("\"");
                    parsedData.getErrors().add(customError);
                }

            }
            //Vérifier si des champs obligatoirs sont absents
            checkIfRequiredFieldIsAbsent(foundFields, jsonFields, indexes, fullQualifiedNameOfField);
            index++;

            return virtualObject;
        } else {
            return null;
        }
    }

    private void checkIfRequiredFieldIsAbsent(Set<String> foundFields, final List<JsonField> jsonFields, List<Indexe> indexes, String fullQualifiedNameOfField) {
        jsonFields.forEach(j -> {
            if (j.isRequired() && !foundFields.stream().filter(f->f.equalsIgnoreCase(j.getName())).findFirst().isPresent()) {
                parsedData.getErrors().add(requiredErrorMessage(j.getName(), fullQualifiedNameOfField, indexes));
            }
        });
    }

    private CustomError requiredErrorMessage(String key, String fullQualifiedNameOfField, List<Indexe> indexes) {
        CustomError customError = constructErrorMessage(indexes);
        customError.getMessage().append("La valeur de l'attribut ").append("\"").append(fullQualifiedNameOfField).append(".").append(key).append("\"")
                .append(" ne peut être nulle ");

        return customError;
    }

    private void traverseArrayOfTextualNodes(Virtual virtualObject, Map.Entry<String, JsonNode> entry, JsonField dynamicField, List<Indexe> indexes, String fullQualifiedNameOfField) {

        if (entry.getValue().toString().equals("null") || entry.getValue().size() == 0) {
            if (dynamicField.isRequired()) {
                parsedData.getErrors().add(requiredErrorMessage(entry.getKey(), fullQualifiedNameOfField, indexes));
            }
            return;
        }
        Class classOfField = dynamicField.getClazz();
        CustomError customError = constructErrorMessage(indexes);
        customError.getMessage().append("\"").append(fullQualifiedNameOfField).append(".").append(entry.getKey()).append("\"").append(" {");

        boolean isTextFormatted = true;
        List<Object> values = new ArrayList<>();

        //On valide chaque élément du tableau
        for (int i = 0; i < entry.getValue().size(); i++) {
            Object finalObject = validateValue(entry.getValue().get(i).asText(), dynamicField);

            //Si l'objet retourné après validation est nul, alors la validation a échoué
            if (finalObject == null) {
                customError.getMessage().append(" Elément N°").append(i + 1).append(" est mal formaté").append(", ");//On renseigne la position de l'élément qui a échoué
                isTextFormatted = false;

            } else if (finalObject.toString().length() > dynamicField.getLengthh()) {
                customError.getMessage().append(" Elément N°").append(i + 1).append(" La taille de la donnée est supérieure à la taille attendue").append(", ");//On renseigne la position de l'élément qui a échoué
                isTextFormatted = false;
            }
            values.add(finalObject);// ajouter l'élément au tableau final
        }

        if (!isTextFormatted) {
            customError.getMessage().replace(customError.getMessage().length() - 2, customError.getMessage().length(), " }");
            parsedData.getErrors().add(customError);
        }

        List finalValues = convertToRealType(values, classOfField);
        virtualObject.invoke(setterofField(dynamicField.getName()), finalValues);
    }

    private void traverseArrayOfObjectNodes(Virtual virtualObject, Map.Entry<String, JsonNode> entry, JsonField dynamicField, List<Indexe> indexes, String fullQualifiedNameOfField) {
        if (entry.getValue().toString().equals("null") || entry.getValue().size() == 0) {
            if (dynamicField.isRequired()) {
                parsedData.getErrors().add(requiredErrorMessage(entry.getKey(), fullQualifiedNameOfField, indexes));
            }
            return;
        }
        List<Virtual> virtuals = new ArrayList<>();
        List<Indexe> subIndexes = new ArrayList<>();
        subIndexes.addAll(indexes);

        subIndexes.add(new Indexe(1, fullQualifiedNameOfField + "." + entry.getKey()));

        for (int i = 0; i < entry.getValue().size(); i++) {

            //Valider de façon récursive les objets du tableau
            virtuals.add(traverseNode(entry.getValue().get(i), dynamicField.getClazz(), dynamicField.getDynamicFields(), subIndexes, fullQualifiedNameOfField + "." + entry.getKey()));

            int subPosition = subIndexes.get(subIndexes.size() - 1).getPosition();
            subIndexes.get(subIndexes.size() - 1).setPosition(subPosition + 1);
        }

        virtualObject.invoke(setterofField(dynamicField.getName()), virtuals);
    }

    private void traverseSingleTextualNode(Virtual virtualObject, Map.Entry<String, JsonNode> entry, JsonField dynamicField, List<Indexe> indexes, String fullQualifiedNameOfField) {
        if (entry.getValue().toString().equals("null") || entry.getValue().asText().isEmpty()) {
            if (dynamicField.isRequired()) {
                parsedData.getErrors().add(requiredErrorMessage(entry.getKey(), fullQualifiedNameOfField, indexes));
            }
            return;
        }
        Object finalValue = validateValue(entry.getValue().asText(), dynamicField);

        if (finalValue == null) {
            CustomError customError = constructErrorMessage(indexes);
            customError.getMessage().append("\"").append(fullQualifiedNameOfField).append(".").append(entry.getKey()).append("\"").append(" est mal formaté");
            parsedData.getErrors().add(customError);

        } else if (finalValue.toString().length() > dynamicField.getLengthh()) {
            CustomError customError = constructErrorMessage(indexes);
            customError.getMessage().append("\"").append(fullQualifiedNameOfField).append(".").append(entry.getKey()).append("\"").append(" La taille de la donnée est supérieure à la taille attendue");
            parsedData.getErrors().add(customError);
        } else {
            virtualObject.invoke(setterofField(dynamicField.getName()), finalValue);
        }
    }

    private void traverseSingleObjectNode(Virtual virtualObject, Map.Entry<String, JsonNode> entry, JsonField dynamicField, List<Indexe> indexes, String fullQualifiedNameOfField) {
        List<Indexe> subIndexes = new ArrayList<>();
        subIndexes.addAll(indexes);
        subIndexes.add(new Indexe(entry.getKey()));

        if (entry.getValue().toString().equals("null")) {
            if (dynamicField.isRequired()) {
                parsedData.getErrors().add(requiredErrorMessage(entry.getKey(), fullQualifiedNameOfField, indexes));
            }
            return;
        }
        Virtual virtual = traverseNode(entry.getValue(), dynamicField.getClazz(), dynamicField.getDynamicFields(), subIndexes, fullQualifiedNameOfField + "." + entry.getKey());

        virtualObject.invoke(setterofField(dynamicField.getName()), virtual);
    }

    private boolean validateDate(String value, String formatDate, String separateurDate) {
        boolean result = false;

        StringBuilder dateToValidate = new StringBuilder(0);

        if (separateurDate != null && !separateurDate.isEmpty()) {

            String[] dateArray = value.split(separateurDate);

            for (String d : dateArray) {
                dateToValidate.append(d);
            }
        } else {
            dateToValidate = new StringBuilder(value);
        }

        if (formatDate != null && !formatDate.isEmpty()) {
            result = GenericValidator.isDate(dateToValidate.toString(), formatDate, false);
        }
        return result;
    }

    /**
     * Méthode qui validate une donnée
     *
     * @param value
     * @param classOfField
     * @return
     */
    private Object validateValue(String value, JsonField dynamicField) {
        Object finalValue = null;
        Class classOfField = dynamicField.getClazz();

        try {
            if (classOfField.isAssignableFrom(LocalDate.class)) {

                boolean isFormatted = validateDate(value, dynamicField.getFormatDate(), dynamicField.getSeparateurDate());

                if (isFormatted) {
                    finalValue = value;
                }

            } else if (classOfField.isAssignableFrom(Long.class)) {

                finalValue = Long.valueOf(value);
            } else if (classOfField.isAssignableFrom(BigDecimal.class)) {
                finalValue = new BigDecimal(value);

            } else {
                finalValue = value;
            }
        } catch (Exception ex) {
        }
        return finalValue;
    }

    private List<LocalDate> convertListOfDate(List<Object> genericValues) {
        List<LocalDate> listeLocalDate = new ArrayList<>();

        genericValues.forEach(g -> {

            LocalDate localDate = null;

            if (g != null) {
                localDate = (LocalDate) g;
            }

            listeLocalDate.add(localDate);
        });
        return listeLocalDate;
    }

    private List<Long> convertListOfLong(List<Object> genericValues) {
        List<Long> listeLong = new ArrayList<>();

        genericValues.forEach(g -> {

            Long longValue = null;

            if (g != null) {
                longValue = (Long) g;
            }
            listeLong.add(longValue);
        });

        return listeLong;
    }

    private List<BigDecimal> convertListOfBigDecimal(List<Object> genericValues) {
        List<BigDecimal> listeBigDecimal = new ArrayList<>();

        genericValues.forEach(g -> {

            BigDecimal bigDecimalValue = null;

            if (g != null) {
                bigDecimalValue = (BigDecimal) g;
            }

            listeBigDecimal.add(bigDecimalValue);
        });

        return listeBigDecimal;
    }

    private List<String> convertListOfString(List<Object> genericValues) {
        List<String> listeString = new ArrayList<>();

        genericValues.forEach(g -> {

            String str = null;

            if (g != null) {
                str = (String) g;
            }

            listeString.add(str);
        });
        return listeString;
    }

    /**
     * Méthode qui converti une liste d'objets en une liste d'un type précis
     *
     * @param genericValues
     * @param classOfField
     * @return
     */
    private List convertToRealType(List<Object> genericValues, Class classOfField) {

        if (classOfField.isAssignableFrom(LocalDate.class)) {
            return convertListOfDate(genericValues);

        } else if (classOfField.isAssignableFrom(Long.class)) {
            return convertListOfLong(genericValues);

        } else if (classOfField.isAssignableFrom(BigDecimal.class)) {
            return convertListOfBigDecimal(genericValues);

        } else {
            return convertListOfString(genericValues);
        }
    }

    private CustomError constructErrorMessage(List<Indexe> indexes) {
        StringBuilder error = new StringBuilder();
        CustomError customError = new CustomError();
        customError.setEltNumber(indexes.get(0).getPosition());

        indexes.forEach(indexe -> {

            if (indexe.getFullQualifiedNameOfField() != null && !indexe.getFullQualifiedNameOfField().isEmpty() && indexe.getPosition() != 0) {
                error.append("\"").append(indexe.getFullQualifiedNameOfField()).append("\"").append(" : ").append("Elément N° ").append(indexe.getPosition()).append(" : ");

            } else if (indexe.getFullQualifiedNameOfField() != null && !indexe.getFullQualifiedNameOfField().isEmpty()) {
                error.append("\"").append(indexe.getFullQualifiedNameOfField()).append("\"").append(" : ");

            } else if (indexe.getPosition() != 0) {
                error.append("Elément N° ").append(indexe.getPosition()).append(" : ");
            }
        });

        customError.setMessage(error);
        return customError;
    }

    private static String setterofField(String fieldName) {

        String name = String.valueOf(fieldName.charAt(0)).toUpperCase() + fieldName.substring(1);

        return "set" + name;
    }
}