package com.megatim.apifdxweb.core.impl.helper;

import com.megatim.apifdxweb.core.ifaces.referentiel.ReferentielManager;
import com.megatim.apifdxweb.tools.AppContext;
import com.megatim.fdxcommons.core.ifaces.db.ReferentielDataSaver;
import com.megatim.fdxcommons.core.ifaces.helper.DataInMemoryHandler;
import com.megatim.fdxcommons.core.ifaces.helper.ReferentielConsumptionHelper;
import com.megatim.fdxcommons.core.ifaces.helper.referentiel.DynamicTableCreator;
import com.megatim.fdxcommons.model.pojo.ReferentielToImportData;
import com.megatim.fdxcommons.model.referentiel.Referentiel;
import com.megatim.fdxcommons.tools.exceptions.ImportReferentielException;
import javax.annotation.Resource;
import javax.enterprise.context.Dependent;
import javax.inject.Inject;
import javax.sql.DataSource;
import javax.transaction.Transactional;
import com.megatim.fdxcommons.core.ifaces.dataproduction.DataMigration;
import com.megatim.fdxcommons.core.ifaces.referentiel.historique.ReferentielIntegrationHistoriqueManager;
import com.megatim.fdxcommons.model.pojo.TableDefinition;
import com.megatim.fdxcommons.model.referentiel.historique.ReferentielIntegrationHistorique;
import com.megatim.fdxcommons.model.referentiel.historique.ReferentielIntegrationHistoriqueId;
import com.megatim.fdxcommons.model.referentiel.historique.pojo.FilteredTypeFichier;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 *
 * @author ASUS
 */
@Dependent
public class ReferentielConsumptionHelperImpl implements ReferentielConsumptionHelper {

    @Inject
    private ReferentielDataSaver referentielDataSaver;

    @Inject
    ReferentielManager referentielManager;

    @Inject
    private DataInMemoryHandler dataInMemoryHandler;

    @Inject
    private DynamicTableCreator dynamicTableCreator;

    @Resource(lookup = AppContext.JNDI_NAME)
    private DataSource dataSource;

    @Inject
    private DataMigration dataMigration;

    @Inject
    private ReferentielIntegrationHistoriqueManager refIntegrationHistoriqueManager;

    @Override
    @Transactional
    public void consume(ReferentielToImportData referentielToImportData) throws Exception {
        Referentiel refInDB = referentielManager.getReferentielEnCours();

        if (refInDB != null && Long.valueOf(refInDB.getVersion()) >= Long.valueOf(referentielToImportData.getReferentielEnCours().getVersion())) {
            throw new ImportReferentielException("Version du référentiel 'en cours' est antérieure à la version existante dans le système");
        }
        referentielDataSaver.persist(referentielToImportData);

        if (refInDB != null) {
            FilteredTypeFichier filteredTypeFichiers = dataMigration.filterTypeFichiers(referentielToImportData.getTableDefinitions(),
                    refInDB.getVersion(),
                    referentielToImportData.getReferentielEnCours().getVersion());

            //On creé uniquement les tables dont le typefichier est absent dans le ref précédent ou la structure de ses colonnes a changé
            createTables(filteredTypeFichiers.getChangedOrNewTypeFichiers(), referentielToImportData.getTableDefinitions());

            saveReferentielIntegrationHistorique(filteredTypeFichiers, referentielToImportData.getReferentielEnCours().getVersion());
        } else {
            //On creé les tables
            dynamicTableCreator.createDynamicTables(referentielToImportData.getTableDefinitions());

            saveHistoriqueChangedOrNewTypeFichiers(referentielToImportData);
        }

        //Charger les nouvelles informations du référentiel dans un objet en mémoire
        dataInMemoryHandler.initializeDataInMemory();
    }

    private void createTables(Set<String> changedOrNewTypeFichiers, List<TableDefinition> tableDefs) throws Exception {
        dynamicTableCreator
                .createDynamicTables(tableDefs
                        .stream()
                        .filter(t -> changedOrNewTypeFichiers.contains(t.getCodeTypeFichier()))
                        .collect(Collectors.toList()));
    }

    private void saveReferentielIntegrationHistorique(FilteredTypeFichier filteredTypeFichiers, String newRef) {
        saveHistoriqueChangedOrNewTypeFichiers(filteredTypeFichiers.getChangedOrNewTypeFichiers(), newRef);
        saveHistoriqueUnChangedTypeFichiers(filteredTypeFichiers.getUnChangedTypeFichiers(), newRef);
    }

    private void saveHistoriqueChangedOrNewTypeFichiers(Set<String> changedOrNewTypeFichiers, String newRef) {
        for (String codeTypeFichier : changedOrNewTypeFichiers) {
            refIntegrationHistoriqueManager.save(new ReferentielIntegrationHistorique(codeTypeFichier, newRef, new HashSet<>(Arrays.asList(newRef))));
        }
    }

    private void saveHistoriqueChangedOrNewTypeFichiers(ReferentielToImportData referentielToImportData) {
        Set<String> changedOrNewTypeFichiers = referentielToImportData.getTypeFichiers().stream().map(t -> t.getCode()).collect(Collectors.toSet());
        saveHistoriqueChangedOrNewTypeFichiers(changedOrNewTypeFichiers, referentielToImportData.getReferentielEnCours().getVersion());
    }

    private void saveHistoriqueUnChangedTypeFichiers(Set<String> unChangedOrNewTypeFichiers, String newRef) {

        for (String codeTypeFichier : unChangedOrNewTypeFichiers) {
            ReferentielIntegrationHistorique refInt = refIntegrationHistoriqueManager
                    .getById(new ReferentielIntegrationHistoriqueId(codeTypeFichier, newRef));

            if (refInt == null) {
                refIntegrationHistoriqueManager.save(new ReferentielIntegrationHistorique(codeTypeFichier, newRef, new HashSet<>(Arrays.asList(newRef))));
            } else {
                refInt.getDependingReferentiels().add(newRef);
                refIntegrationHistoriqueManager.save(refInt);
            }
        }
    }
}