package com.megatim.fdxcommons.tools.database.queries.metadata;

import com.megatim.fdxcommons.model.enumeration.Operateur;
import com.megatim.fdxcommons.model.integration.ColumnDefinition;
import com.megatim.fdxcommons.model.integration.TableDefinition;
import com.megatim.fdxcommons.tools.database.exceptions.BadQueryCriteriaException;
import com.megatim.fdxcommons.tools.database.exceptions.LocalDateTimeValueParseError;
import com.megatim.fdxcommons.tools.database.tables.appcolumns.AppColumnDefinitions;
import com.megatim.fdxcommons.tools.database.tables.FdxTableColumn;
import com.megatim.fdxcommons.tools.database.tables.FdxTableColumns;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import javax.naming.NamingException;

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

    private final QueryCriterion queryCriterion;
    private final FdxTableColumns fdxTableColumns;
    private final List<ColumnDefinition> columnDefinitions;

    public ParsedQueryCriterion(QueryCriterion queryCriterion, FdxTableColumns fdxTableColumns, List<ColumnDefinition> columnDefinitions) {
        this.queryCriterion = queryCriterion;
        this.fdxTableColumns = fdxTableColumns;
        this.columnDefinitions = columnDefinitions;
    }

    public QueryCriterion parsedCriterion() throws SQLException, NamingException, LocalDateTimeValueParseError, BadQueryCriteriaException {
        return queryCriterion != null
                ? parsedCriterion(queryCriterion)
                : null;
    }

    private QueryCriterion parsedCriterion(QueryCriterion criterion) throws SQLException, NamingException, LocalDateTimeValueParseError, BadQueryCriteriaException {

        if (criterion == null) {
            return null;
        }

        if (criterion.getSubCriteria() != null && !criterion.getSubCriteria().isEmpty() && criterion.getCriteriaLogicConnector() != null) {
            List<QueryCriterion> subCriteria = new ArrayList<>();

            for (QueryCriterion qc : criterion.getSubCriteria()) {
                QueryCriterion parseCriterion = parsedCriterion(qc);

                if (parseCriterion != null) {
                    subCriteria.add(parseCriterion);
                }
            }
            if (!subCriteria.isEmpty()) {
                return new QueryCriterion(null,
                        null,
                        null,
                        criterion.getCriteriaLogicConnector(),
                        subCriteria
                );
            }

        } else if ((criterion.getSubCriteria() == null || criterion.getSubCriteria().isEmpty())
                && nomColonneIsValid(criterion.getNomColonne())
                && criterion.getOperateur() != null) {
            Object correctValue = correctValue(criterion.getNomColonne(), criterion.getCriteriaValue(), criterion.getOperateur());

            if (isUnaryOperator(criterion.getOperateur()) || (correctValue != null && !correctValue.toString().isEmpty())) {
                return new QueryCriterion(criterion.getNomColonne(),
                        correctValue,
                        criterion.getOperateur(),
                        null,
                        Arrays.asList()
                );
            }
        }

        throw new BadQueryCriteriaException("Critère non valide");
    }

    private boolean nomColonneIsValid(String nomColonne) throws SQLException, NamingException {
        return nomColonne != null && fdxTableColumns
                .columns()
                .stream()
                .filter(c -> c.getName().equalsIgnoreCase(nomColonne))
                .findFirst()
                .isPresent();
    }

    private Object correctValue(String nomColonne, Object value, Operateur operateur) throws SQLException, NamingException, LocalDateTimeValueParseError, BadQueryCriteriaException {

        if (value == null) {
            return null;
        }

        AppColumnDefinitions appColumnDefinitions = new AppColumnDefinitions();

        for (FdxTableColumn column : fdxTableColumns.columns()) {

            if (column.getName().equalsIgnoreCase(nomColonne)) {

                boolean isDateCreationColumn = appColumnDefinitions.isDateCreationColumn(column.getName());

                String dateFormat = columnDefinitions
                        .stream()
                        .filter(cD -> cD.getName().equalsIgnoreCase(nomColonne) && cD.getTypeDonnee().equals("DATE"))
                        .findFirst()
                        .map(cD -> cD.getFormatDate())
                        .orElse("");

                QueryCriteriaCorrectValue queryCriteriaCorrectValue = new QueryCriteriaCorrectValue(
                        column.getType(),
                        value,
                        operateur,
                        dateFormat,
                        isDateCreationColumn
                );

                return queryCriteriaCorrectValue.value();

            }

        }

        throw new BadQueryCriteriaException("Critères mal formattés");
    }

    private boolean isUnaryOperator(Operateur operateur) {
        return operateur.equals(Operateur.IS_NOT_NULL) || operateur.equals(Operateur.IS_NULL);
    }
}