/*
 * 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.megatim.dynamicjsonparser.pojo.CustomError;
import com.megatim.dynamicjsonparser.pojo.JsonField;
import com.megatim.dynamicjsonparser.pojo.JsonParsedData;
import com.megatim.dynamicjsonparser.pojo.Node;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Deque;
import java.util.List;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import org.burningwave.core.Virtual;

/**
 *
 * @author ASUS
 */
public class DataRetrieverAction extends RecursiveTask<JsonParsedData> {

    //Liste des données extraites du fichier json
    private final List<Virtual> finalVirtuals = Collections.synchronizedList(new ArrayList<>());

    //Liste des erreurs recontrées dans le fichier json
    private final Deque<CustomError> deque = new ConcurrentLinkedDeque<>();

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

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

    @Override
    protected JsonParsedData compute() {
        if (nbThreads > 1) {
            ForkJoinTask
                    .invokeAll(createSubtasks())
                    .stream()
                    .map(DataRetrieverAction::join)
                    .forEach(p -> {
                        deque.addAll(p.getErrors());
                        finalVirtuals.addAll(p.getVirtuals());
                    });
            return new JsonParsedData(finalVirtuals, new ArrayList<>(deque));
        } else {
            return new JsonDataProcessor(nodes, classOfEntity, jsonFields, rootClass).iterateThroughNodes();
        }
    }

    private List<DataRetrieverAction> createSubtasks() {
        List<DataRetrieverAction> subtasks = new ArrayList<>();
        int nbEltsPerTask = nodes.size() / nbThreads;
        int remainder = nodes.size() % nbThreads;

        for (int i = 0; i < nbThreads; i++) {
            if (remainder > 0 && i == nbThreads - 1) {
                subtasks.add(new DataRetrieverAction(nodes.subList(nbEltsPerTask * i, nbEltsPerTask * i + nbEltsPerTask + remainder), classOfEntity, jsonFields, rootClass, 1));
            } else {
                subtasks.add(new DataRetrieverAction(nodes.subList(nbEltsPerTask * i, nbEltsPerTask * i + nbEltsPerTask), classOfEntity, jsonFields, rootClass, 1));
            }
        }

        return subtasks;
    }

}