package com.megatim.fdxcommons.core.impl.db;

import com.megatim.fdxcommons.model.referentiel.Referentiel;
import com.megatim.fdxcommons.model.referentiel.ValidateurFichierConfiguration;
import com.megatim.fdxcommons.core.ifaces.db.ImportZipValidatorIfaces;
import com.megatim.fdxcommons.core.ifaces.helper.referentiel.ValidateurTypeFichierParser;
import com.megatim.fdxcommons.tools.exceptions.ImportReferentielException;
import com.megatim.fdxcommons.model.pojo.ReferentielToImportData;
import com.megatim.fdxcommons.model.integration.TableDefinition;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import javax.enterprise.context.Dependent;
import javax.inject.Inject;

/**
 *
 * @author ASUS
 */
@Dependent
public class ImportZipValidatorImpl implements ImportZipValidatorIfaces {

    @Inject
    private ValidateurTypeFichierParser validateurTypeFichierParser;

    @Override
    public List<TableDefinition> getTableDefinitions(File validatorDir, ReferentielToImportData referentielToImportData) throws Exception {

        List<TableDefinition> tableDefinitions = new ArrayList<>();

        if (validatorDir.isDirectory()) {
            for (Referentiel referentiel : referentielToImportData.getReferentiels()) {
                Path referentielPath = Paths.get(validatorDir.getAbsolutePath(), referentiel.getVersion());

                //S'il n'existe pas un chemin correspondant à la version du referentiel en_cours
                if (!Files.exists(referentielPath, LinkOption.NOFOLLOW_LINKS)) {
                    if (referentiel.getVersion().equals(referentielToImportData.getReferentielEnCours().getVersion())) {
                        throw new ImportReferentielException("Le répertoire '" + referentiel.getVersion() + "' des validateurs est introuvable");
                    } else {
                        continue;
                    }
                }

                //Si ce chemin n'est pas celui d'un répertoire
                if (!Files.isDirectory(referentielPath, LinkOption.NOFOLLOW_LINKS)) {
                    throw new ImportReferentielException("'" + referentiel.getVersion() + "' n'est pas un répertoire dans le repertoire des validateurs");
                }

                //Liste des configurations de validateurs associées au reférentiel en cours de traitement
                List<ValidateurFichierConfiguration> validateursConfiguratioForReferentiel
                        = validateurFichierConfigurationForCurrentReferentiel(referentiel, referentielToImportData);

                Map<String, ValidateurFichierConfiguration> mapValidateurConfByFileName = fileNameToValidateurConfiguration(validateursConfiguratioForReferentiel);

                //Liste des répertoires des participants du referentiel en cours de traitement
                File[] participantDirectories = (new File(validatorDir.getAbsolutePath(), referentiel.getVersion())).listFiles();
                for (File participantDirectory : participantDirectories) {

                    //Si le fichier en cours de traitement est un répertoire   
                    if (participantDirectory.isDirectory()) {

                        //Liste des validateurs contenus dans le dossier d'un participant
                        File[] validateurs = participantDirectory.listFiles();

                        for (File validatorFile : validateurs) {

                            if (validatorFile.isFile()) {

                                if (mapValidateurConfByFileName.containsKey(validatorFile.getName())) {
                                    TableDefinition tableDefinition = new TableDefinition();
                                    String codeTypeFichier = mapValidateurConfByFileName.get(validatorFile.getName()).getTypeFichier().getCode();

                                    try {
                                        tableDefinition = validateurTypeFichierParser.parseToColumnDefinition(validatorFile.getAbsolutePath(),
                                                codeTypeFichier, referentiel.getVersion());
                                    } catch (Exception ex) {
                                        tableDefinition.setColumnDefinitions(new ArrayList<>());
                                        Logger.getLogger(ImportZipValidatorImpl.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
                                    }
                                    if (tableDefinition.getColumnDefinitions() != null && !tableDefinition.getColumnDefinitions().isEmpty()) {
                                        tableDefinitions.add(tableDefinition);
                                    }
                                }
                            }
                        }

                    }
                }
            }
        }

        return tableDefinitions;
    }

    private List<ValidateurFichierConfiguration> validateurFichierConfigurationForCurrentReferentiel(Referentiel referentielEnCours, ReferentielToImportData referentielToImportData) {
        return referentielToImportData.getValidateurFichierConfigurations()
                .stream()
                .filter(p -> p.getReferentiel().getVersion().equals(referentielEnCours.getVersion()))
                .collect(Collectors.toList());
    }

    /**
     * Classer les configurations des validateurs par nom du fichier
     *
     * @param validateursConf
     * @return
     */
    private Map<String, ValidateurFichierConfiguration> fileNameToValidateurConfiguration(List<ValidateurFichierConfiguration> validateursConfiguration) {
        Map<String, ValidateurFichierConfiguration> mapValidateurConf = new HashMap<>();

        for (ValidateurFichierConfiguration vc : validateursConfiguration) {
            File file = new File(vc.getFileName());
            /**
             * Dans le fichier zip du referentiel, le nom du fichier de
             * validateur est en chemin absolu Raison pour laquelle il faut
             * passer un objet de type 'File' afin de recupérer le nom relatif
             * du fichier
             */
            mapValidateurConf.put(file.getName(), vc);
        }

        return mapValidateurConf;
    }
}