package eu.eudat.queryable.hibernatequeryablelist;



import eu.eudat.queryable.QueryableList;
import eu.eudat.queryable.predicates.OrderByPredicate;
import eu.eudat.queryable.predicates.SelectPredicate;
import eu.eudat.queryable.predicates.SinglePredicate;

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;
import java.util.LinkedList;
import java.util.List;

public class QueryableHibernateList<T> implements QueryableList<T> {

    private EntityManager manager;
    private CriteriaQuery<T> query;
    private Class<T> tClass;
    private Root<T> root;
    private LinkedList<Predicate> predicates = new LinkedList<Predicate>();
    private Integer length;
    private Integer offset;
    public QueryableHibernateList(EntityManager manager, Class<T> tClass) {
        this.manager = manager;
        this.tClass = tClass;
    }

    public QueryableHibernateList<T> setManager(EntityManager manager) {
        this.manager = manager;
        return this;
    }

    public QueryableHibernateList<T> setEntity(Class<T> type) {
        CriteriaBuilder builder = this.manager.getCriteriaBuilder();
        this.query = builder.createQuery(type);
        this.root = this.query.from(this.tClass);
        return this;
    }

    public void initiateQueryableList(Class<T> type) {
        CriteriaBuilder builder = this.manager.getCriteriaBuilder();
        this.query = builder.createQuery(type);
    }

    @Override
    public QueryableList<T> skip(Integer offset) {
        this.offset = offset;
        return this;
    }

    @Override
    public QueryableList<T> take(Integer length) {
        this.length = length;
        return this;
    }

    public QueryableList<T> where(SinglePredicate<T> predicate) {
        this.predicates.add(predicate.applyPredicate(this.manager.getCriteriaBuilder(), this.root));
        return this;
    }

    public <R> List<R> select(SelectPredicate<T, R> predicate) {
        List<T> list = this.toList();
        List<R> newlist = new LinkedList<R>();
        for (T item : list) {
            newlist.add(predicate.applySelection(item));
        }
        return newlist;
    }

    public QueryableList<T> distinct() {
        this.query.distinct(true);
        return this;
    }

    public QueryableList<T> orderBy(OrderByPredicate<T> predicate) {
        this.query.orderBy(predicate.applyPredicate(this.manager.getCriteriaBuilder(), this.root));
        return this;
    }

    public List<T> toList() {
        Predicate[] array = new Predicate[this.predicates.size()];
        this.predicates.toArray(array);
        this.query.where(array);

        TypedQuery<T> typedQuery = this.manager.createQuery(this.query);
        if(this.offset!=null)typedQuery.setFirstResult(this.offset);
        if(this.length!=null)typedQuery.setMaxResults(this.length);
        return typedQuery.getResultList();
    }
}