/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Interface.java to edit this template
 */
package com.megatim.fdxcommons.dao.ifaces.abstracts;

import com.megatim.fdxcommons.dao.ifaces.utils.SearchCriteriaBuilderUtil;
import static com.megatim.fdxcommons.model.enumeration.SearchAnnotationOperateur.EQUALS;
import static com.megatim.fdxcommons.model.enumeration.SearchAnnotationOperateur.GREATER_OR_EQUALS_THAN;
import static com.megatim.fdxcommons.model.enumeration.SearchAnnotationOperateur.GREATER_THAN;
import static com.megatim.fdxcommons.model.enumeration.SearchAnnotationOperateur.IN;
import static com.megatim.fdxcommons.model.enumeration.SearchAnnotationOperateur.LESS_OR_EQUALS_THAN;
import static com.megatim.fdxcommons.model.enumeration.SearchAnnotationOperateur.LESS_THAN;
import static com.megatim.fdxcommons.model.enumeration.SearchAnnotationOperateur.LIKE;
import static com.megatim.fdxcommons.model.enumeration.SearchAnnotationOperateur.NOT_EQUALS;
import com.megatim.fdxcommons.model.search.SearchCriteria;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

/**
 *
 * @author ASUS
 */
public interface CustomDAOIfaces<T, ID, U> {

    default T save(T entity) {
        return getEntityManager().merge(entity);
    }

    default void delete(T entity) {
        getEntityManager().remove(entity);
    }

    public Class<T> getManagedEntityClass();

    public EntityManager getEntityManager();

    public T getById(ID id);

    public default long count(U searchEntity) {
        CriteriaBuilder qb = getEntityManager().getCriteriaBuilder();
        CriteriaQuery<Long> cq = qb.createQuery(Long.class);
        Root<T> root = cq.from(getManagedEntityClass());

        List<SearchCriteria> searchCriterias = SearchCriteriaBuilderUtil.getSearchCriterias(searchEntity, getManagedEntityClass(), root, new ArrayList<>());
        List<Predicate> predicates = createPedicates(searchCriterias, qb, root);

        cq.select(qb.count(root));
        cq.where(predicates.toArray(new Predicate[predicates.size()]));

        return (long) getEntityManager().createQuery(cq).getSingleResult();
    }

    public default List<T> getAll(U searchEntity) {
        CriteriaBuilder qb = getEntityManager().getCriteriaBuilder();
        CriteriaQuery<T> cq = qb.createQuery(getManagedEntityClass());

        Root<T> root = cq.from(getManagedEntityClass());

        List<SearchCriteria> searchCriterias = SearchCriteriaBuilderUtil.getSearchCriterias(searchEntity, getManagedEntityClass(), root, new ArrayList<>());

        List<Predicate> predicates = new ArrayList<>();

        try {
            predicates = createPedicates(searchCriterias, qb, root);
        } catch (Exception e) {
            e.printStackTrace();
        }

        cq.select(root);
        cq.where(predicates.toArray(new Predicate[predicates.size()]));

        return getEntityManager().createQuery(cq).getResultList();
    }

    public default List<T> findWithPagination(Integer pageNumber, Integer pagesize, U searchEntity) {
        CriteriaBuilder qb = getEntityManager().getCriteriaBuilder();
        CriteriaQuery<T> cq = qb.createQuery(getManagedEntityClass());

        Root<T> root = cq.from(getManagedEntityClass());

        List<SearchCriteria> searchCriterias = SearchCriteriaBuilderUtil.getSearchCriterias(searchEntity, getManagedEntityClass(), root, new ArrayList<>());

        List<Predicate> predicates = new ArrayList<>();

        try {
            predicates = createPedicates(searchCriterias, qb, root);
        } catch (Exception e) {
            e.printStackTrace();
        }

        cq.select(root);
        cq.where(predicates.toArray(new Predicate[predicates.size()]));

        TypedQuery<T> typedQuery = getEntityManager().createQuery(cq);

        typedQuery.setFirstResult((pageNumber - 1) * pagesize);
        typedQuery.setMaxResults(pagesize);

        return typedQuery.getResultList();
    }

    /**
     * Méthode qui les prédicats à partir des critères de recherche
     *
     * @param searchCriterias
     * @param cb
     * @param root
     * @return
     */
    public default List<Predicate> createPedicates(List<SearchCriteria> searchCriterias, CriteriaBuilder cb, Root<T> root) {
        List<Predicate> predicates = new ArrayList<>();

        searchCriterias.stream().forEach(s -> {

            if (s.getFieldValue() != null) {
                Predicate predicate = null;
                switch (s.getOperateur()) {
                    case EQUALS:
                        predicate = cb.equal(s.getFrom().get(s.getFieldName()), s.getFieldValue());
                        predicates.add(predicate);
                        break;

                    case NOT_EQUALS:
                        predicate = cb.notEqual(s.getFrom().get(s.getFieldName()), s.getFieldValue());
                        predicates.add(predicate);
                        break;

                    case LIKE:
                        if (s.getFieldValue() instanceof String) {
                            predicate = cb.like(s.getFrom().get(s.getFieldName()), "%" + s.getFieldValue().toString() + "%");
                            predicates.add(predicate);
                        }
                        break;

                    case GREATER_THAN:
                        if (s.getFieldValue() instanceof Number) {
                            predicate = cb.gt(s.getFrom().get(s.getFieldName()), (Number) s.getFieldValue());
                            predicates.add(predicate);

                        } else if (s.getFieldValue() instanceof LocalDate) {
                            predicate = cb.greaterThan(s.getFrom().get(s.getFieldName()), (LocalDate) s.getFieldValue());
                            predicates.add(predicate);
                        }
                        break;

                    case GREATER_OR_EQUALS_THAN:
                        if (s.getFieldValue() instanceof Number) {
                            predicate = cb.ge(root.get(s.getFieldName()), (Number) s.getFieldValue());
                            predicates.add(predicate);
                        } else if (s.getFieldValue() instanceof LocalDate) {
                            predicate = cb.greaterThanOrEqualTo(root.get(s.getFieldName()), (LocalDate) s.getFieldValue());
                            predicates.add(predicate);
                        }
                        break;

                    case LESS_THAN:
                        if (s.getFieldValue() instanceof Number) {
                            predicate = cb.lt(s.getFrom().get(s.getFieldName()), (Number) s.getFieldValue());
                            predicates.add(predicate);
                        } else if (s.getFieldValue() instanceof LocalDate) {
                            predicate = cb.lessThan(s.getFrom().get(s.getFieldName()), (LocalDate) s.getFieldValue());
                            predicates.add(predicate);
                        }
                        break;

                    case LESS_OR_EQUALS_THAN:
                        if (s.getFieldValue() instanceof Number) {
                            predicate = cb.le(s.getFrom().get(s.getFieldName()), (Number) s.getFieldValue());
                            predicates.add(predicate);
                        } else if (s.getFieldValue() instanceof LocalDate) {
                            predicate = cb.lessThanOrEqualTo(s.getFrom().get(s.getFieldName()), (LocalDate) s.getFieldValue());
                            predicates.add(predicate);
                        }
                        break;
                    case IN:
                        if (s.getFieldValue() instanceof java.util.Collection) {
                            predicate = s.getFrom().get(s.getFieldName()).in(s.getFieldValue());
                            predicates.add(predicate);
                        }
                        break;
                    default:

                }
            }
        });

        return predicates;
    }
}