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

import com.megatim.fdxcommons.core.ifaces.db.ReferentielDataSaver;
import com.megatim.fdxcommons.model.enumeration.CategorieFichier;
import com.megatim.fdxcommons.model.integration.ColumnDefinition;
import com.megatim.fdxcommons.model.pojo.ReferentielToImportData;
import com.megatim.fdxcommons.model.integration.TableDefinition;
import com.megatim.fdxcommons.model.referentiel.ApplicationSource;
import com.megatim.fdxcommons.model.referentiel.ExtensionFichier;
import com.megatim.fdxcommons.model.referentiel.GroupeNoeud;
import com.megatim.fdxcommons.model.referentiel.GroupeParticipant;
import com.megatim.fdxcommons.model.referentiel.Noeud;
import com.megatim.fdxcommons.model.referentiel.Participant;
import com.megatim.fdxcommons.model.referentiel.Pays;
import com.megatim.fdxcommons.model.referentiel.Referentiel;
import com.megatim.fdxcommons.model.referentiel.Routage;
import com.megatim.fdxcommons.model.referentiel.StructureLigne;
import com.megatim.fdxcommons.model.referentiel.TypeFichier;
import com.megatim.fdxcommons.model.referentiel.ValidateurFichier;
import com.megatim.fdxcommons.model.referentiel.ValidateurFichierConfiguration;
import com.megatim.fdxcommons.model.referentiel.natureproduction.NatureProductionFichier;
import com.megatim.fdxcommons.tools.exceptions.TypeFichierExistNotException;
import com.megatim.fdxcommons.tools.exceptions.CommonRessourceNotFoundException;
import com.megatim.fdxconsultation.core.ifaces.integration.ColumnDefinitionManager;
import com.megatim.fdxconsultation.core.ifaces.integration.TableDefinitionManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.ApplicationSourceManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.ExtensionFichierManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.GroupeNoeudManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.GroupeParticipantManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.NoeudManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.ParticipantManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.PaysManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.ReferentielManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.RoutageManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.StructureLigneManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.TypeFichierManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.ValidateurFichierConfigurationManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.ValidateurFichierManager;
import com.megatim.fdxconsultation.core.ifaces.referentiel.natureproduction.NatureProductionFichierManager;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import javax.enterprise.context.Dependent;
import javax.inject.Inject;

/**
 *
 * @author ASUS
 */
@Dependent
public class ReferentielDataSaverImpl implements ReferentielDataSaver {

    @Inject
    private ReferentielManager refManager;

    @Inject
    private ApplicationSourceManager appSourceManager;

    @Inject
    private ExtensionFichierManager extFichierManager;

    @Inject
    private GroupeNoeudManager groupeNoeudManager;

    @Inject
    private GroupeParticipantManager groupePartManager;

    @Inject
    private NoeudManager noeudManager;

    @Inject
    private ParticipantManager participantManager;

    @Inject
    private PaysManager paysManager;

    @Inject
    private RoutageManager routageManager;

    @Inject
    private TypeFichierManager typeFichierManager;

    @Inject
    private StructureLigneManager structLigneManager;

    @Inject
    private ValidateurFichierManager valFichManager;

    @Inject
    private ValidateurFichierConfigurationManager valFichConfManager;

    @Inject
    private ColumnDefinitionManager columnDefinitionManager;

    @Inject
    private TableDefinitionManager tableDefinitionManager;

    @Inject
    NatureProductionFichierManager natureProdFichManager;

    private Map<String, Referentiel> referentielsMap;
    private Map<String, TypeFichier> typeFichiersMap;
    private Map<String, Pays> paysMap;
    private Map<String, Participant> participantsMap;
    private Map<String, ApplicationSource> appSourcesMap;
    private Map<String, ExtensionFichier> extensionFichiersMap;
    private Map<String, ValidateurFichier> validateurFichiersMap;
    private Map<String, ValidateurFichierConfiguration> validateurFichierConfsMap;
    private Map<String, StructureLigne> structLignesMap;
    private Map<String, Noeud> noeudsMap;
    private Map<String, GroupeNoeud> groupeNoeudsMap;
    private Map<String, GroupeParticipant> groupeParticipantsMap;
    private Map<String, Routage> routagesMap;
    private Map<String, ColumnDefinition> columnDefinitionsMap;
    private Map<String, NatureProductionFichier> natureProdFichsMap;

    @Override
    public void persist(ReferentielToImportData referentielToImportData) throws Exception {

        refManager.archiverReferentielEncours();

        persistReferentiels(referentielToImportData.getReferentiels());

        persistApplicationSources(referentielToImportData.getApplicationSources());

        persistPayss(referentielToImportData.getPays());

        persistExtensionFichiers(referentielToImportData.getExtensionFichiers());

        persistParticipants(referentielToImportData.getParticipants());

        persistTypeFichiers(referentielToImportData.getTypeFichiers());

//        persistValidateurFichiers(referentielToImportData.getValidateurFichiers());
//
//        persistValidateurFichierConfigurations(referentielToImportData.getValidateurFichierConfigurations());
//
//        persitStructuresLignes(referentielToImportData.getStructureLignes());
        persistNoeuds(referentielToImportData.getNoeuds());

        persistGroupeNoeuds(referentielToImportData.getGroupeNoeuds());

        persistGroupeParticipants(referentielToImportData.getGroupeParticipants());

        persistRoutages(referentielToImportData.getRoutages());

        persistTableDefinitions(referentielToImportData.getTableDefinitions());

        persistColumnsDefinition(referentielToImportData.getTableDefinitions());

        persistNatureProductionFichiers(referentielToImportData.getNatureProductionFichiers());
    }

    private void persistReferentiels(List<Referentiel> referentiels) throws Exception {
        referentielsMap = refManager.getAll(null).stream().collect(Collectors.toMap(Referentiel::getVersion, Function.identity()));

        if (referentiels != null) {

            for (Referentiel ref : referentiels) {
                Referentiel referentielFound = referentielsMap.get(ref.getVersion());

                if (referentielFound == null) {
                    refManager.save(ref);
                }
            }
        }
    }

    private void persistApplicationSources(List<ApplicationSource> appSources) throws Exception {
        referentielsMap = refManager.getAll(null).stream().collect(Collectors.toMap(Referentiel::getVersion, Function.identity()));
        appSourcesMap = appSourceManager.getAll(null).stream().collect(Collectors.toMap(ApplicationSource::getLibelle, Function.identity()));

        if (appSources != null) {

            for (ApplicationSource appSource : appSources) {
                String referentielVersion = appSource.getReferentiel().getVersion();
                Referentiel referentielFound = referentielsMap.get(referentielVersion);

                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("Le referentiel suivant est introuvable : " + referentielVersion);
                }

                ApplicationSource appSourceFound = appSourcesMap.get(appSource.getLibelle());
                if (appSourceFound == null) {
                    appSource.setReferentiel(referentielFound);
                    appSourceManager.save(appSource);
                }

            }
        }

    }

    private void persistPayss(List<Pays> payss) throws Exception {
        paysMap = paysManager.getAll(null).stream().collect(Collectors.toMap(Pays::getCode, Function.identity()));

        if (payss != null) {

            for (Pays p : payss) {
                String referentielVersion = p.getReferentiel().getVersion();
                Referentiel referentielFound = referentielsMap.get(referentielVersion);

                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource Referentiel suivante est introuvable : " + referentielVersion);
                }
                Pays paysFound = paysMap.get(p.getCode());

                if (paysFound == null) {
                    p.setReferentiel(referentielFound);
                    p.setParticipants(new HashSet<>());
                    paysManager.save(p);
                }

            }
        }
    }

    private void persistExtensionFichiers(List<ExtensionFichier> extFichiers) throws Exception {
        referentielsMap = refManager.getAll(null).stream().collect(Collectors.toMap(Referentiel::getVersion, Function.identity()));
        extensionFichiersMap = extFichierManager.getAll(null).stream().collect(Collectors.toMap(ExtensionFichier::getExtension, Function.identity()));

        if (extFichiers != null) {

            for (ExtensionFichier e : extFichiers) {
                String referentielVersion = e.getReferentiel().getVersion();
                Referentiel referentielFound = referentielsMap.get(referentielVersion);

                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("Le referentiel suivant est introuvable : " + referentielVersion);
                }

                ExtensionFichier extFichierFound = extensionFichiersMap.get(e.getExtension());
                if (extFichierFound == null) {
                    e.setReferentiel(referentielFound);
                    extFichierManager.save(e);
                }
            }
        }
    }

    private void persistParticipants(List<Participant> participants) throws Exception {
        paysMap = paysManager.getAll(null).stream().collect(Collectors.toMap(Pays::getCode, Function.identity()));
        participantsMap = participantManager.getAll(null).stream().collect(Collectors.toMap(Participant::getCode, Function.identity()));

        if (participants != null) {

            for (Participant p : participants) {
                String referentielVersion = p.getReferentiel().getVersion();
                String codePays = p.getPays().getCode();
                Referentiel referentielFound = referentielsMap.get(referentielVersion);

                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource Referentiel suivante est introuvable : " + referentielVersion);
                }
                Pays paysFound = paysMap.get(codePays);

                if (paysFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource Pays suivante est introuvable : " + codePays);
                }
                Participant participantFound = participantsMap.get(p.getCode());

                if (participantFound == null) {
                    p.setPays(paysFound);
                    p.setReferentiel(referentielFound);
                    p.setNoeuds(new HashSet<>());
                    p.setRoutageEnvois(new HashSet<>());
                    p.setRoutageReceptions(new HashSet<>());
                    p.setGroupeParticipants(new HashSet<>());

                    participantManager.save(p);
                }

            }
        }
    }

    private void persistTypeFichiers(List<TypeFichier> typeFichiers) throws Exception {
        participantsMap = participantManager.getAll(null).stream().collect(Collectors.toMap(Participant::getCode, Function.identity()));
        typeFichiersMap = typeFichierManager.getAll(null).stream().collect(Collectors.toMap(TypeFichier::getCode, Function.identity()));

        if (typeFichiers != null) {

            for (TypeFichier typeFich : typeFichiers) {

                if (typeFich.getCategorieFichier().equals(CategorieFichier.STRUCTURE)) {

                    String referentielVersion = typeFich.getReferentiel().getVersion();
                    String codeParticipant = typeFich.getParticipant().getCode();

                    Referentiel referentielFound = referentielsMap.get(referentielVersion);
                    if (referentielFound == null) {
                        throw new CommonRessourceNotFoundException("La ressource Referentiel suivante est introuvable : " + referentielVersion);
                    }

                    Participant participantFound = participantsMap.get(codeParticipant);
                    if (participantFound == null) {
                        throw new CommonRessourceNotFoundException("La ressource Participant suivante est introuvable : " + codeParticipant);
                    }
                    TypeFichier typeFichierFound = typeFichiersMap.get(typeFich.getCode());

                    if (typeFichierFound == null) {
                        typeFich.setReferentiel(referentielFound);
                        typeFich.setParticipant(participantFound);
                        typeFich.setRoutages(new HashSet<>());
                        typeFich.setValidateurFichierConfigurations(new HashSet<>());
                        typeFich.setValidateurFichiers(new HashSet<>());

                        typeFichierManager.save(typeFich);
                    }
                }
            }
        }
    }

    private void persistValidateurFichiers(List<ValidateurFichier> validateurFichiers) throws Exception {
        validateurFichiersMap = valFichManager.getAll(null).stream().collect(Collectors.toMap(ValidateurFichier::getId, Function.identity()));
        typeFichiersMap = typeFichierManager.getAll(null).stream().collect(Collectors.toMap(TypeFichier::getCode, Function.identity()));

        if (validateurFichiers != null) {

            for (ValidateurFichier val : validateurFichiers) {
                String codeTypeFichier = val.getTypeFichier().getCode();
                TypeFichier typeFichierFound = typeFichiersMap.get(codeTypeFichier);

                if (typeFichierFound == null) {
                    throw new TypeFichierExistNotException(codeTypeFichier);
                }
                ValidateurFichier valFichFound = validateurFichiersMap.get(val.getId());

                if (valFichFound == null) {
                    val.setTypeFichier(typeFichierFound);
                    valFichManager.save(val);
                }
            }
        }
    }

    private void persistValidateurFichierConfigurations(List<ValidateurFichierConfiguration> valFichConfs) throws TypeFichierExistNotException, Exception {
        validateurFichierConfsMap = valFichConfManager.getAll(null)
                .stream()
                .collect(Collectors.toMap(x -> x.getReferentiel().getVersion() + "-" + x.getTypeFichier().getCode(),
                        Function.identity()));

        if (valFichConfs != null) {

            for (ValidateurFichierConfiguration valFichConf : valFichConfs) {
                String codeTypeFichier = valFichConf.getTypeFichier().getCode();
                String referentielVersion = valFichConf.getReferentiel().getVersion();

                Referentiel referentielFound = referentielsMap.get(referentielVersion);
                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("Le referentiel suivant est introuvable : " + referentielVersion);
                }

                TypeFichier typeFichierFound = typeFichiersMap.get(codeTypeFichier);
                if (typeFichierFound == null) {
                    throw new TypeFichierExistNotException(codeTypeFichier);
                }

                ValidateurFichierConfiguration ValFichConfFound = validateurFichierConfsMap.get(valFichConf.getReferentiel().getVersion() + "-" + valFichConf.getTypeFichier().getCode());

                if (ValFichConfFound == null) {
                    valFichConf.setTypeFichier(typeFichierFound);
                    valFichConf.setReferentiel(referentielFound);

                    valFichConfManager.save(valFichConf);
                }

            }
        }
    }

    private void persitStructuresLignes(List<StructureLigne> structLignes) throws Exception {
        validateurFichiersMap = valFichManager.getAll(null).stream().collect(Collectors.toMap(ValidateurFichier::getId, Function.identity()));
        appSourcesMap = appSourceManager.getAll(null).stream().collect(Collectors.toMap(ApplicationSource::getLibelle, Function.identity()));
        structLignesMap = structLigneManager.getAll(null).stream().collect(Collectors.toMap(StructureLigne::getId, Function.identity()));

        if (structLignes != null) {

            for (StructureLigne s : structLignes) {
                String valFichierId = s.getValidateurFichier().getId();
                String libelleAppSource = s.getApplicationSource().getLibelle();

                ApplicationSource appSourceFound = appSourcesMap.get(libelleAppSource);
                if (appSourceFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource ApplicationSource suivante est introuvable : " + libelleAppSource);
                }

                ValidateurFichier valFichFound = validateurFichiersMap.get(valFichierId);
                if (valFichFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource ValidateurFichier suivante est introuvable : " + valFichierId);
                }
                StructureLigne structureLigneFound = structLignesMap.get(s.getId());

                if (structureLigneFound == null) {
                    s.setValidateurFichier(valFichFound);
                    s.setApplicationSource(appSourceFound);

                    structLigneManager.save(s);
                }

            }
        }
    }

    private void persistNoeuds(List<Noeud> noeuds) throws Exception {
        noeudsMap = noeudManager.getAll(null).stream().collect(Collectors.toMap(Noeud::getCode, Function.identity()));

        if (noeuds != null) {

            for (Noeud n : noeuds) {
                String referentielVersion = n.getReferentiel().getVersion();
                String codeParticipant = n.getParticipant().getCode();

                Referentiel referentielFound = referentielsMap.get(referentielVersion);
                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource Referentiel suivante est introuvable : " + referentielVersion);
                }

                Participant participantFound = participantsMap.get(codeParticipant);
                if (participantFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource Participant suivante est introuvable : " + codeParticipant);
                }
                Noeud noeudFound = noeudsMap.get(n.getCode());

                if (noeudFound == null) {
                    n.setReferentiel(referentielFound);
                    n.setParticipant(participantFound);
                    n.setGroupeNoeuds(new HashSet<>());
                    n.setRoutageEnvois(new HashSet<>());
                    n.setRoutageReceptions(new HashSet<>());

                    noeudManager.save(n);
                }

            }
        }
    }

    private void persistGroupeNoeuds(List<GroupeNoeud> groupeNoeuds) throws Exception {
        groupeNoeudsMap = groupeNoeudManager.getAll(null).stream().collect(Collectors.toMap(GroupeNoeud::getCode, Function.identity()));

        if (groupeNoeuds != null) {

            for (GroupeNoeud gn : groupeNoeuds) {
                String referentielVersion = gn.getReferentiel().getVersion();
                Referentiel referentielFound = referentielsMap.get(referentielVersion);

                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource Referentiel suivante est introuvable : " + referentielVersion);
                }
                GroupeNoeud grpNoeudFound = groupeNoeudsMap.get(gn.getCode());

                if (grpNoeudFound == null) {
                    gn.setReferentiel(referentielFound);
                    groupeNoeudManager.save(gn);
                }
            }
        }
    }

    private void persistGroupeParticipants(List<GroupeParticipant> groupeParticipants) throws Exception {
        groupeParticipantsMap = groupePartManager.getAll(null).stream().collect(Collectors.toMap(GroupeParticipant::getCode, Function.identity()));

        if (groupeParticipants != null) {

            for (GroupeParticipant gp : groupeParticipants) {
                String referentielVersion = gp.getReferentiel().getVersion();
                Referentiel referentielFound = referentielsMap.get(referentielVersion);

                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("La ressource Referentiel suivante est introuvable : " + referentielVersion);
                }
                GroupeParticipant grpParticipantFound = groupeParticipantsMap.get(gp.getCode());

                if (grpParticipantFound == null) {
                    gp.setReferentiel(referentielFound);
                    gp.setRoutageEnvois(new HashSet<>());
                    gp.setRoutageReceptions(new HashSet<>());

                    groupePartManager.save(gp);
                }

            }
        }
    }

    private void persistRoutages(List<Routage> routages) throws Exception {
        typeFichiersMap = typeFichierManager.getAll(null).stream().collect(Collectors.toMap(TypeFichier::getCode, Function.identity()));
        routagesMap = routageManager.getAll(null)
                .stream()
                .collect(Collectors.toMap(x -> x.getReferentiel().getVersion() + "-" + x.getTypeFichier().getCode(),
                        Function.identity()));

        if (routages != null) {

            for (Routage r : routages) {
                String referentielVersion = r.getReferentiel().getVersion();
                String codeTypeFichier = r.getTypeFichier().getCode();

                Referentiel referentielFound = referentielsMap.get(referentielVersion);
                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("Le referentiel suivant est introuvable : " + referentielVersion);
                }

                TypeFichier typeFichierFound = typeFichiersMap.get(codeTypeFichier);
                if (typeFichierFound == null) {
                    throw new TypeFichierExistNotException(codeTypeFichier);
                }
                Routage routageFound = routagesMap.get(r.getReferentiel().getVersion() + "-" + r.getTypeFichier().getCode());

                if (routageFound == null) {
                    r.setReferentiel(referentielFound);
                    r.setTypeFichier(typeFichierFound);

                    routageManager.save(r);
                }
            }
        }
    }

    private void persistTableDefinitions(List<TableDefinition> tablesDefinition) {
        for (TableDefinition t : tablesDefinition) {
            if (t.getHeaderPresent() != null && t.getColumnDelimiter() != null && t.getLineDelimiter() != null) {
                tableDefinitionManager.save(t);
            }
        }
    }

    private void persistColumnsDefinition(List<TableDefinition> tablesDefinition) throws Exception {
        columnDefinitionsMap = columnDefinitionManager.getAll(null)
                .stream()
                .collect(Collectors.toMap(x -> x.getName() + "-" + x.getReferentielVersion() + "-" + x.getCodeTypeFichier(),
                        Function.identity()
                ));

        if (tablesDefinition != null) {

            for (TableDefinition t : tablesDefinition) {

                for (ColumnDefinition c : t.getColumnDefinitions()) {
                    ColumnDefinition colDefFound = columnDefinitionsMap.get(c.getName() + "-" + c.getReferentielVersion() + "-" + c.getCodeTypeFichier());

                    if (colDefFound == null) {
                        columnDefinitionManager.save(c);
                    }
                }
            }
        }
    }

    private void persistNatureProductionFichiers(List<NatureProductionFichier> natureProductionFichs) throws TypeFichierExistNotException {
        natureProdFichsMap = natureProdFichManager.getAll(null)
                .stream()
                .collect(Collectors.toMap(x -> x.getReferentiel().getVersion() + "-" + x.getTypeFichier().getCode(),
                        Function.identity()));

        if (natureProductionFichs != null) {

            for (NatureProductionFichier n : natureProductionFichs) {
                String referentielVersion = n.getReferentiel().getVersion();
                String codeTypeFichier = n.getTypeFichier().getCode();

                Referentiel referentielFound = referentielsMap.get(referentielVersion);
                if (referentielFound == null) {
                    throw new CommonRessourceNotFoundException("Le referentiel suivant est introuvable : " + referentielVersion);
                }

                TypeFichier typeFichierFound = typeFichiersMap.get(codeTypeFichier);
                if (typeFichierFound == null) {
                    throw new TypeFichierExistNotException(codeTypeFichier);
                }
                NatureProductionFichier natureProdFichFound = natureProdFichsMap.get(n.getReferentiel().getVersion() + "-" + n.getTypeFichier().getCode());

                if (natureProdFichFound == null) {
                    n.setReferentiel(referentielFound);
                    n.setTypeFichier(typeFichierFound);

                    natureProdFichManager.save(n);
                }
            }
        }
    }
}