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

import com.megatim.fdxcommons.model.enumeration.FonctionAggregation;
import com.megatim.fdxcommons.tools.database.connection.DBConnection;
import com.megatim.fdxcommons.tools.database.queries.metadata.QueryCriterion;
import com.megatim.fdxcommons.tools.database.tables.FdxTable;
import com.megatim.fdxcommons.tools.utils.CriteriaEntityFromViewToQueryCriterion;
import com.megatim.fdxconsultation.core.impl.factory.FdxConsultationTableFactory;
import com.megatim.fdxconsultation.model.dto.stats.StatListResult;
import com.megatim.fdxconsultation.model.dto.stats.StatResultDto;
import com.megatim.fdxconsultation.model.dto.stats.StatScalarResult;
import com.megatim.fdxconsultation.model.stats.TableConfiguration;
import com.megatim.fdxconsultation.model.stats.TableauBord;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.stream.Collectors;
import javax.sql.DataSource;

/**
 *
 * @author Gabuntu
 */
public class TableauBordResult {

    private final TableauBord tableauBord;
    private final DataSource dataSource;

    public TableauBordResult(TableauBord tableauBord, DataSource dataSource) {
        this.tableauBord = tableauBord;
        this.dataSource = dataSource;
    }

    public StatResultDto result() throws SQLException, Exception {

        StatResultDto statResultDto = new StatResultDto();
        statResultDto.setDescription(tableauBord.getDescription());

        try ( Connection connection = new DBConnection(dataSource).connection()) {
            FdxTable fdxTable = FdxConsultationTableFactory.createTable(
                    tableauBord.getTypeFichier().getCode(),
                    tableauBord.getReferentiel().getVersion(),
                    connection
            );

            for (TableConfiguration tableConfiguration : tableauBord.getTableConfigurations()) {

                List<String> groupingColumns = groupingColumns(tableConfiguration);
                FonctionAggregation fonctionAggregation = tableConfiguration.getFonctionAggregation();

                List<String[]> results
                        = tableConfiguration.getFonctionAggregation().equals(FonctionAggregation.COUNT)
                        ? fdxTable.count(queryCriterion(tableConfiguration), connection, groupingColumns)
                        : fdxTable.aggregate(connection,
                                tableConfiguration.getTargetedColumn().getName(),
                                groupingColumns, fonctionAggregation,
                                queryCriterion(tableConfiguration)
                        );

                if (!groupingColumns.isEmpty()) { //GROUPE

                    StatListResult statListResult = new StatListResult();
                    statListResult.setTypeResultatConfiguration(tableConfiguration.getTypeResultatConfiguration());
                    statListResult.setLibelle(tableConfiguration.getLibelle());

                    for (String[] result : results) {

                        StatScalarResult statScalarResult = new StatScalarResult();
                        statScalarResult.setValue(result[0]);

                        StringBuilder libelle = new StringBuilder();
                        for (int i = 1; i < result.length; i++) { //Colonnes d'aggrégration
                            libelle.append(result[i]);
                            if ((i + 1) < result.length) {
                                libelle.append(" - ");
                            }
                        }

                        statScalarResult.setLibelle(libelle.toString());
                        statListResult.getValues().add(statScalarResult);

                    }

                    statResultDto.getListResults().add(statListResult);

                } else { //ELEMENT

                    if (!results.isEmpty()) {

                        String[] result = results.get(0);

                        StatScalarResult statScalarResult = new StatScalarResult();
                        statScalarResult.setLibelle(tableConfiguration.getLibelle());
                        statScalarResult.setColor(tableConfiguration.getColor());
                        statScalarResult.setValue(result[0]);

                        statResultDto.getScalarResults().add(statScalarResult);

                    }

                }

            }
        }
        return statResultDto;

    }

    private QueryCriterion queryCriterion(TableConfiguration tableConfiguration) {
        return new CriteriaEntityFromViewToQueryCriterion(
                new ConvertedCriteriaEntityFromView(
                        tableConfiguration.getCriterion()
                ).criteriaEntityFromView()
        ).queryCriterion();
    }

    private List<String> groupingColumns(TableConfiguration tableConfiguration) {
        return tableConfiguration
                .getGroupingColumns()
                .stream()
                .map(c -> c.getName())
                .collect(Collectors.toList());
    }
}