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

import com.megatimfx.common.pojo.SearchCriteria;
import com.megatim.fdxconvert.service.pojo.PaginationElts;
import java.lang.reflect.Field;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import lombok.Getter;
import lombok.Setter;
import org.hibernate.Session;

/**
 *
 * @author mela
 */
@Getter
@Setter
public class AbstractDAO<T> {

    private Class<T> clazz;
    private PaginationElts pagination;

    public AbstractDAO(Class<T> clas) {
        clazz = clas;
        pagination = new PaginationElts();
    }

    public <T> T add(T element) {
        try ( Session session = HibernateUtil.getSessionFactory().openSession()) {
            session.beginTransaction();
            session.persist(element);
            session.getTransaction().commit();
            session.refresh(element);

            return element;
        }
    }

    public <T> T edit(T element) {
        try ( Session session = HibernateUtil.getSessionFactory().openSession()) {
            session.beginTransaction();
            session.update(element);
            session.getTransaction().commit();
            session.refresh(element);

            return element;
        }
    }

    public void delete(T element) {
        try ( Session session = HibernateUtil.getSessionFactory().openSession()) {
            session.beginTransaction();
            session.delete(element);
            session.getTransaction().commit();
        }
    }

    public void deleteAll(String tableName) {
        List<T> liste = getAll(tableName);
        try ( Session session = HibernateUtil.getSessionFactory().openSession()) {
            session.beginTransaction();
            liste.forEach(t -> session.delete(t));
            session.getTransaction().commit();
        }
    }

    public <Optional> T find(Object element) {
        try ( Session session = HibernateUtil.getSessionFactory().openSession()) {
            return session.find(clazz, element);
        }
    }

    public List<T> getAll(String tableName) {

        try ( Session session = HibernateUtil.getSessionFactory().openSession()) {

            List<T> liste = session.createQuery("from " + tableName).getResultList();

            return liste;

        }

    }

    public List<T> getAllByPage(int indexDebut, int numberOfElt, List<SearchCriteria> searchCriterias) {
        try ( Session session = HibernateUtil.getSessionFactory().openSession()) {
            CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
            CriteriaQuery<T> criteriaQuery = criteriaBuilder.createQuery(clazz);
            Root<T> root = criteriaQuery.from(clazz);
            List<Predicate> predicates = createPedicates(searchCriterias, criteriaBuilder, root);

            CriteriaQuery<T> cq = criteriaQuery.select(root);

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

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

            typedQuery.setFirstResult(indexDebut);
            typedQuery.setMaxResults(numberOfElt);
            List<T> liste = typedQuery.getResultList();

            return liste;
        }
    }

    private long count(List<SearchCriteria> searchCriterias) {
        try ( Session session = HibernateUtil.getSessionFactory().openSession()) {
            CriteriaBuilder qb = session.getCriteriaBuilder();
            CriteriaQuery<Long> cq = qb.createQuery(Long.class);
            Root<T> root = cq.from(clazz);
            List<Predicate> predicates = createPedicates(searchCriterias, qb, root);

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

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

    public PaginationElts initPaginationElts(int pageNumber, List<SearchCriteria> searchCriterias) {
        int indexDebut = pageNumber * pagination.getNbEltsPerPage();
        pagination.setListe(getAllByPage(indexDebut, pagination.getNbEltsPerPage(), searchCriterias));
        pagination.setTotalElts(count(searchCriterias));
        pagination.setPage(pageNumber);

        if (pageNumber == 0) {
            pagination.setNumberOfElts(pagination.getListe().size());
        } else {
            pagination.setNumberOfElts(pageNumber * pagination.getNbEltsPerPage() + pagination.getListe().size());
        }

        pagination.setNumberOfPage((pagination.getTotalElts() % pagination.getNbEltsPerPage() == 0) ? (pagination.getTotalElts() / pagination.getNbEltsPerPage())
                : (pagination.getTotalElts() / pagination.getNbEltsPerPage()) + 1);

        return pagination;
    }

    /**
     * Méthode qui retounre la liste des champs de la classe clazz
     *
     * @return
     */
    private Map<String, Field> getClassFields() {
        Field[] fields = clazz.getDeclaredFields();
        Map<String, Field> mapOfFields = new HashMap<>();
        for (Field field : fields) {
            mapOfFields.put(field.getName(), field);
        }

        return mapOfFields;
    }

    /**
     * Méthode qui vérifie que le champ "fieldValue" de l'objet searchCriteria
     * est du même type que le champ "fieldName" dans la classe clazz
     *
     * @param field : contient les informations sur le champ correspondant
     * @param value : valeur dont on veut vérifier le type
     * @return : retourne vrai sivalue est du même type que celui renseigné dans
     * field
     */
    private boolean isFieldAndValueOfSameType(Field field, Object value) {
        boolean result = true;
        try {
            field.getType().cast(value);
        } catch (ClassCastException ex) {
            result = false;
        }
        return result;
        //String className = field.getType().getName();
    }

    /**
     * Méthode qui filtre la liste des critères afin de ne garder que ceux qui
     * respectent le type du champ correspondant dans la classe et ceux dont le
     * fieldName correspond à un champ de la classe clazz
     *
     * @param searchCriterias
     * @return
     */
    private List<SearchCriteria> verifySearchCriteria(List<SearchCriteria> searchCriterias) {
        Map<String, Field> mapOfFields = getClassFields();

        //Retire les critères dont le fieldName ne correspond à aucun champ de la classe clazz
        for (SearchCriteria criteria : searchCriterias) {
            if (!mapOfFields.containsKey(criteria.getFieldName())) {
                searchCriterias.remove(criteria);
//                continue;
            }

//            Retire les critères dont le type de fieldValue ne correspond pas au type du champ dans la classe clazz
//            if(!isFieldAndValueOfSameType(mapOfFields.get(criteria.getFieldName()),criteria.getFieldValue())){
//                searchCriterias.remove(criteria);
//            }
        }
        return searchCriterias;
    }

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

        searchCriterias = verifySearchCriteria(searchCriterias);
        searchCriterias.parallelStream().forEach(s -> {
            Predicate predicate = null;
            switch (s.getOperateur()) {
                case EQUALS:
                    predicate = cb.equal(root.get(s.getFieldName()), s.getFieldValue());
                    predicates.add(predicate);
                    break;

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

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

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

                    } else if (s.getFieldValue() instanceof LocalDate) {
                        predicate = cb.greaterThan(root.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(root.get(s.getFieldName()), (Number) s.getFieldValue());
                        predicates.add(predicate);
                    } else if (s.getFieldValue() instanceof LocalDate) {
                        predicate = cb.lessThan(root.get(s.getFieldName()), (LocalDate)s.getFieldValue());
                        predicates.add(predicate);
                    }
                    break;

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

            }
        });

        return predicates;
    }
}