/*
 * 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.fasterxml.jackson.databind.ObjectMapper;
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 java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.burningwave.core.assembler.ComponentContainer;
import org.burningwave.core.assembler.ComponentSupplier;
import org.burningwave.core.classes.ClassFactory;
import org.burningwave.core.classes.UnitSourceGenerator;
import java.util.Collections;
import java.util.concurrent.ForkJoinPool;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * Classe permettant d'extraire les données d'un fichier json, de les valider
 *
 * @author ASUS
 */
public class JsonDataValidator {

    private JsonParsedData parsedData;

    public JsonParsedData getParsedData() {
        return parsedData;
    }

    /**
     * Méthode permettant d'extraire les données d'in fichier json
     *
     * @param dynamicFields
     * @param storePath
     * @param packageName : nom du package de la classe
     * @param dataFile : fichier Json d'où proviennent les données à valider
     * @param nbThreads
     * @return : retourne vrai si la validation a été un succès, faux sinon
     * @throws IOException
     */
    public boolean validateDatas(List<JsonField> dynamicFields, String storePath, String packageName, final File dataFile, int nbThreads) throws IOException {

        // objet qui contient ls informations sur la classe dont on veut parser les instances
        UnitSourceGenerator unitSG = RuntimeClassBuilder.createRuntimeClass(packageName, dynamicFields, storePath);

        if (unitSG != null && packageName != null && !packageName.isEmpty() && dynamicFields != null && !dynamicFields.isEmpty() && dataFile != null) {
            unitSG.make();

            ComponentSupplier componentSupplier = ComponentContainer.getInstance();
            ClassFactory classFactory = componentSupplier.getClassFactory();

            try ( ClassFactory.ClassRetriever classRetriever = classFactory.loadOrBuildAndDefine(unitSG)) {
                Class classOfEntity = classRetriever.get(packageName + "." + dynamicFields.get(0).getClassName());

                ObjectMapper mapper = new ObjectMapper();
                JsonNode parentNode = mapper.readTree(dataFile);

                parsedData = process(parentNode, classOfEntity, dynamicFields, dynamicFields.get(0).getClassName(), nbThreads);
            }
        }
        parsedData.getErrors().removeIf(c -> c == null || c.getEltNumber() == null);
        Collections.sort(parsedData.getErrors(), (CustomError c1, CustomError c2) -> c1.getEltNumber().compareTo(c2.getEltNumber()));

        return parsedData.getErrors().isEmpty();
    }

    /**
     *
     * @param parentNode
     * @param classOfEntity
     * @param rootClass
     */
    private JsonParsedData process(JsonNode parentNode, Class classOfEntity, List<JsonField> dynamicFields, String rootClass, int nbThreads) {
        Map<String, JsonField> dynamicFieldsToMap = dynamicFields.stream().collect(Collectors.toMap(JsonField::getName, Function.identity()));
        List<Node> nodes = constructList(parentNode);
        
        ForkJoinPool pool = new ForkJoinPool();
        return pool.invoke(new DataRetrieverAction(nodes, classOfEntity, dynamicFields, rootClass, nbThreads));
    }

    private List<Node> constructList(JsonNode parent) {
        List<Node> nodes = new ArrayList<>();

        if (parent.isArray()) {//Si les données sont dans un tableau {
            for (int j = 0; j < parent.size(); j++) {
                nodes.add(new Node(parent.get(j), j + 1));
            }
        } else if (!parent.isEmpty()) {
            nodes.add(new Node(parent, 1));
        }
        return nodes;
    }
}