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

import com.megatim.fdxcommons.model.enumeration.CriteriaLogicConnector;
import com.megatim.fdxcommons.model.enumeration.Operateur;
import com.megatim.fdxcommons.model.pojo.CriteriaEntityFromView;
import com.megatim.fdxcommons.model.referentiel.Referentiel;
import com.megatim.fdxcommons.tools.exceptions.CommonApplicationValidationException;
import com.megatim.fdxconsultation.core.ifaces.integration.ColumnDefinitionManager;
import com.megatim.fdxconsultation.core.ifaces.helper.TableauBordHandler;
import com.megatim.fdxconsultation.core.ifaces.stats.CriteriaEntityPersistedManager;
import com.megatim.fdxconsultation.core.ifaces.stats.TableConfigurationManager;
import com.megatim.fdxconsultation.core.ifaces.stats.TableauBordColumnManager;
import com.megatim.fdxconsultation.core.ifaces.stats.TableauBordManager;
import com.megatim.fdxconsultation.model.dto.stats.TableConfigurationDto;
import com.megatim.fdxconsultation.model.dto.stats.TableauBordDto;
import com.megatim.fdxconsultation.model.enums.TypeConfigurationTableauBord;
import com.megatim.fdxconsultation.model.mappers.MapStructMapper;
import com.megatim.fdxconsultation.model.stats.CriteriaEntityPersisted;
import com.megatim.fdxconsultation.model.stats.TableConfiguration;
import com.megatim.fdxconsultation.model.stats.TableauBord;
import com.megatim.fdxconsultation.model.stats.TableauBordColumn;
import com.megatim.fdxconsultation.model.enums.TypeResultatConfiguration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.enterprise.context.Dependent;
import javax.inject.Inject;

/**
 *
 * @author ASUS
 */
@Dependent
public class TableauBordHandlerImpl implements TableauBordHandler {

    @Inject
    private MapStructMapper mapper;

    @Inject
    com.megatim.fdxcommons.model.mappers.MapStructMapper commonMapper;

    @Inject
    private ColumnDefinitionManager columnDefinitionManager;

    @Inject
    private CriteriaEntityPersistedManager criteriaEntityPersistedManager;

    @Inject
    TableauBordManager tableauBordManager;

    @Inject
    private TableConfigurationManager tableConfigurationManager;

    @Inject
    private TableauBordColumnManager tableauBordColumnManager;

    @Override
    public void reconduireTableauBordValides(Referentiel previousRef, Referentiel newRef, Set<String> typeFichiersToMigrate) {
        List<TableauBord> prevRefTableauBords = tableauBordManager.findByReferentiel(previousRef.getVersion());

        try {
            for (TableauBord t : prevRefTableauBords) {
                if (typeFichiersToMigrate.contains(t.getTypeFichier().getCode())) {
                    createNewTableauBord(t, newRef);
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    @Override
    public TableauBordDto tableauBordToTableauBordDto(TableauBord tableauBord) {
        TableauBordDto dto = new TableauBordDto();

        dto.setId(tableauBord.getId());
        dto.setDescription(tableauBord.getDescription());
        dto.setTypeFichier(commonMapper.typeFichierToTypeFichierSlimDto(tableauBord.getTypeFichier()));
        dto.setTypeConfiguration(tableauBord.getTypeConfiguration());

        Set<TableConfigurationDto> tableConfigurationDtos = new HashSet<>();
        tableauBord.getTableConfigurations().stream().forEach(t -> tableConfigurationDtos.add(tableConfigurationToTableConfigurationDto(t)));
        dto.setTableConfigurations(tableConfigurationDtos);

        return dto;
    }

    /**
     * Méthode permettant de passer de TableauBordDto à TableauBord
     *
     * @param dto
     * @param referentiel
     * @return
     */
    @Override
    public TableauBord tableauBordDtoToTableauBord(TableauBordDto dto, Referentiel referentiel) {
        TableauBord tableauBord = new TableauBord();

        tableauBord.setDescription(dto.getDescription());
        tableauBord.setTypeFichier(commonMapper.typeFichierSlimDtoToTypeFichier(dto.getTypeFichier()));
        tableauBord.setReferentiel(referentiel);

        Set<TableConfiguration> tableConfigurations = new HashSet<>();
        dto.getTableConfigurations().stream().forEach(t -> tableConfigurations.add(tableConfigurationDtoToTableConfiguration(t, dto.getTypeFichier().getCode(), referentiel.getVersion())));
        tableauBord.setTableConfigurations(tableConfigurations);

        return tableauBord;
    }

    @Override
    public TableConfigurationDto tableConfigurationToTableConfigurationDto(TableConfiguration tableConf) {
        TableConfigurationDto dto = new TableConfigurationDto();
        dto.setCriterion(criteriaEntityPersistedToCriteriaEntityFromView(tableConf.getCriterion()));
        dto.setColor(tableConf.getColor());
        dto.setFonctionAggregation(tableConf.getFonctionAggregation());
        dto.setGroupingColumns(mapper.setTableauBordColumnToSetTableauBordColumnDto(tableConf.getGroupingColumns()));
        dto.setLibelle(tableConf.getLibelle());
        dto.setTargetedColumn(mapper.tableauBordColumnToTableauBordColumnDto(tableConf.getTargetedColumn()));
        dto.setTypeResultatConfiguration(tableConf.getTypeResultatConfiguration());
        dto.setColor(tableConf.getColor());

        return dto;
    }

    @Override
    public void stopIfUserSpecificTableauBordExists(String codeTypeFichier, String referentielVersion, String userName) throws CommonApplicationValidationException, Exception {

        CriteriaEntityFromView criterion = new CriteriaEntityFromView();
        criterion.setCriteriaLogicConnector(CriteriaLogicConnector.AND);
        criterion.setSubCriterias(Arrays.asList(
                new CriteriaEntityFromView("typeFichier.code", codeTypeFichier, Operateur.EQUALS),
                new CriteriaEntityFromView("user.userName", userName, Operateur.EQUALS),
                new CriteriaEntityFromView("referentiel.version", referentielVersion, Operateur.EQUALS),
                new CriteriaEntityFromView("typeConfiguration", TypeConfigurationTableauBord.USER_SPECIFIC, Operateur.EQUALS)));

        List<TableauBord> tb = tableauBordManager.findAll(criterion, Arrays.asList(), Arrays.asList());
        if (tb.stream().findFirst().isPresent()) {
            throw new CommonApplicationValidationException("Une configuration existe déjà pour le typefichier " + codeTypeFichier + ", l'utilisateur" + userName + " et le référentiel " + referentielVersion);
        }
    }

    @Override
    public void stopIfGlobaleTableauBordExists(String codeTypeFichier, String referentielVersion) throws Exception {

        CriteriaEntityFromView criterion = new CriteriaEntityFromView();
        criterion.setCriteriaLogicConnector(CriteriaLogicConnector.AND);
        criterion.setSubCriterias(Arrays.asList(
                new CriteriaEntityFromView("typeFichier.code", codeTypeFichier, Operateur.EQUALS),
                new CriteriaEntityFromView("referentiel.version", referentielVersion, Operateur.EQUALS),
                new CriteriaEntityFromView("typeConfiguration", TypeConfigurationTableauBord.GLOBAL, Operateur.EQUALS)
        ));

        if (tableauBordManager.findAll(criterion, Arrays.asList(), Arrays.asList()).stream().findFirst().isPresent()) {
            throw new CommonApplicationValidationException("Une configuration existe déjà pour ce typefichier et ce référentiel");
        }
    }

    private void createNewTableauBord(TableauBord t, Referentiel referentiel) throws Exception {

        try {
            if (t.getTypeConfiguration().equals(TypeConfigurationTableauBord.USER_SPECIFIC)) {
                stopIfUserSpecificTableauBordExists(t.getTypeFichier().getCode(), referentiel.getVersion(), t.getUser().getUserName());
            } else {
                stopIfGlobaleTableauBordExists(t.getTypeFichier().getCode(), referentiel.getVersion());
            }
            TableauBord tableauBord = tableauBord(t, referentiel);
            tableauBordManager.save(tableauBord);
        } catch (Exception ex) {
            Logger.getLogger(TableauBordHandlerImpl.class.getSimpleName()).log(Level.SEVERE, ex.getMessage(), ex);
        }
    }

    private TableauBord tableauBord(TableauBord t, Referentiel referentiel) {
        TableauBord tableauBord = new TableauBord();
        tableauBord.setReferentiel(referentiel);
        tableauBord.setTypeFichier(t.getTypeFichier());
        tableauBord.setDescription(t.getDescription());
        tableauBord.setUser(t.getUser());
        tableauBord.setTypeConfiguration(t.getTypeConfiguration());

        for (TableConfiguration tc : t.getTableConfigurations()) {
            TableConfiguration tableConf = new TableConfiguration();
            tableConf.setLibelle(tc.getLibelle());
            tableConf.setFonctionAggregation(tc.getFonctionAggregation());
            tableConf.setTargetedColumn(newTableauBordColumn(tc.getTargetedColumn()));
            tableConf.setTypeResultatConfiguration(tc.getTypeResultatConfiguration());
            tableConf.setFonctionAggregationCriterion(tc.getFonctionAggregationCriterion());

            CriteriaEntityPersisted cr = reconductCriteria(tc.getCriterion());
            tableConf.setCriterion(cr);

            for (TableauBordColumn tbc : tc.getGroupingColumns()) {
                tableConf.getGroupingColumns().add(newTableauBordColumn(tbc));
            }
            tableauBord.getTableConfigurations().add(tableConf);
        }

        return tableauBord;
    }

    private TableauBordColumn newTableauBordColumn(TableauBordColumn column) {
        if (column == null) {
            return null;
        }
        TableauBordColumn newColumn = new TableauBordColumn();
        newColumn.setName(column.getName());
        newColumn.setTypeDonnee(column.getTypeDonnee());

        return newColumn;
    }

    private TableConfiguration tableConfigurationDtoToTableConfiguration(TableConfigurationDto dto, String codeTypeFichier, String referentielVersion) {
        TableConfiguration tableConf = new TableConfiguration();
        tableConf.setFonctionAggregation(dto.getFonctionAggregation());
        tableConf.setLibelle(dto.getLibelle());
        tableConf.setColor(dto.getColor());
        tableConf.setTargetedColumn(mapper.tableauBordColumnDtoToTableauBordColumn(dto.getTargetedColumn()));
        tableConf.setGroupingColumns(mapper.setTableauBordColumnDtoToSetTableauBordColumn(dto.getGroupingColumns()));
        tableConf.setTypeResultatConfiguration(dto.getTypeResultatConfiguration() != null ? dto.getTypeResultatConfiguration() : TypeResultatConfiguration.RECAPITULATIF);

        CriteriaEntityPersisted criterionPersisted = criteriaEntityPersistedManager.constructCriteriaPersisted(codeTypeFichier, referentielVersion, dto.getCriterion());
        tableConf.setCriterion(criterionPersisted);

        return tableConf;
    }

    private CriteriaEntityPersisted reconductCriteria(CriteriaEntityPersisted criterion) {

        if (criterion != null) {

            if (!criterion.getSubCriterias().isEmpty()) {

                CriteriaEntityPersisted finalCriterion = new CriteriaEntityPersisted();
                List<CriteriaEntityPersisted> subCriteria = new ArrayList<>(criterion.getSubCriterias());
                criterion.setSubCriterias(new ArrayList<>());
                subCriteria.stream().forEach(c -> finalCriterion.getSubCriterias().add(reconductCriteria(c)));

                return finalCriterion;

            } else {

                CriteriaEntityPersisted finalCriterion = new CriteriaEntityPersisted();
                finalCriterion.setNomColonne(criterion.getNomColonne());
                finalCriterion.setOperateur(criterion.getOperateur());
                finalCriterion.setCriteriaLogicConnector(criterion.getCriteriaLogicConnector());

                finalCriterion.setCriteriaDateListValue(criterion.getCriteriaDateListValue());
                finalCriterion.setCriteriaDateLowerBound(criterion.getCriteriaDateLowerBound());
                finalCriterion.setCriteriaDateUpperBound(criterion.getCriteriaDateUpperBound());
                finalCriterion.setCriteriaDateValue(criterion.getCriteriaDateValue());

                finalCriterion.setCriteriaNumericListValue(criterion.getCriteriaNumericListValue());
                finalCriterion.setCriteriaNumericValue(criterion.getCriteriaNumericValue());
                finalCriterion.setCriteriaNumericLowerBound(criterion.getCriteriaNumericLowerBound());
                finalCriterion.setCriteriaNumericUpperBound(criterion.getCriteriaNumericUpperBound());

                finalCriterion.setCriteriaStringListValue(criterion.getCriteriaStringListValue());
                finalCriterion.setCriteriaStringValue(criterion.getCriteriaStringValue());
                finalCriterion.setCriteriaStringLowerBound(criterion.getCriteriaStringLowerBound());
                finalCriterion.setCriteriaStringUpperBound(criterion.getCriteriaStringUpperBound());

                return finalCriterion;
            }

        } else {

            return null;

        }
    }

}